active-fedora 3.1.6 → 3.2.0.pre1

data/lib/active_fedora/metadata_datastream.rb

@@ -8,9 +8,10 @@ module ActiveFedora
   #   </fields>
   class MetadataDatastream < Datastream
     
-    # .to_solr (among other things) is provided by ActiveFedora::MetadataDatastreamHelper
     include ActiveFedora::MetadataDatastreamHelper
 
+    # .to_solr and .to_xml (among other things) are provided by ActiveFedora::MetadataDatastreamHelper
+    self.xml_model = ActiveFedora::MetadataDatastream    
 
     def update_attributes(params={},opts={})
       result = params.dup
@@ -143,29 +144,6 @@ module ActiveFedora
       tmpl.send(:dirty=, false)
       tmpl
     end
-
-    def to_xml(xml = Nokogiri::XML::Document.parse("<fields />")) #:nodoc:
-      if xml.instance_of?(Nokogiri::XML::Builder)
-        xml_insertion_point = xml.doc.root 
-      elsif xml.instance_of?(Nokogiri::XML::Document) 
-        xml_insertion_point = xml.root
-      else
-        xml_insertion_point = xml
-      end
-      
-      builder = Nokogiri::XML::Builder.with(xml_insertion_point) do |xml|
-        fields.each_pair 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
-          values.each do |val|
-            builder_arg = "xml.#{field}(val, element_attrs)"
-            eval(builder_arg)
-          end
-        end
-      end
-      return builder.to_xml
-    end
     
     # This method generates the various accessor and mutator methods on self for the datastream metadata attributes.
     # each field will have the 3 magic methods:

data/lib/active_fedora/metadata_datastream_helper.rb

@@ -7,6 +7,8 @@ module ActiveFedora::MetadataDatastreamHelper
   
   module ClassMethods
     
+    attr_accessor :xml_model
+    
     #get the Class's field list
     def fields
       @@classFields
@@ -20,15 +22,18 @@ module ActiveFedora::MetadataDatastreamHelper
   end
 
   def ensure_xml_loaded
-    return if xml_loaded
+    return if xml_loaded 
     self.xml_loaded = true
-    self.class.from_xml content, self
+    if new?
+      ## Load up the template
+      self.class.from_xml nil, self
+    else
+      self.class.from_xml content, self
+    end
   end
   
   def serialize! # :nodoc:
-    if dirty?
-      self.content = self.to_xml 
-    end
+    self.content = self.to_xml  ##TODO only do this when the xml will have changed to avoid a load of the datastream content. 
   end
 
   def to_solr(solr_doc = Hash.new) # :nodoc:
@@ -70,5 +75,27 @@ module ActiveFedora::MetadataDatastreamHelper
     end
   end
   
+  def to_xml(xml = Nokogiri::XML::Document.parse("<fields />")) #:nodoc:
+    if xml.instance_of?(Nokogiri::XML::Builder)
+      xml_insertion_point = xml.doc.root 
+    elsif xml.instance_of?(Nokogiri::XML::Document) 
+      xml_insertion_point = xml.root
+    else
+      xml_insertion_point = xml
+    end
+    
+    builder = Nokogiri::XML::Builder.with(xml_insertion_point) do |xml|
+      fields.each_pair 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
+        values.each do |val|
+          builder_arg = "xml.#{field}(val, element_attrs)"
+          eval(builder_arg)
+        end
+      end
+    end
+    return builder.to_xml
+  end
 
 end

data/lib/active_fedora/named_relationships.rb

@@ -0,0 +1,95 @@
+module ActiveFedora
+  module NamedRelationships
+    extend ActiveSupport::Concern
+    included do
+      class_attribute :class_named_relationships_desc
+      self.class_named_relationships_desc = {}
+    end
+
+      # ** EXPERIMENTAL **
+      # 
+      # Check to make sure a subject,name, and predicate triple does not already exist
+      # with the same subject but different name.
+      # This method is used to ensure conflicting has_relationship calls are not made because
+      # predicates cannot be reused across relationship names.  Otherwise, the mapping of relationship name
+      # to predicate in RELS-EXT would be broken.
+      def named_predicate_exists_with_different_name?(subject,name,predicate)
+        if named_relationships_desc.has_key?(subject)
+          named_relationships_desc[subject].each_pair do |existing_name, args|
+            return true if !args[:predicate].nil? && args[:predicate] == predicate && existing_name != name 
+          end
+        end
+        return false
+      end
+      
+      # ** EXPERIMENTAL **
+      #  
+      # Return hash that stores named relationship metadata defined by has_relationship calls
+      # ====Example
+      # For the following relationship
+      #
+      #  has_relationship "audio_records", :has_part, :type=>AudioRecord
+      # Results in the following returned by named_relationships_desc
+      #  {:self=>{"audio_records"=>{:type=>AudioRecord, :singular=>nil, :predicate=>:has_part, :inbound=>false}}}
+      def named_relationships_desc
+        @class_named_relationships_desc ||= Hash[:self => {}]
+        #class_named_relationships_desc
+      end
+      
+      # ** EXPERIMENTAL **
+      #   
+      # Internal method that ensures a relationship subject such as :self and :inbound
+      # exist within the named_relationships_desc hash tracking named relationships metadata. 
+      def register_named_subject(subject)
+        unless named_relationships_desc.has_key?(subject) 
+          named_relationships_desc[subject] = {} 
+        end
+      end
+  
+      # ** EXPERIMENTAL **
+      # 
+      # Internal method that adds relationship name and predicate pair to either an outbound (:self)
+      # or inbound (:inbound) relationship types.
+      def register_named_relationship(subject, name, predicate, opts)
+        register_named_subject(subject)
+        opts.merge!({:predicate=>predicate})
+        named_relationships_desc[subject][name] = opts
+      end
+      
+      # ** EXPERIMENTAL **
+      #   
+      # Used in has_relationship call to create dynamic helper methods to 
+      # append and remove objects to and from a named relationship
+      # ====Example
+      # For the following relationship
+      #
+      #  has_relationship "audio_records", :has_part, :type=>AudioRecord
+      #
+      # Methods audio_records_append and audio_records_remove are created.
+      # Boths methods take an object that is kind_of? ActiveFedora::Base as a parameter
+      def create_named_relationship_methods(name)
+        append_method_name = "#{name.to_s.downcase}_append"
+        remove_method_name = "#{name.to_s.downcase}_remove"
+        self.send(:define_method,:"#{append_method_name}") {|object| add_named_relationship(name,object)}
+        self.send(:define_method,:"#{remove_method_name}") {|object| remove_named_relationship(name,object)}
+      end 
+
+      #  ** EXPERIMENTAL **
+      #  Similar to +create_named_relationship_methods+ except we are merely creating an alias for outbound portion of bidirectional
+      #
+      #  ====Example
+      #    has_bidirectional_relationship "members", :has_collection_member, :is_member_of_collection
+      #    
+      #    Method members_outbound_append and members_outbound_remove added
+      #    This method will create members_append which does same thing as members_outbound_append
+      #    and will create members_remove which does same thing as members_outbound_remove
+      def create_bidirectional_named_relationship_methods(name,outbound_name)
+        append_method_name = "#{name.to_s.downcase}_append"
+        remove_method_name = "#{name.to_s.downcase}_remove"
+        self.send(:define_method,:"#{append_method_name}") {|object| add_named_relationship(outbound_name,object)}
+        self.send(:define_method,:"#{remove_method_name}") {|object| remove_named_relationship(outbound_name,object)}
+      end
+
+    
+  end
+end

data/lib/active_fedora/nested_attributes.rb

@@ -8,7 +8,7 @@ module ActiveFedora
   module NestedAttributes #:nodoc:
     extend ActiveSupport::Concern
     included do
-      class_inheritable_accessor :nested_attributes_options, :instance_writer => false
+      class_attribute :nested_attributes_options, :instance_writer => false
       self.nested_attributes_options = {}
     end
 

data/lib/active_fedora/predicates.rb

@@ -0,0 +1,76 @@
+module ActiveFedora
+
+  module Predicates
+    def self.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 = predicate_lookup(predicate,xmlns)
+          rescue UnregisteredPredicateError
+            xmlns = nil
+            rel_predicate = nil
+          end
+        else
+          xmlns="info:fedora/fedora-system:def/relations-external#"
+          begin
+            rel_predicate = predicate_lookup(predicate,xmlns)
+          rescue UnregisteredPredicateError
+            xmlns = nil
+            rel_predicate = nil
+          end
+        end
+        
+        unless xmlns && rel_predicate
+          rel_predicate, xmlns = find_predicate(predicate)
+        end
+        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/reflection.rb

@@ -2,6 +2,13 @@ module ActiveFedora
   module Reflection # :nodoc:
     extend ActiveSupport::Concern
 
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+
+
     module ClassMethods
       def create_reflection(macro, name, options, active_fedora)
         case macro
@@ -9,7 +16,8 @@ module ActiveFedora
             klass = AssociationReflection
             reflection = klass.new(macro, name, options, active_fedora)
         end
-        write_inheritable_hash :reflections, name => reflection
+
+        self.reflections = self.reflections.merge(name => reflection)
         reflection
       end
 

data/lib/active_fedora/relationship.rb

@@ -5,6 +5,7 @@ module ActiveFedora
     
     attr_accessor :subject, :predicate, :object, :is_literal, :data_type
     def initialize(attr={})
+      ActiveSupport::Deprecation.warn("ActiveFedora::Releationship is deprecated and will be removed in the next release")
       attr = {:is_literal => false}.merge(attr)
       @is_literal = attr[:is_literal] # must happen first
       self.subject = attr[:subject]

data/lib/active_fedora/relationship_graph.rb

@@ -0,0 +1,152 @@
+module ActiveFedora
+  class RelationshipGraph
+
+    attr_accessor :relationships, :dirty
+
+
+    def initialize
+      self.dirty = false
+      self.relationships = {}
+    end
+    
+    def add(predicate, object, literal=false)
+      unless relationships.has_key? predicate
+        relationships[predicate] = []
+      end
+      object = RDF::Literal.new(object) if literal
+      unless relationships[predicate].include?(object)
+        @dirty = true
+        relationships[predicate] << object
+      end
+    end
+
+    def delete(predicate, object)
+      return unless relationships.has_key? predicate
+      if relationships[predicate].include?(object)
+        @dirty = true
+        relationships[predicate].delete(object)
+      end
+      if object.respond_to?(:internal_uri) && relationships[predicate].include?(object.internal_uri)
+        @dirty = true
+        relationships[predicate].delete(object.internal_uri)
+      elsif object.is_a? String 
+        relationships[predicate].delete_if{|obj| obj.respond_to?(:internal_uri) && obj.internal_uri == object}
+      end
+
+    end
+
+    def [](predicate)
+      relationships[predicate]
+    end
+    
+    def to_graph(subject_uri)
+      # need to destroy relationships and rewrite it.
+      subject =  RDF::URI.new(subject_uri)
+      graph = RDF::Graph.new
+      relationships.each do |predicate, values|
+        values.each do |object|
+          graph.insert build_statement(subject,  predicate, object)
+        end
+      end
+
+      graph
+    end
+
+    # Create an RDF statement
+    # @param uri a string represending the subject
+    # @param predicate a predicate symbol
+    # @param target an object to store
+    def build_statement(uri, predicate, target)
+      raise "Not allowed anymore" if uri == :self
+      target = target.internal_uri if target.respond_to? :internal_uri
+      subject =  RDF::URI.new(uri)  #TODO cache
+      if target.is_a? RDF::Literal or target.is_a? RDF::Resource
+        object = target
+      else
+        begin
+          target_uri = (target.is_a? URI) ? target : URI.parse(target)
+          if target_uri.scheme.nil?
+            raise ArgumentError, "Invalid target \"#{target}\". Must have namespace."
+          end
+          if target_uri.to_s =~ /\A[\w\-]+:[\w\-]+\Z/
+            raise ArgumentError, "Invalid target \"#{target}\". Target should be a complete URI, and not a pid."
+          end
+        rescue URI::InvalidURIError
+          raise ArgumentError, "Invalid target \"#{target}\". Target must be specified as a literal, or be a valid URI."
+        end
+        object = RDF::URI.new(target)
+      end
+      RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(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