active-fedora 3.2.0.pre1 → 3.2.0.pre2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active-fedora (3.2.0.pre1)
+    active-fedora (3.2.0.pre2)
       activeresource (>= 3.0.0)
       activesupport (>= 3.0.0)
       equivalent-xml

data/History.txt

@@ -3,10 +3,12 @@
 Don't create pids until save
 inspect and equality methods
 Deprecate datastream_collections
-Rails 3.1 compatibility
 Disseminators have been added
+HYDRA-729 don't update xml datastreams unless they've changed
 Adapt To
 ActiveFedora::Relationship is deprecated
+Rails 3.1 compatibility
+Ruby 1.9 compatibility
 
 3.1.5
 HYDRA-722 updating AF::Base#label= and then saving doesn't persist the change

data/lib/active_fedora.rb

@@ -4,6 +4,7 @@ require 'active_support'
 require 'active_fedora/solr_service'
 require 'active_fedora/rubydora_connection'
 require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/object'
 
 SOLR_DOCUMENT_ID = ActiveFedora::SolrService.id_field unless defined?(SOLR_DOCUMENT_ID)
 ENABLE_SOLR_UPDATES = true unless defined?(ENABLE_SOLR_UPDATES)
@@ -17,9 +18,9 @@ module ActiveFedora #:nodoc:
     autoload :Base
     autoload :ContentModel
     autoload :Reflection
-    #autoload :Relationship
+    autoload :Relationships
+    autoload :FileManagement
     autoload :RelationshipGraph
-    autoload :RelationshipsHelper
     autoload :Datastream
     autoload :Delegating
     autoload :DigitalObject
@@ -31,7 +32,6 @@ module ActiveFedora #:nodoc:
     autoload :Property
     autoload :QualifiedDublinCoreDatastream
     autoload :RelsExtDatastream
-    autoload :RelationshipsHelper
     autoload :ServiceDefinitions
     autoload :SemanticNode
     autoload :NestedAttributes

data/lib/active_fedora/associations.rb

@@ -34,7 +34,6 @@ module ActiveFedora
 
       def has_many(association_id, options={})
         raise "You must specify a property name for #{name}" if !options[:property]
-        has_relationship association_id.to_s, options[:property], :inbound => true
         reflection = create_has_many_reflection(association_id, options)
         collection_accessor_methods(reflection, HasManyAssociation)
       end
@@ -75,7 +74,6 @@ module ActiveFedora
       #   belongs_to :author, :class_name => "Person", :property => :author_of
       def belongs_to(association_id, options = {})
         raise "You must specify a property name for #{name}" if !options[:property]
-        has_relationship association_id.to_s, options[:property]
         reflection = create_belongs_to_reflection(association_id, options)
 
         association_accessor_methods(reflection, BelongsToAssociation)

data/lib/active_fedora/associations/association_collection.rb

@@ -129,9 +129,23 @@ module ActiveFedora
       end
 
       def find_target
-        @owner.load_inbound_relationship(@reflection.name.to_s, @reflection.options[:property])
+        load_inbound_relationship(@owner.pid, @reflection.options[:property])
       end
 
+      def load_inbound_relationship(pid, predicate, opts={})
+        opts = {:rows=>25}.merge(opts)
+        query = inbound_relationship_query(pid, predicate)
+        return [] if query.empty?
+        solr_result = SolrService.instance.conn.query(query, :rows=>opts[:rows])
+#TODO, don't reify, just store the solr results and lazily reify.
+        return ActiveFedora::SolrService.reify_solr_results(solr_result)
+      end
+
+      def inbound_relationship_query(pid,predicate)
+        internal_uri = "info:fedora/#{pid}"
+        escaped_uri = internal_uri.gsub(/(:)/, '\\:')
+        "#{predicate}_s:#{escaped_uri}" 
+      end
 
       def add_record_to_target_with_callbacks(record)
       #  callback(:before_add, record)

data/lib/active_fedora/associations/belongs_to_association.rb

@@ -24,7 +24,11 @@ module ActiveFedora
 
       private
         def find_target
-          @owner.load_outbound_relationship(@reflection.name.to_s, @reflection.options[:property]).first
+          pid = @owner.ids_for_outbound(@reflection.options[:property]).first
+          return if pid.nil?
+          query = ActiveFedora::SolrService.construct_query_for_pids([pid])
+          solr_result = SolrService.instance.conn.query(query)
+          return ActiveFedora::SolrService.reify_solr_results(solr_result).first
         end
 
         def foreign_key_present

data/lib/active_fedora/associations/has_and_belongs_to_many_association.rb

@@ -7,7 +7,11 @@ module ActiveFedora
       end
 
       def find_target
-          @owner.load_outbound_relationship(@reflection.name.to_s, @reflection.options[:property])
+          pids = @owner.ids_for_outbound(@reflection.options[:property])
+          return [] if pids.empty?
+          query = ActiveFedora::SolrService.construct_query_for_pids(pids)
+          solr_result = SolrService.instance.conn.query(query)
+          return ActiveFedora::SolrService.reify_solr_results(solr_result)
       end
 
 

data/lib/active_fedora/base.rb

@@ -30,12 +30,46 @@ module ActiveFedora
   # =Implementation
   # This class is really a facade for a basic Fedora::FedoraObject, which is stored internally.
   class Base
-    include RelationshipsHelper
     include SemanticNode
 
+    def self.method_missing (name, *args)
+      if [:has_relationship, :has_bidirectional_relationship, :register_relationship_desc].include? name 
+        ActiveSupport::Deprecation.warn("Deprecation: Relationships will not be included by default in the next version.   To use #{name} add 'include ActiveFedora::Relationships' to your model")
+        include Relationships
+        send name, *args
+      elsif name == :has_datastream
+        ActiveSupport::Deprecation.warn("Deprecation: DatastreamCollections will not be included by default in the next version.   To use has_datastream add 'include ActiveFedora::DatastreamCollections' to your model")
+        include DatastreamCollections
+        has_datastream(*args)
+      else 
+        super
+      end
+    end
+
+
+    def method_missing(name, *args)
+      if [:collection_members, :part_of, :parts, :part_of_append, :file_objects].include? name 
+        ActiveSupport::Deprecation.warn("Deprecation: FileManagement will not be included by default in the next version.   To use #{name} add 'include ActiveFedora::FileManagement' to your model")
+        self.class.send :include, FileManagement
+        send name, *args
+      else 
+        dsid = corresponding_datastream_name(name)
+        if dsid
+          ### Create and invoke a proxy method 
+          self.class.send :define_method, name do
+              datastreams[dsid]
+          end
+          self.send(name)
+        else 
+          super
+        end
+      end
+    end
+
+
     class_attribute  :ds_specs
     
-   def self.inherited(p)
+    def self.inherited(p)
       # each subclass should get a copy of the parent's datastream definitions, it should not add to the parent's definition table.
       p.ds_specs = p.ds_specs.dup
       super
@@ -43,13 +77,6 @@ module ActiveFedora
     
     self.ds_specs = {'RELS-EXT'=> {:type=> ActiveFedora::RelsExtDatastream, :label=>"", :block=>nil}}
 
-    
-
-    has_relationship "collection_members", :has_collection_member
-    has_relationship "part_of", :is_part_of
-    has_bidirectional_relationship "parts", :has_part, :is_part_of
-    
-
     # Has this object been saved?
     def new_object?
       inner_object.new?
@@ -112,29 +139,6 @@ module ActiveFedora
       ds_specs[args[:name]]= {:type => args[:type], :label =>  args.fetch(:label,""), :control_group => args.fetch(:control_group,"X"), :disseminator => args.fetch(:disseminator,""), :url => args.fetch(:url,""),:block => block}
     end
 
-    def self.method_missing (name, args)
-      if name == :has_datastream
-        ActiveSupport::Deprecation.warn("Deprecation: DatastreamCollections will not be included by default in the next version.   To use has_datastream add 'include ActiveFedora::DatastreamCollections' to your model")
-        include DatastreamCollections
-        has_datastream(args)
-      else 
-        super
-      end
-
-    end
-
-    def method_missing(name, *args)
-      dsid = corresponding_datastream_name(name)
-      if dsid
-        ### Create and invoke a proxy method 
-        self.class.send :define_method, name do
-            datastreams[dsid]
-        end
-        self.send(name)
-      else 
-        super
-      end
-    end
 
     ## Given a method name, return the best-guess dsid
     def corresponding_datastream_name(method_name)
@@ -349,65 +353,6 @@ module ActiveFedora
       add_datastream(ds)
     end
     
-    # List the objects that assert isPartOf pointing at this object _plus_ all objects that this object asserts hasPart for
-    #   Note: Previous versions of ActiveFedora used hasCollectionMember to represent this type of relationship.  
-    #   To accommodate this, until active-fedora-1.3, .file_assets will also return anything that this asserts hasCollectionMember for and will output a warning in the logs.
-    #
-    # @param [Hash] opts -- same options as auto-generated methods for relationships (ie. :response_format)
-    # @return [Array of ActiveFedora objects, Array of PIDs, or Solr::Result] -- same options as auto-generated methods for relationships (ie. :response_format)
-    def file_objects(opts={})
-      cm_array = collection_members(:response_format=>:id_array)
-      
-      if !cm_array.empty?
-        logger.warn "This object has collection member assertions.  hasCollectionMember will no longer be used to track file_object relationships after active_fedora 1.3.  Use isPartOf assertions in the RELS-EXT of child objects instead."
-        if opts[:response_format] == :solr || opts[:response_format] == :load_from_solr
-          logger.warn ":solr and :load_from_solr response formats for file_objects search only uses parts relationships (usage of hasCollectionMember is no longer supported)"
-          result = parts(opts)
-        else
-          cm_result = collection_members(opts)
-          parts_result = parts(opts)
-          ary = cm_result+parts_result
-          result = ary.uniq
-        end
-      else
-        result = parts(opts)
-      end
-      return result
-    end
-    
-    # Add the given obj as a child to the current object using an inbound is_part_of relationship
-    #
-    # @param [ActiveFedora::Base,String] obj the object or the pid of the object to add
-    # @return [Boolean] whether saving the child object was successful
-    # @example This will add an is_part_of relationship to the child_object's RELS-EXT datastream pointing at parent_object
-    #   parent_object.file_objects_append(child_object)
-    def file_objects_append(obj)
-      # collection_members_append(obj)
-      unless obj.kind_of? ActiveFedora::Base
-        begin
-          obj = ActiveFedora::Base.load_instance(obj)
-        rescue ActiveFedora::ObjectNotFoundError
-          "You must provide either an ActiveFedora object or a valid pid to add it as a file object.  You submitted #{obj.inspect}"
-        end
-      end
-      obj.add_relationship(:is_part_of, self)
-      obj.save
-    end
-    
-    # Add the given obj as a collection member to the current object using an outbound has_collection_member relationship.
-    #
-    # @param [ActiveFedora::Base] obj the file to add
-    # @return [ActiveFedora::Base] obj returns self
-    # @example This will add a has_collection_member relationship to the parent_object's RELS-EXT datastream pointing at child_object
-    #   parent_object.collection_members_append(child_object)
-    def collection_members_append(obj)
-      add_relationship(:has_collection_member, obj)
-      return self
-    end
-
-    def collection_members_remove()
-      # will rely on SemanticNode.remove_relationship once it is implemented
-    end
     
     def create_datastream(type, dsid, opts={})
       dsid = generate_dsid(opts[:prefix] || "DS") if dsid == nil
@@ -821,7 +766,6 @@ module ActiveFedora
     include NestedAttributes
     include Reflection
     include NamedRelationships
-#    include DatastreamCollections
   end
 
 end

data/lib/active_fedora/datastream.rb

@@ -28,8 +28,7 @@ module ActiveFedora
       dsid.gsub(/\./, '%2e')
     end
     
-    # Test whether this datastream been modified since it was last saved?
-    # TODO deprecate this, just use changed?
+    # Test whether this datastream been modified since it was last saved
     def dirty?
       @dirty || changed?
     end

data/lib/active_fedora/file_management.rb

@@ -0,0 +1,73 @@
+module ActiveFedora
+  module FileManagement
+    extend ActiveSupport::Concern
+
+    included do
+      has_relationship "collection_members", :has_collection_member
+      has_relationship "part_of", :is_part_of
+      has_bidirectional_relationship "parts", :has_part, :is_part_of
+    end
+
+    # List the objects that assert isPartOf pointing at this object _plus_ all objects that this object asserts hasPart for
+    #   Note: Previous versions of ActiveFedora used hasCollectionMember to represent this type of relationship.  
+    #   To accommodate this, until active-fedora-1.3, .file_assets will also return anything that this asserts hasCollectionMember for and will output a warning in the logs.
+    #
+    # @param [Hash] opts -- same options as auto-generated methods for relationships (ie. :response_format)
+    # @return [Array of ActiveFedora objects, Array of PIDs, or Solr::Result] -- same options as auto-generated methods for relationships (ie. :response_format)
+    def file_objects(opts={})
+      cm_array = collection_members(:response_format=>:id_array)
+      
+      if !cm_array.empty?
+        logger.warn "This object has collection member assertions.  hasCollectionMember will no longer be used to track file_object relationships after active_fedora 1.3.  Use isPartOf assertions in the RELS-EXT of child objects instead."
+        if opts[:response_format] == :solr || opts[:response_format] == :load_from_solr
+          logger.warn ":solr and :load_from_solr response formats for file_objects search only uses parts relationships (usage of hasCollectionMember is no longer supported)"
+          result = parts(opts)
+        else
+          cm_result = collection_members(opts)
+          parts_result = parts(opts)
+          ary = cm_result+parts_result
+          result = ary.uniq
+        end
+      else
+        result = parts(opts)
+      end
+      return result
+    end
+    
+    # Add the given obj as a child to the current object using an inbound is_part_of relationship
+    #
+    # @param [ActiveFedora::Base,String] obj the object or the pid of the object to add
+    # @return [Boolean] whether saving the child object was successful
+    # @example This will add an is_part_of relationship to the child_object's RELS-EXT datastream pointing at parent_object
+    #   parent_object.file_objects_append(child_object)
+    def file_objects_append(obj)
+      # collection_members_append(obj)
+      unless obj.kind_of? ActiveFedora::Base
+        begin
+          obj = ActiveFedora::Base.load_instance(obj)
+        rescue ActiveFedora::ObjectNotFoundError
+          "You must provide either an ActiveFedora object or a valid pid to add it as a file object.  You submitted #{obj.inspect}"
+        end
+      end
+      obj.add_relationship(:is_part_of, self)
+      obj.save
+    end
+    
+    # Add the given obj as a collection member to the current object using an outbound has_collection_member relationship.
+    #
+    # @param [ActiveFedora::Base] obj the file to add
+    # @return [ActiveFedora::Base] obj returns self
+    # @example This will add a has_collection_member relationship to the parent_object's RELS-EXT datastream pointing at child_object
+    #   parent_object.collection_members_append(child_object)
+    def collection_members_append(obj)
+      add_relationship(:has_collection_member, obj)
+      return self
+    end
+
+    def collection_members_remove()
+      # will rely on SemanticNode.remove_relationship once it is implemented
+    end
+
+  end
+end
+

data/lib/active_fedora/metadata_datastream_helper.rb

@@ -33,7 +33,9 @@ module ActiveFedora::MetadataDatastreamHelper
   end
   
   def serialize! # :nodoc:
-    self.content = self.to_xml  ##TODO only do this when the xml will have changed to avoid a load of the datastream content. 
+    if dirty?
+      self.content = self.to_xml  ##TODO only do this when the xml will have changed to avoid a load of the datastream content. 
+    end
   end
 
   def to_solr(solr_doc = Hash.new) # :nodoc:

data/lib/active_fedora/model.rb

@@ -102,9 +102,7 @@ module ActiveFedora
         return_multiple = false
         if args == :all
           return_multiple = true
-          # escaped_class_name = self.name.gsub(/(:)/, '\\:')
           escaped_class_uri = SolrService.escape_uri_for_query(self.to_class_uri)
-          # q = "#{ActiveFedora::SolrService.solr_name(:active_fedora_model, :symbol)}:#{escaped_class_name}"
           q = "#{ActiveFedora::SolrService.solr_name(:has_model, :symbol)}:#{escaped_class_uri}"
         elsif args.class == String
           escaped_id = args.gsub(/(:)/, '\\:')
@@ -115,13 +113,12 @@ module ActiveFedora
         else
           hits = SolrService.instance.conn.query(q).hits 
         end
-        results = hits.map do |hit|
-          obj = RubydoraConnection.instance.find_model(hit[SOLR_DOCUMENT_ID], self)
-        end
-        if return_multiple == true
-          return results
+        if return_multiple
+          return hits.map do |hit|
+             RubydoraConnection.instance.find_model(hit[SOLR_DOCUMENT_ID], self)
+          end
         else
-          return results.first
+          return RubydoraConnection.instance.find_model(hits.first[SOLR_DOCUMENT_ID], self) if hits.first
         end
       end
 
@@ -233,16 +230,7 @@ module ActiveFedora
         end
 
         logger.debug "Querying solr for #{self.name} objects with query: '#{query}'"
-    	results = ActiveFedora::SolrService.instance.conn.query(query,query_opts)
-    	#objects = []
-        #  results.hits.each do |hit|
-        #    puts "get object for #{hit[SOLR_DOCUMENT_ID]}"
-        #    obj = Fedora::Repository.instance.find_model(hit[SOLR_DOCUMENT_ID], self)
-        #    obj.inner_object.new_object = false
-        #    objects.push(obj)
-        #end
-        #objects
-        #ActiveFedora::SolrService.reify_solr_results(results)
+    	  results = ActiveFedora::SolrService.instance.conn.query(query,query_opts)
       end
     
       def class_fields

data/lib/active_fedora/relationships.rb

@@ -0,0 +1,634 @@
+module ActiveFedora
+  module Relationships
+    extend ActiveSupport::Concern
+
+
+    # Return array of objects for a given relationship name
+    # @param [String] Name of relationship to find
+    # @return [Array] Returns array of objects linked via the relationship name given
+    def find_relationship_by_name(name)
+      rels = nil
+      if inbound_relationship_names.include?(name)
+        rels = relationships_by_name(false)[:inbound][name]
+      elsif outbound_relationship_names.include?(name)
+        rels = relationships_by_name[:self][name]
+      end
+      rels = [] if rels.nil?
+      return rels
+    end
+
+    # Return array of relationship names for all inbound relationships (coming from other objects' RELS-EXT and Solr)
+    # @return [Array] of inbound relationship names for relationships declared via has_relationship in the class
+    def inbound_relationship_names
+        relationships_desc.has_key?(:inbound) ? relationships_desc[:inbound].keys : []
+    end
+
+    # Return hash of relationships_by_name 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.
+    # @return [Hash] Return hash of each relationship name mapped to an Array of objects linked to this object via inbound relationships
+    def inbound_relationships_by_name
+      rels = {}
+      if relationships_desc.has_key?(:inbound)&&!relationships_desc[:inbound].empty?()
+        inbound_rels = inbound_relationships
+      
+        if relationship_predicates.has_key?(:inbound)
+          relationship_predicates[:inbound].each do |name, predicate|
+            rels[name] = inbound_rels.has_key?(predicate) ? inbound_rels[predicate] : []
+          end
+        end
+      end
+      return rels
+    end
+    
+
+    # Call this method to return the query used against solr to retrieve any
+    # objects linked via the relationship name given.
+    #
+    # Instead of this method you can also use the helper method
+    # [relationship_name]_query, i.e. method "parts_query" for relationship "parts" to return the same value
+    # @param [String] The name of the relationship defined in the model
+    # @return [String] The query used when querying solr for objects for this relationship
+    # @example
+    #   Class SampleAFObjRelationshipFilterQuery < ActiveFedora::Base
+    #     #points to all parents linked via is_member_of
+    #     has_relationship "parents", :is_member_of
+    #     #returns only parents that have a level value set to "series"
+    #     has_relationship "series_parents", :is_member_of, :solr_fq=>level_t:series"
+    #   end
+    #   s = SampleAFObjRelationshipFilterQuery.new
+    #   obj = ActiveFedora::Base.new
+    #   s.parents_append(obj)
+    #   s.series_parents_query 
+    #   #=> "(id:changeme\\:13020 AND level_t:series)" 
+    #   SampleAFObjRelationshipFilterQuery.relationship_query("series_parents")
+    #   #=> "(id:changeme\\:13020 AND level_t:series)" 
+    def relationship_query(relationship_name)
+      query = ""
+      if self.class.is_bidirectional_relationship?(relationship_name)
+        predicate = outbound_relationship_predicates["#{relationship_name}_outbound"]
+        id_array = ids_for_outbound(predicate)
+        query = self.class.bidirectional_relationship_query(pid,relationship_name,id_array)
+      elsif outbound_relationship_names.include?(relationship_name)
+        predicate = outbound_relationship_predicates[relationship_name]
+        id_array = ids_for_outbound(predicate)
+        query = self.class.outbound_relationship_query(relationship_name,id_array)
+      elsif inbound_relationship_names.include?(relationship_name)
+        query = self.class.inbound_relationship_query(pid,relationship_name)
+      end
+      query
+    end
+
+
+    # Gets the relationships hash with subject mapped to relationship
+    # names instead of relationship predicates (unlike the "relationships" method in SemanticNode)
+    # 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.
+    # @param [Boolean] if false it will include inbound relationships (defaults to true)
+    # @return [Hash] Returns a hash of subject name (:self or :inbound) mapped to nested hashs of each relationship name mapped to an Array of objects linked via the relationship
+    def relationships_by_name(outbound_only=true)
+      @relationships_by_name = relationships_by_name_from_class()
+      outbound_only ? @relationships_by_name : @relationships_by_name.merge(:inbound=>inbound_relationships_by_name)      
+    end
+
+    # Gets relationships by name from the class using the current relationships hash
+    # and relationship name,predicate pairs.
+    # @return [Hash] returns the outbound relationships with :self mapped to nested hashs of each relationship name mapped to an Array of objects linked via the relationship
+    def relationships_by_name_from_class()
+      rels = {}
+      relationship_predicates.each_pair do |subj, names|
+        case subj
+        when :self
+          rels[:self] = {}
+          names.each_pair do |name, predicate|
+            set = []
+            res = relationships.query(:predicate => Predicates.find_graph_predicate(predicate))
+            res.each_object do |o|
+              set << o.to_s
+            end
+            rels[:self][name] = set
+          end
+        when :inbound
+          #nop
+        end
+      end
+      return rels
+    end
+
+
+
+    # Throws an assertion error if conforms_to? returns false for object and model_class
+    # @param [String] Name of object (just label for output)
+    # @param [ActiveFedora::Base] Expects to be an object that has ActiveFedora::Base as an ancestor of its class
+    # @param [Class] The model class used in conforms_to? check on object
+    def assert_conforms_to(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.conforms_to?(model_class)
+    end
+    
+
+
+
+    # Returns a Class symbol for the given string for the class name
+    # @param [String] the class name as a string
+    # @return [Class] the class as a Class object
+    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
+
+    # Return array of relationship names for all outbound relationships (coming from this object's RELS-EXT)
+    # @return [Array] of outbound relationship names for relationships declared via has_relationship in the class
+    def outbound_relationship_names
+        relationships_desc.has_key?(:self) ? relationships_desc[:self].keys : []
+    end
+  
+    # Returns true if the given relationship name is a relationship
+    # @param [String] Name of relationship
+    # @param [Boolean] If false checks inbound relationships as well (defaults to true)
+    def is_relationship_name?(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
+    
+
+    def load_inbound_relationship(name, predicate, opts={})
+      opts = {:rows=>25}.merge(opts)
+      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
+        if 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
+          return ActiveFedora::SolrService.reify_solr_results(solr_result)
+        end
+      end
+    end
+
+
+
+    def load_bidirectional(name, inbound_method_name, outbound_method_name, opts) 
+        opts = {:rows=>25}.merge(opts)
+        if opts[:response_format] == :solr || opts[:response_format] == :load_from_solr
+          predicate = outbound_relationship_predicates["#{name}_outbound"]
+          outbound_id_array = ids_for_outbound(predicate)
+          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
+            return solr_result
+          elsif opts[:response_format] == :load_from_solr || self.load_from_solr
+            return ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+          else
+            return ActiveFedora::SolrService.reify_solr_results(solr_result)
+          end
+        else
+          ary = send(inbound_method_name,opts) + send(outbound_method_name, opts)
+          return ary.uniq
+        end
+    end
+
+    def load_outbound_relationship(name, predicate, opts={})
+      id_array = ids_for_outbound(predicate)
+      if opts[:response_format] == :id_array  && !self.relationship_has_solr_filter_query?(:self,"#{name}")
+        return id_array
+      else
+        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
+          return ActiveFedora::SolrService.reify_solr_results(solr_result)
+        end
+      end
+    end
+
+    # Check if a relationship has any solr query filters defined by has_relationship call
+    # @param [Symbol] subject to use such as :self or :inbound
+    # @param [String] relationship name
+    # @return [Boolean] true if the relationship has a query filter defined
+    def relationship_has_solr_filter_query?(subject, relationship_name)
+      relationships_desc.has_key?(subject) && relationships_desc[subject].has_key?(relationship_name) && relationships_desc[subject][relationship_name].has_key?(:solr_fq)
+    end
+
+
+    # Add an outbound relationship for given relationship name
+    # See ActiveFedora::SemanticNode::ClassMethods.has_relationship
+    # @param [String] Name of relationship
+    # @param [ActiveFedora::Base] object to add to the relationship (expects ActvieFedora::Base to be an ancestor)
+    # @return [Boolean] returns true if add operation successful
+    def add_relationship_by_name(name, object)
+      if is_relationship_name?(name,true)
+        if relationships_desc[:self][name].has_key?(:type)
+          klass = class_from_name(relationships_desc[:self][name][:type])
+          unless klass.nil?
+            (assert_conforms_to 'object', object, klass)
+          end
+        end
+        add_relationship(outbound_relationship_predicates[name],object)
+      else
+        false
+      end
+    end
+    
+    # Remove an object for the given relationship name
+    # @param [String] Relationship name
+    # @param [ActiveFedora::Base] object to remove
+    # @return [Boolean] return true if remove operation successful
+    def remove_relationship_by_name(name, object)
+      if is_relationship_name?(name,true)
+        remove_relationship(outbound_relationship_predicates[name],object)
+      else
+        return false
+      end
+    end
+
+
+    module ClassMethods
+      # Tests if the relationship name passed is in bidirectional
+      # @param [String] relationship name to test
+      # @return [Boolean]
+      def is_bidirectional_relationship?(relationship_name)
+        (relationships_desc.has_key?(:self)&&relationships_desc.has_key?(:inbound)&&relationships_desc[:self].has_key?("#{relationship_name}_outbound") && relationships_desc[:inbound].has_key?("#{relationship_name}_inbound")) 
+      end
+
+
+      # Returns a solr query for retrieving objects specified in an outbound relationship.
+      # This method is mostly used by internal method calls.
+      # It utilizes any solr_fq value defined within a relationship to attach a query filter when
+      # querying solr on top of just the predicate being used.
+      # Because it is static it 
+      # needs the pids defined within RELS-EXT for this relationship to be passed in.
+      # If you are calling this method directly to get the query you should use the 
+      # ActiveFedora::SemanticNode.relationship_query instead or use the helper method
+      # [relationship_name]_query, i.e. method "parts_query" for relationship "parts".  This
+      # method would only be called directly if you had something like an array of outbound pids
+      # already in something like a solr document for object that has these relationships.
+      # @param [String] The name of the relationship defined in the model
+      # @param [Array] An array of pids to include in the query
+      # @return [String]
+      # @example
+      #   Class SampleAFObjRelationshipFilterQuery < ActiveFedora::Base
+      #     #points to all parents linked via is_member_of
+      #     has_relationship "parents", :is_member_of
+      #     #returns only parents that have a level value set to "series"
+      #     has_relationship "series_parents", :is_member_of, :solr_fq=>"level_t:series"
+      #   end
+      #   s = SampleAFObjRelationshipFilterQuery.new
+      #   obj = ActiveFedora::Base.new
+      #   s.series_parents_append(obj)
+      #   s.series_parents_query 
+      #   #=> "(id:changeme\\:13020 AND level_t:series)" 
+      #   SampleAFObjRelationshipFilterQuery.outbound_relationship_query("series_parents",["id:changeme:13020"])
+      #   #=> "(id:changeme\\:13020 AND level_t:series)" 
+      def outbound_relationship_query(relationship_name,outbound_pids)
+        query = ActiveFedora::SolrService.construct_query_for_pids(outbound_pids)
+        subject = :self
+        if relationships_desc.has_key?(subject) && relationships_desc[subject].has_key?(relationship_name) && relationships_desc[subject][relationship_name].has_key?(:solr_fq)
+          solr_fq = relationships_desc[subject][relationship_name][:solr_fq]
+          unless query.empty?
+            #substitute in the filter query for each pid so that it is applied to each in the query
+            query_parts = query.split(/OR/)
+            query = ""
+            query_parts.each_with_index do |query_part,index|
+              query_part.strip!
+              query << " OR " if index > 0
+              query << "(#{query_part} AND #{solr_fq})"
+            end
+          else
+            query = solr_fq
+          end
+        end
+        query
+      end
+
+
+      # Returns a solr query for retrieving objects specified in an inbound relationship.
+      # This method is mostly used by internal method calls.
+      # It utilizes any solr_fq value defined within a relationship to attach a query filter
+      # on top of just the predicate being used.  Because it is static it 
+      # needs the pid of the object that has the inbound relationships passed in.
+      # If you are calling this method directly to get the query you should use the 
+      # ActiveFedora::SemanticNode.relationship_query instead or use the helper method
+      # [relationship_name]_query, i.e. method "parts_query" for relationship "parts".  This
+      # method would only be called directly if you were working only with Solr and already
+      # had the pid for the object in something like a solr document.
+      # @param [String] The pid for the object that has these inbound relationships
+      # @param [String] The name of the relationship defined in the model
+      # @return [String]
+      # @example
+      #   Class SampleAFObjRelationshipFilterQuery < ActiveFedora::Base
+      #     #returns all parts
+      #     has_relationship "parts", :is_part_of, :inbound=>true
+      #     #returns only parts that have level to "series"
+      #     has_relationship "series_parts", :is_part_of, :inbound=>true, :solr_fq=>"level_t:series"
+      #   end
+      #   s = SampleAFObjRelationshipFilterQuery.new
+      #   s.pid 
+      #   #=> id:changeme:13020
+      #   s.series_parts_query
+      #   #=> "is_part_of_s:info\\:fedora/changeme\\:13021 AND level_t:series"
+      #   SampleAFObjRelationshipFilterQuery.inbound_relationship_query(s.pid,"series_parts")
+      #   #=> "is_part_of_s:info\\:fedora/changeme\\:13021 AND level_t:series"
+      def inbound_relationship_query(pid,relationship_name)
+        query = ""
+        subject = :inbound
+        if relationships_desc.has_key?(subject) && relationships_desc[subject].has_key?(relationship_name)
+          predicate = relationships_desc[subject][relationship_name][:predicate]
+          internal_uri = "info:fedora/#{pid}"
+          escaped_uri = internal_uri.gsub(/(:)/, '\\:')
+          query = "#{predicate}_s:#{escaped_uri}" 
+          if relationships_desc.has_key?(subject) && relationships_desc[subject].has_key?(relationship_name) && relationships_desc[subject][relationship_name].has_key?(:solr_fq)
+            solr_fq = relationships_desc[subject][relationship_name][:solr_fq]
+            query << " AND " unless query.empty?
+            query << solr_fq
+          end
+        end
+        query
+      end
+
+      # Returns a solr query for retrieving objects specified in a bidirectional relationship.
+      # This method is mostly used by internal method calls.
+      # It usea of solr_fq value defined within a relationship to attach a query filter
+      # on top of just the predicate being used.  Because it is static it 
+      # needs the pids defined within RELS-EXT for the outbound relationship as well as the pid of the
+      # object for the inbound portion of the relationship.
+      # If you are calling this method directly to get the query you should use the 
+      # ActiveFedora::SemanticNode.relationship_query instead or use the helper method
+      # [relationship_name]_query, i.e. method "bi_parts_query" for relationship "bi_parts".  This
+      # method would only be called directly if you had something like an array of outbound pids
+      # already in something like a solr document for object that has these relationships.
+      # @param [String] The pid for the object that has these inbound relationships
+      # @param [String] The name of the relationship defined in the model
+      # @param [Array] An array of pids to include in the query
+      # @return [String]
+      # @example
+      #   Class SampleAFObjRelationshipFilterQuery < ActiveFedora::Base
+      #     has_bidirectional_relationship "bi_series_parts", :has_part, :is_part_of, :solr_fq=>"level_t:series"
+      #   end
+      #   s = SampleAFObjRelationshipFilterQuery.new
+      #   obj = ActiveFedora::Base.new
+      #   s.bi_series_parts_append(obj)
+      #   s.pid
+      #   #=> "changeme:13025" 
+      #   obj.pid
+      #   #=> id:changeme:13026
+      #   s.bi_series_parts_query 
+      #   #=> "(id:changeme\\:13026 AND level_t:series) OR (is_part_of_s:info\\:fedora/changeme\\:13025 AND level_t:series)" 
+      #   SampleAFObjRelationshipFilterQuery.bidirectional_relationship_query(s.pid,"series_parents",["id:changeme:13026"])
+      #   #=> "(id:changeme\\:13026 AND level_t:series) OR (is_part_of_s:info\\:fedora/changeme\\:13025 AND level_t:series)" 
+      def bidirectional_relationship_query(pid,relationship_name,outbound_pids)
+        outbound_query = outbound_relationship_query("#{relationship_name}_outbound",outbound_pids) 
+        inbound_query = inbound_relationship_query(pid,"#{relationship_name}_inbound")
+        query = outbound_query # use outbound_query by default
+        if !inbound_query.empty?
+          query << " OR (" + inbound_relationship_query(pid,"#{relationship_name}_inbound") + ")"
+        end
+        return query      
+      end
+
+
+      # Internal method that ensures a relationship subject such as :self and :inbound
+      # exist within the relationships_desc hash tracking relationships metadata. 
+      # @param [Symbol] Subject name to register (will probably be something like :self or :inbound)
+      def register_relationship_desc_subject(subject)
+        unless relationships_desc.has_key?(subject) 
+          relationships_desc[subject] = {} 
+        end
+      end
+  
+      # Internal method that adds relationship name and predicate pair to either an outbound (:self)
+      # or inbound (:inbound) relationship types. Refer to ActiveFedora::SemanticNode.has_relationship for information on what metadata will be persisted.
+      # @param [Symbol] Subject name to register
+      # @param [String] Name of relationship being registered
+      # @param [Symbol] Fedora ontology predicate to use
+      # @param [Hash] Any options passed to has_relationship such as :type, :solr_fq, etc.
+      def register_relationship_desc(subject, name, predicate, opts={})
+        register_relationship_desc_subject(subject)
+        opts.merge!({:predicate=>predicate})
+        relationships_desc[subject][name] = opts
+      end
+
+      # relationships are tracked as a hash of structure 
+      # @example
+      #   ds.relationships # => {:self=>{:has_model=>["afmodel:SimpleThing"],:has_part=>["demo:20"]},:inbound=>{:is_part_of=>["demo:6"]} 
+      def relationships
+        @class_relationships ||= Hash[:self => {}]
+      end
+    
+    
+      def register_subject(subject)
+        if !relationships.has_key?(subject) 
+            relationships[subject] = {} 
+        end
+      end
+    
+      def register_predicate(subject, predicate)
+        register_subject(subject)
+        if !relationships[subject].has_key?(predicate) 
+          relationships[subject][predicate] = []
+        end
+      end
+
+      # Allows for a relationship to be treated like any other attribute of a model class. You define
+      # 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
+      #   predicate: predicate for the relationship
+      #   opts:
+      #     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
+      # this object's RELS-EXT datastream
+      #
+      # Word of caution - The same predicate may not be used twice for two inbound or two outbound relationships.  However, it may be used twice if one is inbound
+      # and one is outbound as shown in the example above.  A full list of possible predicates are defined by predicate_mappings
+      #
+      # 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
+          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 \"#{predicate.inspect}\" not allowed" if named_predicate_exists_with_different_name?(:self,name,predicate)
+          register_relationship_desc(:self, name, predicate, opts)
+          register_predicate(:self, predicate)
+          create_relationship_name_methods(name)
+          create_outbound_relationship_finders(name, predicate, opts)
+        end
+      end
+
+      # Used in has_relationship call to create dynamic helper methods to 
+      # append and remove objects to and from a relationship
+      # @param [String] relationship name to create helper methods for
+      # @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_relationship_name_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_relationship_by_name(name,object)}
+        self.send(:define_method,:"#{remove_method_name}") {|object| remove_relationship_by_name(name,object)}
+      end 
+
+      
+      # Generates relationship finders for predicates that point in both directions
+      #
+      # @param [String] name of the relationship method(s) to create
+      # @param [Symbol] outbound_predicate Predicate used in outbound relationships
+      # @param [Symbol] inbound_predicate Predicate used in inbound relationships
+      # @param [Hash] opts
+      #
+      # Example:
+      #  has_bidirectional_relationship("parts", :has_part, :is_part_of)
+      #
+      # will create three instance methods: parts_outbound, and parts_inbound and parts
+      # the inbound and outbound methods are the same that would result from calling 
+      # create_inbound_relationship_finders and create_outbound_relationship_finders
+      # The third method combines the results of both and handles generating appropriate 
+      # solr queries where necessary.
+      def has_bidirectional_relationship(name, outbound_predicate, inbound_predicate, opts={})
+        create_bidirectional_relationship_finders(name, outbound_predicate, inbound_predicate, opts)
+      end
+      
+      def create_inbound_relationship_finders(name, predicate, opts = {})
+        class_eval <<-END, __FILE__, __LINE__
+        def #{name}(opts={})
+          load_inbound_relationship('#{name}', '#{predicate}', opts)
+        end
+        def #{name}_ids
+          #{name}(:response_format => :id_array)
+        end
+        def #{name}_from_solr
+          #{name}(:response_format => :load_from_solr)
+        end
+        def #{name}_query
+          relationship_query("#{name}")
+        end
+        END
+      end
+    
+      def create_outbound_relationship_finders(name, predicate, opts = {})
+        class_eval <<-END, __FILE__, __LINE__
+        def #{name}(opts={})
+          load_outbound_relationship(#{name.inspect}, #{predicate.inspect}, opts)
+        end
+        def #{name}_ids
+          #{name}(:response_format => :id_array)
+        end
+        def #{name}_from_solr
+          #{name}(:response_format => :load_from_solr)
+        end
+        def #{name}_query
+          relationship_query("#{name}")
+        end
+        END
+      end
+      
+
+
+      # Generates relationship finders for predicates that point in both directions
+      # and registers predicate relationships for each direction.
+      #
+      # @param [String] name Name of the relationship method(s) to create
+      # @param [Symbol] outbound_predicate Predicate used in outbound relationships
+      # @param [Symbol] inbound_predicate Predicate used in inbound relationships
+      # @param [Hash] opts (optional)
+      def create_bidirectional_relationship_finders(name, outbound_predicate, inbound_predicate, opts={})
+        inbound_method_name = name.to_s+"_inbound"
+        outbound_method_name = name.to_s+"_outbound"
+        has_relationship(outbound_method_name, outbound_predicate, opts)
+        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_relationship_name_methods(name,outbound_method_name)
+
+        class_eval <<-END, __FILE__, __LINE__
+        def #{name}(opts={})
+          load_bidirectional("#{name}", :#{inbound_method_name}, :#{outbound_method_name}, opts)
+        end
+        def #{name}_ids
+          #{name}(:response_format => :id_array)
+        end
+        def #{name}_from_solr
+          #{name}(:response_format => :load_from_solr)
+        end
+        def #{name}_query
+          relationship_query("#{name}")
+        end
+        END
+      end
+
+      #  Similar to +create_relationship_name_methods+ except it is used when an ActiveFedora::Base model class
+      #  declares has_bidirectional_relationship.  we are merely creating an alias for outbound portion of bidirectional
+      #  @param [String] bidirectional relationship name
+      #  @param [String] outbound relationship method name associated with the bidirectional relationship ([bidirectional_name]_outbound)
+      #  @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_relationship_name_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_relationship_by_name(outbound_name,object)}
+        self.send(:define_method,:"#{remove_method_name}") {|object| remove_relationship_by_name(outbound_name,object)}
+      end
+
+    end
+  end
+end