active-fedora 3.2.2 → 3.3.0

data/lib/active_fedora/dcrdf_datastream.rb

@@ -0,0 +1,11 @@
+module ActiveFedora
+  class DCRDFDatastream < NtriplesRDFDatastream
+
+    # given a symbol, resolve the predicate as a RDF::URI
+    # if the predicate is not in DC, return nil 
+    def resolve_predicate(name)
+      RDF::DC.send(name) if RDF::DC.respond_to? name
+    end
+
+  end
+end

data/lib/active_fedora/delegating.rb

@@ -31,7 +31,7 @@ module ActiveFedora
         def create_delegate_accessor(field, args)
             define_method field do
               ds = self.send(args[:to])
-              val = if ds.kind_of? ActiveFedora::MetadataDatastream 
+              val = if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::DCRDFDatastream)
                 ds.send(:get_values, field)
               else 
                 terminology = args[:at] || [field]
@@ -45,7 +45,7 @@ module ActiveFedora
         def create_delegate_setter(field, args)
             define_method "#{field}=".to_sym do |v|
               ds = self.send(args[:to])
-              if ds.kind_of? ActiveFedora::MetadataDatastream 
+              if ds.kind_of?(ActiveFedora::MetadataDatastream) || ds.kind_of?(ActiveFedora::DCRDFDatastream)
                 ds.send(:set_value, field, v)
               else 
                 terminology = args[:at] || [field]

data/lib/active_fedora/metadata_datastream.rb

@@ -129,7 +129,8 @@ module ActiveFedora
               end
             end 
         
-            new_values.each do |y,z| 
+            new_values.keys.sort { |a,b| a.to_i <=> b.to_i }.each do |y| 
+              z = new_values[y]
               result[field_name].delete(y)
               current_values<<z #just append everything left
               new_array_index = current_values.length - 1
@@ -199,7 +200,7 @@ module ActiveFedora
       end
       
       builder = Nokogiri::XML::Builder.with(xml_insertion_point) do |xml|
-        fields.each_pair do |field,field_info|
+        fields.each do |field,field_info|
           element_attrs = field_info[:element_attrs].nil? ? {} : field_info[:element_attrs]
           values = field_info[:values]
           values = [values] unless values.respond_to? :each

data/lib/active_fedora/nested_attributes.rb

@@ -1,7 +1,6 @@
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/object/try'
 require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/indifferent_access'
 
 
 module ActiveFedora

data/lib/active_fedora/ntriples_rdf_datastream.rb

@@ -0,0 +1,19 @@
+require 'rdf/ntriples'
+
+module ActiveFedora
+  class NtriplesRDFDatastream < RDFDatastream
+
+    def serialization_format
+      :ntriples
+    end
+
+    def mimeType
+      'text/plain'
+    end
+
+    def controlGroup
+      'M'
+    end
+  end
+end
+

data/lib/active_fedora/predicates.rb

@@ -54,6 +54,10 @@ module ActiveFedora
       @@predicate_config ||= YAML::load(File.open(ActiveFedora.predicate_config)) if File.exist?(ActiveFedora.predicate_config)
     end
 
+    def self.predicate_namespaces
+      predicate_config[:predicate_namespaces] || {}
+    end
+    
     def self.predicate_mappings
       predicate_config[:predicate_mapping]
     end

data/lib/active_fedora/rdf_datastream.rb

@@ -0,0 +1,108 @@
+require 'rdf'
+
+module ActiveFedora
+  class RDFDatastream < Datastream
+    attr_accessor :loaded
+
+    def ensure_loaded
+      return if loaded 
+      self.loaded = true
+      unless new?
+        deserialize content
+      end
+    end
+    
+    def serialize! # :nodoc:
+      if graph.dirty
+        return unless loaded 
+        self.content = serialize
+      end
+    end
+
+    def graph
+      @graph ||= RelationshipGraph.new
+    end
+
+    def get_values(predicate)
+      ensure_loaded
+      predicate = resolve_predicate(predicate) unless predicate.kind_of? RDF::URI
+      results = graph[predicate]
+      res = []
+      results.each do |object|
+        res << (object.kind_of?(RDF::Literal) ? object.value : object.to_str)
+      end
+      res
+    end
+  
+    # if there are any existing statements with this predicate, replace them
+    def set_value(predicate, args)
+      ensure_loaded
+      predicate = resolve_predicate(predicate) unless predicate.kind_of? RDF::URI
+      graph.delete(predicate)
+      graph.add(predicate, args, true)
+    end
+
+    # append a value 
+    def append(predicate, args)
+      ensure_loaded
+      graph.add(predicate, args, true)
+    end
+
+
+
+    def method_missing(name, *args)
+      if pred = resolve_predicate(name) 
+        get_values(pred)
+      elsif (md = /^([^=]+)=$/.match(name.to_s)) && pred = resolve_predicate(md[1])
+        set_value(pred, *args)  
+      else 
+        super
+      end
+    end
+
+    def serialization_format
+      raise "you must override the `serialization_format' method in a subclass"
+    end
+
+    
+    # given a symbol or string, map it to a RDF::URI
+    # if the provided parameter is not allowed in the vocabulary, return nil
+    def resolve_predicate(predicate)
+      raise "you must override the `resolve_predicate' method in a subclass"
+    end
+
+    # Populate a RDFDatastream object based on the "datastream" content 
+    # Assumes that the datastream contains RDF XML from a Fedora RELS-EXT datastream 
+    # @param [ActiveFedora::MetadataDatastream] tmpl the Datastream object that you are populating
+    # @param [String] the "rdf" node 
+    def deserialize(data) 
+      unless data.nil?
+        RDF::Reader.for(serialization_format).new(data) do |reader|
+          reader.each_statement do |statement|
+            literal = statement.object.kind_of?(RDF::Literal)
+            object = literal ? statement.object.value : statement.object.to_str
+            graph.add(statement.predicate, object, literal)
+          end
+        end
+      end
+      graph
+    end
+
+    # Creates a RDF datastream for insertion into a Fedora Object
+    # @param [String] pid
+    # @param [Hash] relationships (optional) @default self.relationships
+    # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
+    def serialize()
+      out = RDF::Writer.for(serialization_format).buffer do |writer|
+        graph.to_graph("info:fedora/#{pid}").each_statement do |statement|
+          writer << statement
+        end
+      end
+      out
+    end
+    
+    
+  end
+
+end
+

data/lib/active_fedora/rdf_xml_writer.rb

@@ -9,61 +9,73 @@ module ActiveFedora
 # an rdf:type assertion is present; this is incompatible with Fedora
   class RDFXMLWriter < RDF::RDFXML::Writer
     def subject(subject, parent_node)
-      node = nil
       
       raise RDF::WriterError, "Illegal use of subject #{subject.inspect}, not supported in RDF/XML" unless subject.resource?
       
-      if !is_done?(subject)
-        subject_done(subject)
-        properties = @graph.properties(subject)
-        add_debug {"subject: #{subject.inspect}, props: #{properties.inspect}"}
+      node = if !is_done?(subject)
+        subject_not_done(subject, parent_node)
+      elsif @force_RDF_about.include?(subject)
+        force_about(subject, parent_node)
+      end
+      @force_RDF_about.delete(subject)
 
-        @graph.query(:subject => subject).each do |st|
-          raise RDF::WriterError, "Illegal use of predicate #{st.predicate.inspect}, not supported in RDF/XML" unless st.predicate.uri?
-        end
+      parent_node.add_child(node) if node
+    end
 
-        prop_list = order_properties(properties)
-        add_debug {"=> property order: #{prop_list.to_sentence}"}
+    private
 
-        qname = "rdf:Description"
-        prefixes[:rdf] = RDF.to_uri
+    def force_about(subject, parent_node)
+      add_debug {"subject: #{subject.inspect}, force about"}
+      node = Nokogiri::XML::Element.new("rdf:Description", parent_node.document)
+      if subject.is_a?(RDF::Node)
+        node["rdf:nodeID"] = subject.id
+      else
+        node["rdf:about"] = relativize(subject)
+      end
+      node
+    end
 
-        node = Nokogiri::XML::Element.new(qname, parent_node.document)
-        
-        if subject.is_a?(RDF::Node)
-          # Only need nodeID if it's referenced elsewhere
-          if ref_count(subject) > (@depth == 0 ? 0 : 1)
-            node["rdf:nodeID"] = subject.id
-          else
-            node.add_child(Nokogiri::XML::Comment.new(node.document, "Serialization for #{subject}")) if RDF::RDFXML::debug?
-          end
-        else
-          node["rdf:about"] = relativize(subject)
-        end
+    def subject_not_done(subject, parent_node)
+      subject_done(subject)
+      properties = @graph.properties(subject)
+      add_debug {"subject: #{subject.inspect}, props: #{properties.inspect}"}
+
+      @graph.query(:subject => subject).each do |st|
+        raise RDF::WriterError, "Illegal use of predicate #{st.predicate.inspect}, not supported in RDF/XML" unless st.predicate.uri?
+      end
 
-        prop_list.each do |prop|
-          prop_ref = RDF::URI.intern(prop)
-          
-          properties[prop].each do |object|
-            raise RDF::WriterError, "Illegal use of object #{object.inspect}, not supported in RDF/XML" unless object.resource? || object.literal?
+      prop_list = order_properties(properties)
+      add_debug {"=> property order: #{prop_list.to_sentence}"}
 
-            @depth += 1
-            predicate(prop_ref, object, node, properties[prop].length == 1)
-            @depth -= 1
-          end
-        end
-      elsif @force_RDF_about.include?(subject)
-        add_debug {"subject: #{subject.inspect}, force about"}
-        node = Nokogiri::XML::Element.new("rdf:Description", parent_node.document)
-        if subject.is_a?(RDF::Node)
+      qname = "rdf:Description"
+      prefixes[:rdf] = RDF.to_uri
+
+      node = Nokogiri::XML::Element.new(qname, parent_node.document)
+      
+      if subject.is_a?(RDF::Node)
+        # Only need nodeID if it's referenced elsewhere
+        if ref_count(subject) > (@depth == 0 ? 0 : 1)
           node["rdf:nodeID"] = subject.id
         else
-          node["rdf:about"] = relativize(subject)
+          node.add_child(Nokogiri::XML::Comment.new(node.document, "Serialization for #{subject}")) if RDF::RDFXML::debug?
         end
+      else
+        node["rdf:about"] = relativize(subject)
       end
-      @force_RDF_about.delete(subject)
 
-      parent_node.add_child(node) if node
+      prop_list.each do |prop|
+        prop_ref = RDF::URI.intern(prop)
+        
+        properties[prop].each do |object|
+          raise RDF::WriterError, "Illegal use of object #{object.inspect}, not supported in RDF/XML" unless object.resource? || object.literal?
+
+          @depth += 1
+          predicate(prop_ref, object, node, properties[prop].length == 1)
+          @depth -= 1
+        end
+      end
+      node
     end
+
   end
 end

data/lib/active_fedora/relationship_graph.rb

@@ -8,6 +8,10 @@ module ActiveFedora
       self.dirty = false
       self.relationships = {}
     end
+
+    def has_predicate?(predicate)
+      relationships.has_key? predicate
+    end
     
     def add(predicate, object, literal=false)
       unless relationships.has_key? predicate
@@ -20,8 +24,16 @@ module ActiveFedora
       end
     end
 
-    def delete(predicate, object)
+    # Remove the statement matching the predicate and object
+    # [predicate] the predicate to delete
+    # [object] the object to delete, if nil, all statements with this predicate are deleted.
+    def delete(predicate, object = nil)
       return unless relationships.has_key? predicate
+      if object.nil?
+        @dirty = true
+        relationships.delete(predicate)
+        return
+      end
       if relationships[predicate].include?(object)
         @dirty = true
         relationships[predicate].delete(object)
@@ -32,7 +44,6 @@ module ActiveFedora
       elsif object.is_a? String 
         relationships[predicate].delete_if{|obj| obj.respond_to?(:internal_uri) && obj.internal_uri == object}
       end
-
     end
 
     def [](predicate)
@@ -76,77 +87,10 @@ module ActiveFedora
         end
         object = RDF::URI.new(target)
       end
-      RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(predicate), object)
+      predicate = ActiveFedora::Predicates.find_graph_predicate(predicate) unless predicate.kind_of? RDF::URI
+      RDF::Statement.new(subject, predicate, object)
     
     end
 
-    # def find_graph_predicate(predicate)
-    #     #TODO, these could be cached
-    #     case predicate
-    #     when :has_model, "hasModel", :hasModel
-    #       xmlns="info:fedora/fedora-system:def/model#"
-    #       begin
-    #         rel_predicate = ActiveFedora::Predicates.predicate_lookup(predicate,xmlns)
-    #       rescue UnregisteredPredicateError
-    #         xmlns = nil
-    #         rel_predicate = nil
-    #       end
-    #     else
-    #       xmlns="info:fedora/fedora-system:def/relations-external#"
-    #       begin
-    #         rel_predicate = ActiveFedora::Predicates.predicate_lookup(predicate,xmlns)
-    #       rescue UnregisteredPredicateError
-    #         xmlns = nil
-    #         rel_predicate = nil
-    #       end
-    #     end
-    #     
-    #     unless xmlns && rel_predicate
-    #       rel_predicate, xmlns = ActiveFedora::Predicates.find_predicate(predicate)
-    #     end
-    #     self.class.vocabularies[xmlns][rel_predicate] 
-    # end
-    # def self.vocabularies
-    #   return @vocabularies if @vocabularies
-    #   @vocabularies = {}
-    #   predicate_mappings.keys.each { |ns| @vocabularies[ns] = RDF::Vocabulary.new(ns)}
-    #   @vocabularies
-    # end
-
-    # # If predicate is a symbol, looks up the predicate in the predicate_mappings
-    # # If predicate is not a Symbol, returns the predicate untouched
-    # # @raise UnregisteredPredicateError if the predicate is a symbol but is not found in the predicate_mappings
-    # def self.predicate_lookup(predicate,namespace="info:fedora/fedora-system:def/relations-external#")
-    #   if predicate.class == Symbol 
-    #     if predicate_mappings[namespace].has_key?(predicate)
-    #       return predicate_mappings[namespace][predicate]
-    #     else
-    #       raise ActiveFedora::UnregisteredPredicateError
-    #     end
-    #   end
-    #   return predicate
-    # end
-
-    # def self.predicate_config
-    #   @@predicate_config ||= YAML::load(File.open(ActiveFedora.predicate_config)) if File.exist?(ActiveFedora.predicate_config)
-    # end
-
-    # def self.predicate_mappings
-    #   predicate_config[:predicate_mapping]
-    # end
-
-    # def self.default_predicate_namespace
-    #   predicate_config[:default_namespace]
-    # end
-
-    # def self.find_predicate(predicate)
-    #   predicate_mappings.each do |namespace,predicates|
-    #     if predicates.fetch(predicate,nil)
-    #       return predicates[predicate], namespace
-    #     end
-    #   end
-    #   raise ActiveFedora::UnregisteredPredicateError, "Unregistered predicate: #{predicate.inspect}"
-    # end
-
   end
 end

data/lib/active_fedora/rels_ext_datastream.rb

@@ -46,17 +46,14 @@ module ActiveFedora
     end
 
     # Creates a RELS-EXT datastream for insertion into a Fedora Object
-    # @param [String] pid
-    # @param [Hash] relationships (optional) @default self.relationships
-    # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
     def to_rels_ext()
       xml = ActiveFedora::RDFXMLWriter.buffer do |writer|
+        writer.prefixes.merge! ActiveFedora::Predicates.predicate_namespaces
         model.relationships.each_statement do |statement|
           writer << statement
         end
       end
       xml
-
     end
 
     def self.short_predicate(predicate)