active-fedora 2.3.4 → 2.3.7

data/lib/active_fedora/semantic_node.rb

@@ -1,13 +1,17 @@
+require 'active_fedora/relationships_helper'
+
 module ActiveFedora
   module SemanticNode 
     include MediaShelfClassLevelInheritableAttributes
-    ms_inheritable_attributes  :class_relationships, :internal_uri, :class_named_relationships_desc
     
-    attr_accessor :internal_uri, :named_relationship_desc, :relationships_are_dirty, :load_from_solr
+    ms_inheritable_attributes  :class_relationships, :internal_uri
+    
+    attr_accessor :internal_uri, :relationships_are_dirty, :load_from_solr
     
 
     def self.included(klass)
       klass.extend(ClassMethods)
+      klass.send(:include, ActiveFedora::RelationshipsHelper)
     end
 
     def assert_kind_of(n, o,t)
@@ -39,23 +43,6 @@ module ActiveFedora
         relationships[subject][predicate] = []
       end
     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. 
-    # This method just calls the class method counterpart of this method.
-    def register_named_subject(subject)
-      self.class.register_named_subject(subject)
-    end
-  
-    # ** EXPERIMENTAL **
-    # 
-    # Internal method that adds relationship name and predicate pair to either an outbound (:self)
-    # or inbound (:inbound) relationship types.  This method just calls the class method counterpart of this method.
-    def register_named_relationship(subject, name, predicate, opts)
-      self.class.register_named_relationship(subject, name, predicate, opts)
-    end
 
     # ** EXPERIMENTAL **
     # 
@@ -89,7 +76,7 @@ module ActiveFedora
 
     def inbound_relationships(response_format=:uri)
       rel_values = {}
-      inbound_named_relationship_predicates.each_pair do |name,predicate|
+      inbound_relationship_predicates.each_pair do |name,predicate|
         objects = self.send("#{name}",{:response_format=>response_format})
         items = []
         objects.each do |object|
@@ -134,266 +121,6 @@ module ActiveFedora
       return rels
     end
     
-    # ** EXPERIMENTAL **
-    # 
-    # Return array of objects for a given relationship name
-    def named_relationship(name)
-      rels = nil
-      if inbound_relationship_names.include?(name)
-        rels = named_relationships(false)[:inbound][name]
-      elsif outbound_relationship_names.include?(name)
-        rels = named_relationships[:self][name]
-      end
-      rels = [] if rels.nil?
-      return rels
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Gets the named relationships hash of subject=>name=>object_array
-    # It has an optional parameter of outbound_only that defaults true.
-    # If false it will include inbound relationships in the results.
-    # Also, it will only reload outbound relationships if the relationships hash has changed
-    # since the last time this method was called.
-    def named_relationships(outbound_only=true)
-      #make sure to update if relationships have been updated
-      if @relationships_are_dirty == true
-        @named_relationships = named_relationships_from_class()
-        @relationships_are_dirty = false
-      end
-      
-      #this will get called normally on first fetch if relationships are not dirty
-      @named_relationships ||= named_relationships_from_class()
-      outbound_only ? @named_relationships : @named_relationships.merge(:inbound=>named_inbound_relationships)      
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Gets named relationships from the class using the current relationships hash
-    # and relationship name,predicate pairs.
-    def named_relationships_from_class()
-      rels = {}
-      named_relationship_predicates.each_pair do |subj, names|
-        if relationships.has_key?(subj)
-          rels[subj] = {}
-          names.each_pair do |name, predicate|
-            rels[subj][name] = (relationships[subj].has_key?(predicate) ? relationships[subj][predicate] : [])
-          end
-        end
-      end
-      return rels
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash of named_relationships defined within other objects' RELS-EXT
-    # It returns a hash of relationship name to arrays of objects.  It requeries
-    # solr each time this method is called.
-    def named_inbound_relationships
-      rels = {}
-      if named_relationships_desc.has_key?(:inbound)&&!named_relationships_desc[:inbound].empty?()
-        inbound_rels = inbound_relationships
-      
-        if named_relationship_predicates.has_key?(:inbound)
-          named_relationship_predicates[:inbound].each do |name, predicate|
-            rels[name] = inbound_rels.has_key?(predicate) ? inbound_rels[predicate] : []
-          end
-        end
-      end
-      return rels
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash of outbound relationship names and predicate pairs
-    def outbound_named_relationship_predicates
-      named_relationship_predicates.has_key?(:self) ? named_relationship_predicates[:self] : {}
-    end
-
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash of inbound relationship names and predicate pairs
-    def inbound_named_relationship_predicates
-      named_relationship_predicates.has_key?(:inbound) ? named_relationship_predicates[:inbound] : {}
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash of relationship names and predicate pairs
-    def named_relationship_predicates
-      @named_relationship_predicates ||= named_relationship_predicates_from_class
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash of relationship names and predicate pairs from class
-    def named_relationship_predicates_from_class
-      rels = {}
-      named_relationships_desc.each_pair do |subj, names|
-        rels[subj] = {}
-        names.each_pair do |name, args|
-          rels[subj][name] = args[:predicate]
-        end
-      end
-      return rels
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return array all relationship names
-    def relationship_names
-      names = []
-      named_relationships_desc.each_key do |subject|
-            names = names.concat(named_relationships_desc[subject].keys)
-        end
-        names
-    end
-
-    # ** EXPERIMENTAL **
-    # 
-    # Return array of relationship names for all named inbound relationships (coming from other objects' RELS-EXT and Solr)
-    def inbound_relationship_names
-        named_relationships_desc.has_key?(:inbound) ? named_relationships_desc[:inbound].keys : []
-    end
-
-    # ** EXPERIMENTAL **
-    # 
-    # Return array of relationship names for all named outbound relationships (coming from this object's RELS-EXT)
-    def outbound_relationship_names
-        named_relationships_desc.has_key?(:self) ? named_relationships_desc[:self].keys : []
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash of named_relationships defined within this object's RELS-EXT
-    # It returns a hash of relationship name to arrays of objects
-    def named_outbound_relationships
-        named_relationships_desc.has_key?(:self) ? named_relationships[:self] : {}
-    end
-  
-    # ** EXPERIMENTAL **
-    # 
-    # Returns true if the given relationship name is a named relationship
-    # ====Parameters
-    #  name: Name of relationship
-    #  outbound_only:  If false checks inbound relationships as well (defaults to true)
-    def is_named_relationship?(name, outbound_only=true)
-      if outbound_only
-        outbound_relationship_names.include?(name)
-      else
-        (outbound_relationship_names.include?(name)||inbound_relationship_names.include?(name))
-      end
-    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
-      @named_relationships_desc ||= named_relationships_desc_from_class
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Get class instance variable named_relationships_desc that holds has_relationship metadata
-    def named_relationships_desc_from_class
-      self.class.named_relationships_desc
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return the value of :type for the relationship for name passed in.
-    # It defaults to ActiveFedora::Base.
-    def named_relationship_type(name)
-      if is_named_relationship?(name,true)
-        subject = outbound_relationship_names.include?(name)? :self : :inbound
-        if named_relationships_desc[subject][name].has_key?(:type)
-          return class_from_name(named_relationships_desc[subject][name][:type])
-        end
-      end
-      return nil  
-    end
-
-    # ** EXPERIMENTAL **
-    # 
-    # Add an outbound relationship for given named relationship
-    # See ActiveFedora::SemanticNode::ClassMethods.has_relationship
-    def add_named_relationship(name, object)
-      if is_named_relationship?(name,true)
-        if named_relationships_desc[:self][name].has_key?(:type)
-          klass = class_from_name(named_relationships_desc[:self][name][:type])
-          unless klass.nil?
-            (assert_kind_of_model 'object', object, klass)
-          end
-        end
-        #r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>outbound_named_relationship_predicates[name],:object=>object})
-        #add_relationship(r)
-        add_relationship(outbound_named_relationship_predicates[name],object)
-      else
-        false
-      end
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Remove an object from the named relationship
-    def remove_named_relationship(name, object)
-      if is_named_relationship?(name,true)
-        remove_relationship(outbound_named_relationship_predicates[name],object)
-      else
-        return false
-      end
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Throws an assertion error if kind_of_model? returns false for object and model_class
-    # ====Parameters
-    #  name: Name of object (just label for output)
-    #  object: The object to test
-    #  model_class: The model class used to in kind_of_model? check on object
-    def assert_kind_of_model(name, object, model_class)
-      raise "Assertion failure: #{name}: #{object.pid} does not have model #{model_class}, it has model #{relationships[:self][:has_model]}" unless object.kind_of_model?(model_class)
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Checks that this object is matches the model class passed in.
-    # It requires two steps to pass to return true
-    #   1. It has a hasModel relationship of the same model
-    #   2. kind_of? returns true for the model passed in
-    # This method can most often be used to detect if an object from Fedora that was created
-    # with a different model was then used to populate this object.
-    def kind_of_model?(model_class)
-      if self.kind_of?(model_class)
-        #check has model and class match
-        if relationships[:self].has_key?(:has_model)
-          r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:has_model, :object=>ActiveFedora::ContentModel.pid_from_ruby_class(self.class))
-          if relationships[:self][:has_model].first.to_s.eql?(r.object.to_s)
-            return true
-          else
-            raise "has_model relationship check failed for model #{model_class} raising exception, expected: '#{r.object.to_s}' actual: '#{relationships[:self][:has_model].to_s}'"
-          end
-        else
-          raise "has_model relationship does not exist for model #{model_class} check raising exception"
-        end
-      else
-       raise "kind_of? check failed for model #{model_class}, actual #{self.class} raising exception"
-     end
-     return false
-   end
-    
-    def class_from_name(name)
-      klass = name.to_s.split('::').inject(Kernel) {|scope, const_name| 
-      scope.const_get(const_name)}
-      (!klass.nil? && klass.is_a?(::Class)) ? klass : nil
-    end
-    
     # Creates a RELS-EXT datastream for insertion into a Fedora Object
     # @param [String] pid
     # @param [Hash] relationships (optional) @default self.relationships
@@ -448,17 +175,21 @@ module ActiveFedora
       end
       xml.to_s
     end
-    
+
     module ClassMethods
-    
+      #include ActiveFedora::RelationshipsHelper::ClassMethods
+
       # Allows for a relationship to be treated like any other attribute of a model class. You define
-      # named relationships in your model class using this method.  You then have access to several
+      # relationships in your model class using this method.  You then have access to several
       # helper methods to list, append, and remove objects from the list of relationships. 
       # ====Examples to define two relationships 
       #  class AudioRecord < ActiveFedora::Base
       #
       #   has_relationship "oral_history", :has_part, :inbound=>true, :type=>OralHistory
+      #   # returns all similar audio
       #   has_relationship "similar_audio", :has_part, :type=>AudioRecord
+      #   #returns only similar audio with format wav
+      #   has_relationship "similar_audio_wav", :has_part, :solr_fq=>"format_t:wav"
       #
       # The first two parameters are required:
       #   name: relationship name
@@ -467,6 +198,7 @@ module ActiveFedora
       #     possible parameters  
       #       :inbound => if true loads an external relationship via Solr (defaults to false)
       #       :type => The type of model to use when instantiated an object from the pid in this relationship (defaults to ActiveFedora::Base)
+      #       :solr_fq => Define a solr query here if you want to filter out some objects in your relationship (must be a properly formatted solr query)
       #
       # If inbound is true it expects the relationship to be defined by another object's RELS-EXT
       # and to load that relationship from Solr.  Otherwise, if inbound is true the relationship is stored in
@@ -478,25 +210,27 @@ module ActiveFedora
       # For the oral_history relationship in the example above the following helper methods are created:
       #  oral_history: returns array of OralHistory objects that have this AudioRecord with predicate :has_part 
       #  oral_history_ids: Return array of pids for OralHistory objects that have this AudioRecord with predicate :has_part
+      #  oral_history_query: Return solr query that can be used to retrieve related objects as solr documents
       # 
       # For the outbound relationship "similar_audio" there are two additional methods to append and remove objects from that relationship
       # since it is managed internally:
       #  similar_audio: Return array of AudioRecord objects that have been added to similar_audio relationship
       #  similar_audio_ids:  Return array of AudioRecord object pids that have been added to similar_audio relationship
+      #  similar_audio_query: Return solr query that can be used to retrieve related objects as solr documents
       #  similar_audio_append: Add an AudioRecord object to the similar_audio relationship
       #  similar_audio_remove: Remove an AudioRecord from the similar_audio relationship
       def has_relationship(name, predicate, opts = {})
         opts = {:singular => nil, :inbound => false}.merge(opts)
         if opts[:inbound] == true
-          raise "Duplicate use of predicate for named inbound relationship not allowed" if named_predicate_exists_with_different_name?(:inbound,name,predicate)
-          register_named_relationship(:inbound, name, predicate, opts)
+          #raise "Duplicate use of predicate for inbound relationship name not allowed" if predicate_exists_with_different_relationship_name?(:inbound,name,predicate)
+          register_relationship_desc(:inbound, name, predicate, opts)
           register_predicate(:inbound, predicate)
           create_inbound_relationship_finders(name, predicate, opts)
         else
-          raise "Duplicate use of predicate for named outbound relationship not allowed" if named_predicate_exists_with_different_name?(:self,name,predicate)
-          register_named_relationship(:self, name, predicate, opts)
+          #raise "Duplicate use of predicate for outbound relationship name not allowed" if predicate_exists_with_different_relationship_name?(:self,name,predicate)
+          register_relationship_desc(:self, name, predicate, opts)
           register_predicate(:self, predicate)
-          create_named_relationship_methods(name)
+          create_relationship_name_methods(name)
           create_outbound_relationship_finders(name, predicate, opts)
         end
       end
@@ -519,96 +253,14 @@ module ActiveFedora
       def has_bidirectional_relationship(name, outbound_predicate, inbound_predicate, opts={})
         create_bidirectional_relationship_finders(name, outbound_predicate, inbound_predicate, opts)
       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 => {}]
-      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
     
       def create_inbound_relationship_finders(name, predicate, opts = {})
         class_eval <<-END
         def #{name}(opts={})
           opts = {:rows=>25}.merge(opts)
-          escaped_uri = self.internal_uri.gsub(/(:)/, '\\:')
-          solr_result = SolrService.instance.conn.query("#{predicate}_s:\#{escaped_uri}", :rows=>opts[:rows])
+          query = self.class.inbound_relationship_query(self.pid,"#{name}")
+          return [] if query.empty?
+          solr_result = SolrService.instance.conn.query(query, :rows=>opts[:rows])
           if opts[:response_format] == :solr
             return solr_result
           else
@@ -631,6 +283,9 @@ module ActiveFedora
         def #{name}_from_solr
           #{name}(:response_format => :load_from_solr)
         end
+        def #{name}_query
+          relationship_query("#{name}")
+        end
         END
       end
     
@@ -643,13 +298,19 @@ module ActiveFedora
               id_array << rel.gsub("info:fedora/", "")
             end
           end
-          if opts[:response_format] == :id_array
+          if opts[:response_format] == :id_array && !self.class.relationship_has_solr_filter_query?(:self,"#{name}")
             return id_array
           else
-            query = ActiveFedora::SolrService.construct_query_for_pids(id_array)
+            query = self.class.outbound_relationship_query("#{name}",id_array)
             solr_result = SolrService.instance.conn.query(query)
             if opts[:response_format] == :solr
               return solr_result
+            elsif opts[:response_format] == :id_array
+              id_array = []
+              solr_result.hits.each do |hit|
+                id_array << hit[SOLR_DOCUMENT_ID]
+              end
+              return id_array
             elsif opts[:response_format] == :load_from_solr || self.load_from_solr
               return ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
             else
@@ -663,6 +324,9 @@ module ActiveFedora
         def #{name}_from_solr
           #{name}(:response_format => :load_from_solr)
         end
+        def #{name}_query
+          relationship_query("#{name}")
+        end
         END
       end
       
@@ -680,18 +344,21 @@ module ActiveFedora
         has_relationship(inbound_method_name, inbound_predicate, opts.merge!(:inbound=>true))
 
         #create methods that mirror the outbound append and remove with our bidirectional name, assume just add and remove locally        
-        create_bidirectional_named_relationship_methods(name,outbound_method_name)
+        create_bidirectional_relationship_name_methods(name,outbound_method_name)
 
         class_eval <<-END
         def #{name}(opts={})
           opts = {:rows=>25}.merge(opts)
           if opts[:response_format] == :solr || opts[:response_format] == :load_from_solr
-            escaped_uri = self.internal_uri.gsub(/(:)/, '\\:')
-            query = "#{inbound_predicate}_s:\#{escaped_uri}"
-            
-            outbound_id_array = #{outbound_method_name}(:response_format=>:id_array)
-            query = query + " OR " + ActiveFedora::SolrService.construct_query_for_pids(outbound_id_array)
-            
+            outbound_id_array = []
+            predicate = outbound_relationship_predicates["#{name}_outbound"]
+            if !outbound_relationships[predicate].nil? 
+              outbound_relationships[predicate].each do |rel|
+                outbound_id_array << rel.gsub("info:fedora/", "")
+              end
+            end
+            #outbound_id_array = #{outbound_method_name}(:response_format=>:id_array)
+            query = self.class.bidirectional_relationship_query(self.pid,"#{name}",outbound_id_array)
             solr_result = SolrService.instance.conn.query(query, :rows=>opts[:rows])
             
             if opts[:response_format] == :solr
@@ -712,6 +379,9 @@ module ActiveFedora
         def #{name}_from_solr
           #{name}(:response_format => :load_from_solr)
         end
+        def #{name}_query
+          relationship_query("#{name}")
+        end
         END
       end
     
@@ -735,7 +405,7 @@ module ActiveFedora
           relationships[subject][predicate] = []
         end
       end
-    
+
       #alias_method :register_target, :register_object
     
       # Creates a RELS-EXT datastream for insertion into a Fedora Object