Class: ActiveFedora::RDFDatastream

Inherits:
Datastream
  • Object
show all
Includes:
ModelMethods
Defined in:
lib/active_fedora/rdf_datastream.rb

Direct Known Subclasses

NtriplesRDFDatastream, RdfxmlRDFDatastream

Defined Under Namespace

Modules: ModelMethods Classes: IndexObject, TermProxy

Instance Attribute Summary collapse

Attributes inherited from Datastream

#digital_object, #dirty, #last_modified

Instance Method Summary collapse

Methods inherited from Datastream

#add_ds_location, #add_mime_type, #create, from_xml, #initialize, #inspect, #new_object?, #profile_from_hash, #size, #solrize_profile, #to_param, #validate_content_present

Constructor Details

This class inherits a constructor from ActiveFedora::Datastream

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args) ⇒ Object 



288
289
290
291
292
293
294
295
296
 
# File 'lib/active_fedora/rdf_datastream.rb', line 288

def method_missing(name, *args)
  if (md = /^([^=]+)=$/.match(name.to_s)) && pred = find_predicate(md[1])
    set_value(pred, *args)  
   elsif pred = find_predicate(name)
    get_values(name)
  else 
    super
  end
end

Instance Attribute Details

#loaded ⇒ Object

Returns the value of attribute loaded.



148
149
150
 
# File 'lib/active_fedora/rdf_datastream.rb', line 148

def loaded
  @loaded
end

Instance Method Details

#append(predicate, args) ⇒ Object

append a value

Parameters:

  • predicate (Symbol, RDF::URI) —

    the predicate to insert into the graph



276
277
278
279
280
281
282
 
# File 'lib/active_fedora/rdf_datastream.rb', line 276

def append(predicate, args)
  ensure_loaded
  predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
  graph.add(predicate, args, true)
  graph.dirty = true
  return TermProxy.new(graph, predicate, args)
end

#content=(content) ⇒ Object 



173
174
175
176
177
 
# File 'lib/active_fedora/rdf_datastream.rb', line 173

def content=(content)
  super
  @graph = RelationshipGraph.new
  deserialize(content)
end

#deserialize(data) ⇒ Object

Populate a RDFDatastream object based on the “datastream” content Assumes that the datastream contains RDF content

Parameters:

  • data (String) —

    the “rdf” node



226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/active_fedora/rdf_datastream.rb', line 226

def deserialize(data)
  unless data.nil?
    RDF::Reader.for(serialization_format).new(data) do |reader|
      reader.each_statement do |statement|
        begin
          next unless statement.subject == rdf_subject
        rescue
        end
        literal = statement.object.kind_of?(RDF::Literal)
        object = literal ? statement.object.value : statement.object.to_s
        graph.add(statement.predicate, object, literal)
      end
    end
  end
  graph
end

#dirty? ⇒ Boolean

Returns:

  • (Boolean) 


158
159
160
 
# File 'lib/active_fedora/rdf_datastream.rb', line 158

def dirty?
  graph.dirty
end

#ensure_loaded ⇒ Object 



150
151
152
153
154
155
156
 
# File 'lib/active_fedora/rdf_datastream.rb', line 150

def ensure_loaded
  return if loaded 
  self.loaded = true
  unless new?
    deserialize content
  end
end

#fields ⇒ Object

returns a Hash, e.g.: => {:values => [], :type => :something, :behaviors => [], …}



180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/active_fedora/rdf_datastream.rb', line 180

def fields
  ensure_loaded
  field_map = {}
  graph.relationships.each do |predicate, values|
    vocab_sym, name = predicate.qname
    uri, vocab = self.class.vocabularies.select { |ns, v| v.__prefix__ == vocab_sym }.first
    next unless vocab

    config = self.class.config[:predicate_mapping][vocab.to_s]

    name, indexed_as = config.select { |k, v| name.to_s == v.to_s && k.to_s.split("__")[0] == self.class.prefix(name).to_s.split("__")[0]}.first
    next unless name and config.has_key?("#{name}__type".to_sym) and config.has_key?("#{name}__behaviors".to_sym)
    type = config["#{name}__type".to_sym]
    behaviors = config["#{name}__behaviors".to_sym]
    field_map[name.to_sym] = {:values => values.map {|v| v.to_s}, :type => type, :behaviors => behaviors}
  end
  field_map
end

#find_predicate(predicate) ⇒ Object

Parameters:

  • predicate (Symbol, RDF::URI) —

    the predicate to insert into the graph



217
218
219
220
221
 
# File 'lib/active_fedora/rdf_datastream.rb', line 217

def find_predicate(predicate)
  predicate = self.class.prefix(predicate) unless predicate.kind_of? RDF::URI
  result = ActiveFedora::Predicates.find_predicate(predicate)
  RDF::URI(result.reverse.join)
end

#get_values(predicate) ⇒ Object

Parameters:

  • predicate (Symbol, RDF::URI) —

    the predicate to insert into the graph



248
249
250
251
252
253
254
255
256
257
258
 
# File 'lib/active_fedora/rdf_datastream.rb', line 248

def get_values(predicate)
  ensure_loaded
  predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
  results = graph[predicate]
  return if results.nil?
  values = []
  results.each do |object|
    values << (object.kind_of?(RDF::Literal) ? object.value : object.to_s)
  end
  TermProxy.new(graph, predicate, values)
end

#graph ⇒ Object 



243
244
245
 
# File 'lib/active_fedora/rdf_datastream.rb', line 243

def graph
  @graph ||= RelationshipGraph.new
end

#rdf_subject ⇒ Object

Get the subject for this rdf/xml datastream



300
301
302
 
# File 'lib/active_fedora/rdf_datastream.rb', line 300

def rdf_subject
  @subject ||= self.class.rdf_subject.call(self)
end

#save ⇒ Object 



162
163
164
165
 
# File 'lib/active_fedora/rdf_datastream.rb', line 162

def save
  super
  graph.dirty = false
end

#serialization_format ⇒ Object 



284
285
286
 
# File 'lib/active_fedora/rdf_datastream.rb', line 284

def serialization_format
  raise "you must override the `serialization_format' method in a subclass"
end

#serialize ⇒ Object

Creates a RDF datastream for insertion into a Fedora Object Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array



306
307
308
309
310
311
312
313
314
 
# File 'lib/active_fedora/rdf_datastream.rb', line 306

def serialize
  out = RDF::Writer.for(serialization_format).buffer do |writer|
    graph.to_graph(rdf_subject).each_statement do |statement|
      writer << statement
    end
  end
  graph.dirty = false
  out
end

#serialize! ⇒ Object

:nodoc:



167
168
169
170
171
 
# File 'lib/active_fedora/rdf_datastream.rb', line 167

def serialize! # :nodoc:
  return unless dirty?
  return unless loaded
  self.content = serialize
end

#set_value(predicate, args) ⇒ Object

if there are any existing statements with this predicate, replace them

Parameters:

  • predicate (Symbol, RDF::URI) —

    the predicate to insert into the graph



262
263
264
265
266
267
268
269
270
271
272
 
# File 'lib/active_fedora/rdf_datastream.rb', line 262

def set_value(predicate, args)
  ensure_loaded
  predicate = find_predicate(predicate) unless predicate.kind_of? RDF::URI
  graph.delete(predicate)
  args = [args] unless args.respond_to? :each
  args.each do |arg|
    graph.add(predicate, arg, true) unless arg.empty?
  end
  graph.dirty = true
  return TermProxy.new(graph, predicate, args)
end

#to_solr(solr_doc = Hash.new) ⇒ Object

:nodoc:



199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/active_fedora/rdf_datastream.rb', line 199

def to_solr(solr_doc = Hash.new) # :nodoc:
  ensure_loaded
  fields.each do |field_key, field_info|
    values = field_info.fetch(:values, false)
    if values
      field_info[:behaviors].each do |index_type|
        field_symbol = ActiveFedora::SolrService.solr_name(field_key, field_info[:type], index_type)
        values = [values] unless values.respond_to? :each
        values.each do |val|    
          ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_symbol, val)         
        end
      end
    end
  end
  solr_doc
end