active-fedora 3.2.0.pre1 → 3.2.0.pre2

data/spec/unit/semantic_node_spec.rb

@@ -5,7 +5,7 @@ require 'xmlsimple'
 @@last_pid = 0
 
 class SpecNode2
-  include ActiveFedora::RelationshipsHelper
+  include ActiveFedora::Relationships
   include ActiveFedora::SemanticNode
   
   attr_accessor :pid
@@ -21,18 +21,10 @@ describe ActiveFedora::SemanticNode do
     def increment_pid
       @@last_pid += 1    
     end
-      
-    before(:all) do
-      @pid = "test:sample_pid"
-      @uri = "info:fedora/#{@pid}"
-      @sample_solr_hits = [{"id"=>"_PID1_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]},
-                            {"id"=>"_PID2_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]},
-                            {"id"=>"_PID3_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]}]
-    end
     
     before(:each) do
       class SpecNode
-        include ActiveFedora::RelationshipsHelper
+        include ActiveFedora::Relationships
         include ActiveFedora::SemanticNode
         
         attr_accessor :pid
@@ -91,327 +83,6 @@ describe ActiveFedora::SemanticNode do
       @node.should  respond_to(:internal_uri)
     end
     
-    it 'should provide #has_relationship' do
-      SpecNode.should  respond_to(:has_relationship)
-      SpecNode.should  respond_to(:has_relationship)
-    end
-    
-    describe '#has_relationship' do
-      it "should create finders based on provided relationship name" do
-        SpecNode.has_relationship("parts", :is_part_of, :inbound => true)
-        local_node = SpecNode.new
-        local_node.should respond_to(:parts_ids)
-        local_node.should respond_to(:parts_query)
-        # local_node.should respond_to(:parts)
-        local_node.should_not respond_to(:containers)
-        SpecNode.has_relationship("containers", :is_member_of)  
-        local_node.should respond_to(:containers_ids)
-        local_node.should respond_to(:containers_query)
-      end
-      
-      it "should add a subject and predicate to the relationships array" do
-        SpecNode.has_relationship("parents", :is_part_of)
-        SpecNode.relationships.should have_key(:self)
-        SpecNode.relationships[:self].should have_key(:is_part_of)
-      end
-      
-      it "should use :inbound as the subject if :inbound => true" do
-        SpecNode.has_relationship("parents", :is_part_of, :inbound => true)
-        SpecNode.relationships.should have_key(:inbound)
-        SpecNode.relationships[:inbound].should have_key(:is_part_of)
-      end
-      
-      it 'should create inbound relationship finders' do
-        SpecNode.expects(:create_inbound_relationship_finders)
-        SpecNode.has_relationship("parts", :is_part_of, :inbound => true) 
-      end
-      
-      it 'should create outbound relationship finders' do
-        SpecNode.expects(:create_outbound_relationship_finders).times(2)
-        SpecNode.has_relationship("parts", :is_part_of, :inbound => false)
-        SpecNode.has_relationship("container", :is_member_of)
-      end
-      
-      it "should create outbound relationship finders that return an array of fedora PIDs" do
-        SpecNode.has_relationship("containers", :is_member_of, :inbound => false)
-        local_node = SpecNode.new
-        local_node.internal_uri = "info:fedora/#{@pid}"
-        
-        local_node.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true, :content=>'')).at_least_once
-        local_node.add_relationship(:is_member_of, "info:fedora/container:A")
-        local_node.add_relationship(:is_member_of, "info:fedora/container:B")
-
-        containers_result = local_node.containers_ids
-        containers_result.should be_instance_of(Array)
-        containers_result.should include("container:A")
-        containers_result.should include("container:B")
-      end
-      
-      class MockHasRelationship < SpecNode2
-        has_relationship "testing", :has_part, :type=>SpecNode2
-        has_relationship "testing2", :has_member, :type=>SpecNode2
-        has_relationship "testing_inbound", :has_part, :type=>SpecNode2, :inbound=>true
-      end
-        
-      it 'should create relationship descriptions both inbound and outbound' do
-        @test_object2 = MockHasRelationship.new
-        @test_object2.pid = increment_pid
-        @test_object2.stubs(:testing_inbound).returns({})
-        @test_object2.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true, :content =>'')).at_least_once
-        @test_object2.add_relationship(:has_model, ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode2))
-        @test_object2.should respond_to(:testing_append)
-        @test_object2.should respond_to(:testing_remove)
-        @test_object2.should respond_to(:testing2_append)
-        @test_object2.should respond_to(:testing2_remove)
-        #make sure append/remove method not created for inbound rel
-        @test_object2.should_not respond_to(:testing_inbound_append)
-        @test_object2.should_not respond_to(:testing_inbound_remove)
-        
-        @test_object2.relationships_desc.should == 
-        {:inbound=>{"testing_inbound"=>{:type=>SpecNode2, 
-                                       :predicate=>:has_part, 
-                                        :inbound=>true, 
-                                        :singular=>nil}}, 
-         :self=>{"testing"=>{:type=>SpecNode2, 
-                             :predicate=>:has_part, 
-                             :inbound=>false, 
-                             :singular=>nil},
-                 "testing2"=>{:type=>SpecNode2, 
-                              :predicate=>:has_member, 
-                              :inbound=>false, 
-                              :singular=>nil}}}
-      end
-    end
-      
-    describe '#create_inbound_relationship_finders' do
-      
-      it 'should respond to #create_inbound_relationship_finders' do
-        SpecNode.should respond_to(:create_inbound_relationship_finders)
-      end
-      
-      it "should create finders based on provided relationship name" do
-        SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
-        local_node = SpecNode.new
-        local_node.should respond_to(:parts_ids)
-        local_node.should_not respond_to(:containers)
-        SpecNode.create_inbound_relationship_finders("containers", :is_member_of, :inbound => true)  
-        local_node.should respond_to(:containers_ids)
-        local_node.should respond_to(:containers)
-        local_node.should respond_to(:containers_from_solr)
-        local_node.should respond_to(:containers_query)
-      end
-      
-      it "resulting finder should search against solr and use Model#load_instance to build an array of objects" do
-        solr_result = (mock("solr result", :is_a? => true, :hits => @sample_solr_hits))
-        SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
-        local_node = SpecNode.new()
-        local_node.expects(:pid).returns("test:sample_pid")
-        SpecNode.expects(:relationships_desc).returns({:inbound=>{"parts"=>{:predicate=>:is_part_of}}}).at_least_once()
-        ActiveFedora::SolrService.instance.conn.expects(:query).with("is_part_of_s:info\\:fedora/test\\:sample_pid", :rows=>25).returns(solr_result)
-        local_node.parts.map(&:pid).should == ["_PID1_", "_PID2_", "_PID3_"]
-      end
-      
-      it "resulting finder should accept :solr as :response_format value and return the raw Solr Result" do
-        solr_result = mock("solr result")
-        SpecNode.create_inbound_relationship_finders("constituents", :is_constituent_of, :inbound => true)
-        local_node = SpecNode.new
-        mock_repo = mock("repo")
-        mock_repo.expects(:find_model).never
-        local_node.expects(:pid).returns("test:sample_pid")
-        SpecNode.expects(:relationships_desc).returns({:inbound=>{"constituents"=>{:predicate=>:is_constituent_of}}}).at_least_once()
-        ActiveFedora::SolrService.instance.conn.expects(:query).with("is_constituent_of_s:info\\:fedora/test\\:sample_pid", :rows=>101).returns(solr_result)
-        local_node.constituents(:response_format => :solr, :rows=>101).should equal(solr_result)
-      end
-      
-      
-      it "resulting _ids finder should search against solr and return an array of fedora PIDs" do
-        SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
-        local_node = SpecNode.new
-        local_node.expects(:pid).returns("test:sample_pid")
-        SpecNode.expects(:relationships_desc).returns({:inbound=>{"parts"=>{:predicate=>:is_part_of}}}).at_least_once() 
-        ActiveFedora::SolrService.instance.conn.expects(:query).with("is_part_of_s:info\\:fedora/test\\:sample_pid", :rows=>25).returns(mock("solr result", :hits => [Hash["id"=>"pid1"], Hash["id"=>"pid2"]]))
-        local_node.parts(:response_format => :id_array).should == ["pid1", "pid2"]
-      end
-      
-      it "resulting _ids finder should call the basic finder with :result_format => :id_array" do
-        SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
-        local_node = SpecNode.new
-        local_node.expects(:parts).with(:response_format => :id_array)
-        local_node.parts_ids
-      end
-
-      it "resulting _query finder should call relationship_query" do
-        SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
-        local_node = SpecNode.new
-        local_node.expects(:relationship_query).with("parts")
-        local_node.parts_query
-      end
-    end
-    
-    describe '#create_outbound_relationship_finders' do
-      
-      it 'should respond to #create_outbound_relationship_finders' do
-        SpecNode.should respond_to(:create_outbound_relationship_finders)
-      end
-      
-      it "should create finders based on provided relationship name" do
-        SpecNode.create_outbound_relationship_finders("parts", :is_part_of)
-        local_node = SpecNode.new
-        local_node.should respond_to(:parts_ids)
-        #local_node.should respond_to(:parts)  #.with(:type => "AudioRecord")  
-        local_node.should_not respond_to(:containers)
-        SpecNode.create_outbound_relationship_finders("containers", :is_member_of)  
-        local_node.should respond_to(:containers_ids)
-        local_node.should respond_to(:containers)  
-        local_node.should respond_to(:containers_from_solr)  
-        local_node.should respond_to(:containers_query)
-      end
-      
-      describe " resulting finder" do
-        it "should read from relationships array and use Repository.find_model to build an array of objects" do
-          SpecNode.create_outbound_relationship_finders("containers", :is_member_of)
-          local_node = SpecNode.new
-          local_node.expects(:ids_for_outbound).with(:is_member_of).returns(["my:_PID1_", "my:_PID2_", "my:_PID3_"])
-          mock_repo = mock("repo")
-          solr_result = mock("solr result", :is_a? => true)
-          solr_result.expects(:hits).returns(
-                        [{"id"=> "my:_PID1_", "has_model_s"=>["info:fedora/afmodel:SpecNode"]},
-                         {"id"=> "my:_PID2_", "has_model_s"=>["info:fedora/afmodel:SpecNode"]}, 
-                         {"id"=> "my:_PID3_", "has_model_s"=>["info:fedora/afmodel:SpecNode"]}])
-
-          ActiveFedora::SolrService.instance.conn.expects(:query).with("id:my\\:_PID1_ OR id:my\\:_PID2_ OR id:my\\:_PID3_").returns(solr_result)
-          local_node.containers.map(&:pid).should == ["my:_PID1_", "my:_PID2_", "my:_PID3_"]
-        end
-      
-        it "should accept :solr as :response_format value and return the raw Solr Result" do
-          solr_result = mock("solr result")
-          SpecNode.create_outbound_relationship_finders("constituents", :is_constituent_of)
-          local_node = SpecNode.new
-          mock_repo = mock("repo")
-          mock_repo.expects(:find_model).never
-          local_node.expects(:rels_ext).returns(stub('rels-ext', :content=>''))
-          ActiveFedora::SolrService.instance.conn.expects(:query).returns(solr_result)
-          local_node.constituents(:response_format => :solr).should equal(solr_result)
-        end
-        
-        it "(:response_format => :id_array) should read from relationships array" do
-          SpecNode.create_outbound_relationship_finders("containers", :is_member_of)
-          local_node = SpecNode.new
-          local_node.expects(:ids_for_outbound).with(:is_member_of).returns([])
-          local_node.containers_ids
-        end
-      
-        it "(:response_format => :id_array) should return an array of fedora PIDs" do
-          SpecNode.create_outbound_relationship_finders("containers", :is_member_of)
-          local_node = SpecNode.new
-          local_node.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true, :content=>'')).at_least_once
-          local_node.add_relationship(:is_member_of, "demo:10")
-          result = local_node.containers_ids
-          result.should be_instance_of(Array)
-          result.should include("demo:10")
-        end
-        
-      end
-      
-      describe " resulting _ids finder" do
-        it "should call the basic finder with :result_format => :id_array" do
-          SpecNode.create_outbound_relationship_finders("parts", :is_part_of)
-          local_node = SpecNode.new
-          local_node.expects(:parts).with(:response_format => :id_array)
-          local_node.parts_ids
-        end
-      end
-
-      it "resulting _query finder should call relationship_query" do
-        SpecNode.create_outbound_relationship_finders("containers", :is_member_of)
-        local_node = SpecNode.new
-        local_node.expects(:relationship_query).with("containers")
-        local_node.containers_query
-      end
-    end
-    
-    describe ".create_bidirectional_relationship_finder" do
-      before(:each) do
-        SpecNode.create_bidirectional_relationship_finders("all_parts", :has_part, :is_part_of)
-        @local_node = SpecNode.new
-        @local_node.pid = @pid
-        @local_node.internal_uri = @uri
-      end
-      it "should create inbound & outbound finders" do
-        @local_node.should respond_to(:all_parts_inbound)
-        @local_node.should respond_to(:all_parts_outbound)
-      end
-      it "should rely on inbound & outbound finders" do      
-        @local_node.expects(:all_parts_inbound).with(:rows => 25).returns(["foo1"])
-        @local_node.expects(:all_parts_outbound).with(:rows => 25).returns(["foo2"])
-        @local_node.all_parts.should == ["foo1", "foo2"]
-      end
-      it "(:response_format => :id_array) should rely on inbound & outbound finders" do
-        @local_node.expects(:all_parts_inbound).with(:response_format=>:id_array, :rows => 34).returns(["fooA"])
-        @local_node.expects(:all_parts_outbound).with(:response_format=>:id_array, :rows => 34).returns(["fooB"])
-        @local_node.all_parts(:response_format=>:id_array, :rows => 34).should == ["fooA", "fooB"]
-      end
-      it "(:response_format => :solr) should construct a solr query that combines inbound and outbound searches" do
-        # get the id array for outbound relationships then construct solr query by combining id array with inbound relationship search
-        @local_node.expects(:ids_for_outbound).with(:has_part).returns(["mypid:1"])
-        id_array_query = ActiveFedora::SolrService.construct_query_for_pids(["mypid:1"])
-        solr_result = mock("solr result")
-        ActiveFedora::SolrService.instance.conn.expects(:query).with("#{id_array_query} OR (is_part_of_s:info\\:fedora/test\\:sample_pid)", :rows=>25).returns(solr_result)
-        @local_node.all_parts(:response_format=>:solr)
-      end
-
-      it "should register both inbound and outbound predicate components" do
-        @local_node.class.relationships[:inbound].has_key?(:is_part_of).should == true
-        @local_node.class.relationships[:self].has_key?(:has_part).should == true
-      end
-    
-      it "should register relationship names for inbound, outbound" do
-        @local_node.relationship_names.include?("all_parts_inbound").should == true
-        @local_node.relationship_names.include?("all_parts_outbound").should == true
-      end
-
-      it "should register finder methods for the bidirectional relationship name" do
-        @local_node.should respond_to(:all_parts)
-        @local_node.should respond_to(:all_parts_ids)
-        @local_node.should respond_to(:all_parts_query)
-        @local_node.should respond_to(:all_parts_from_solr)
-      end
-
-      it "resulting _query finder should call relationship_query" do
-        SpecNode.create_bidirectional_relationship_finders("containers", :is_member_of, :has_member)
-        local_node = SpecNode.new
-        local_node.expects(:relationship_query).with("containers")
-        local_node.containers_query
-      end
-    end
-    
-    describe "#has_bidirectional_relationship" do
-      it "should ..." do
-        SpecNode.expects(:create_bidirectional_relationship_finders).with("all_parts", :has_part, :is_part_of, {})
-        SpecNode.has_bidirectional_relationship("all_parts", :has_part, :is_part_of)
-      end
-
-      it "should have relationships_by_name and relationships hashes contain bidirectionally related objects" do
-        SpecNode.has_bidirectional_relationship("all_parts", :has_part, :is_part_of)
-        @local_node = SpecNode.new
-        @local_node.pid = "mypid1"
-        @local_node2 = SpecNode.new
-        @local_node2.pid = "mypid2"
-        model_def = ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode)
-        @local_node.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true, :content=>'')).at_least_once
-        @local_node.add_relationship(:has_model, model_def)
-        @local_node2.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true, :content=>'')).at_least_once
-        @local_node2.add_relationship(:has_model, model_def)
-        @local_node.add_relationship(:has_part, @local_node2)
-        @local_node2.add_relationship(:has_part, @local_node)
-        @local_node.ids_for_outbound(:has_part).should == [@local_node2.pid]
-        @local_node.ids_for_outbound(:has_model).should == ['afmodel:SpecNode']
-        @local_node2.ids_for_outbound(:has_part).should == [@local_node.pid]
-        @local_node2.ids_for_outbound(:has_model).should == ['afmodel:SpecNode']
-        @local_node.relationships_by_name(false).should == {:self=>{"all_parts_outbound"=>[@local_node2.internal_uri]},:inbound=>{"all_parts_inbound"=>[]}}
-        @local_node2.relationships_by_name(false).should == {:self=>{"all_parts_outbound"=>[@local_node.internal_uri]},:inbound=>{"all_parts_inbound"=>[]}}
-      end
-    end
     
     describe ".add_relationship" do
       it "should add relationship to the relationships graph" do
@@ -444,13 +115,6 @@ describe ActiveFedora::SemanticNode do
       
     end
     
-    describe '#relationships' do
-      
-      it "should return a hash" do
-        SpecNode.relationships.class.should == Hash
-      end
-
-    end
     
     it "should provide .outbound_relationships" do 
       @node.should respond_to(:outbound_relationships)

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: active-fedora
 version: !ruby/object:Gem::Version 
-  hash: 1923832043
+  hash: 1923832045
   prerelease: 6
   segments: 
   - 3
   - 2
   - 0
   - pre
-  - 1
-  version: 3.2.0.pre1
+  - 2
+  version: 3.2.0.pre2
 platform: ruby
 authors: 
 - Matt Zumwalt
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-21 00:00:00 -06:00
+date: 2011-12-29 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -569,6 +569,7 @@ files:
 - lib/active_fedora/delegating.rb
 - lib/active_fedora/digital_object.rb
 - lib/active_fedora/fedora_object.rb
+- lib/active_fedora/file_management.rb
 - lib/active_fedora/fixture_loader.rb
 - lib/active_fedora/metadata_datastream.rb
 - lib/active_fedora/metadata_datastream_helper.rb
@@ -584,7 +585,7 @@ files:
 - lib/active_fedora/reflection.rb
 - lib/active_fedora/relationship.rb
 - lib/active_fedora/relationship_graph.rb
-- lib/active_fedora/relationships_helper.rb
+- lib/active_fedora/relationships.rb
 - lib/active_fedora/rels_ext_datastream.rb
 - lib/active_fedora/rubydora_connection.rb
 - lib/active_fedora/samples.rb
@@ -707,7 +708,7 @@ files:
 - spec/unit/rdf_xml_writer.rb
 - spec/unit/relationship_graph_spec.rb
 - spec/unit/relationship_spec.rb
-- spec/unit/relationships_helper_spec.rb
+- spec/unit/relationships_spec.rb
 - spec/unit/rels_ext_datastream_spec.rb
 - spec/unit/rubydora_connection_spec.rb
 - spec/unit/semantic_node_spec.rb
@@ -850,7 +851,7 @@ test_files:
 - spec/unit/rdf_xml_writer.rb
 - spec/unit/relationship_graph_spec.rb
 - spec/unit/relationship_spec.rb
-- spec/unit/relationships_helper_spec.rb
+- spec/unit/relationships_spec.rb
 - spec/unit/rels_ext_datastream_spec.rb
 - spec/unit/rubydora_connection_spec.rb
 - spec/unit/semantic_node_spec.rb

data/lib/active_fedora/relationships_helper.rb

@@ -1,881 +0,0 @@
-module ActiveFedora
-  # This module is meant to extend semantic node to add functionality based on a relationship's name
-  # It is meant to turn a relationship into just another attribute in a model.
-  # The notion of a "relationship name" is used _internally_ to distinguish between the relationships you've set up using has_relationship and the implicit relationships that are based on the predicates themselves.
-  #
-  # @example ActiveFedora
-  #   has_relationship "parents", :is_member_of
-  #
-  #   obj.parents is a relationship in ActiveFedora while :is_member_of is the literal RDF relationship in Fedora
-  #
-  #   There are also several helper methods created for any relationship declared in ActiveFedora.  For the above example
-  #   the following methods are created:
-  #
-  #   obj.parents_append(object)  Appends an object to the "parents" relationship
-  #   obj.parents_remove(object)  Removes an object from the "parents" relationship
-  #   obj.parents_query           Returns the query used against solr to retrieve objects linked via the "parents" relationship
-  #
-  #   Note: ActiveFedora relationships can reflect filters ...
-  #   If you define the solr_fq parameter in your has_relationship call some objects will be filtered out:
-  #  
-  #   has_relationship "parents", :is_member_of, :solr_fq=>"eyes:blue"
-  #
-  #   Then obj.parents will only return parents where their eyes are blue.
-  module RelationshipsHelper
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute  :class_relationships_desc
-    end
-
-
-    # ** EXPERIMENTAL **
-    # 
-    # 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
-
-     # ** EXPERIMENTAL **
-    # 
-    # Internal method that ensures a relationship subject such as :self and :inbound
-    # exist within the relationships_desc hash tracking relationships metadata. 
-    # This method just calls the class method counterpart of this method.
-    # @param [Symbol] Subject name to register (will probably be something like :self or :inbound)
-    def register_relationship_desc_subject(subject)
-      self.class.register_relationship_desc_subject(subject)
-    end
-  
-    # ** EXPERIMENTAL **
-    # 
-    # Internal method that adds a relationship description for a
-    # 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.
-    # @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={})
-      self.class.register_relationship_desc(subject, name, predicate, opts)
-    end
-
-    # ** EXPERIMENTAL **
-    # 
-    # 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
-
-    # ** EXPERIMENTAL **
-    # 
-    # 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
-          # inbound = inbound_relationships
-          # names.each_pair do |name, predicate|
-          #   rels[:inbound][name] = inbound[predicate]
-          # end
-        end
-      end
-      return rels
-    end
-
-        
-    # ** EXPERIMENTAL **
-    # 
-    # 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
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash of outbound relationship names and predicate pairs
-    # @return [Hash] A hash of outbound relationship names mapped to predicates used
-    def outbound_relationship_predicates
-      relationship_predicates.has_key?(:self) ? relationship_predicates[:self] : {}
-    end
-
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash of inbound relationship names and predicate pairs
-    # @return [Hash] A hash of inbound relationship names mapped to predicates used
-    def inbound_relationship_predicates
-      relationship_predicates.has_key?(:inbound) ? relationship_predicates[:inbound] : {}
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash of relationship names and predicate pairs (inbound and outbound).
-    # This method calls the class method version of this method to get the static settings
-    # defined in the class definition.
-    # @return [Hash] A hash of relationship names (inbound and outbound) mapped to predicates used
-    def relationship_predicates
-      @relationship_predicates ||= relationship_predicates_from_class
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash of relationship names and predicate pairs from class.
-    # It retrieves this information via the relationships_desc hash in the class.
-    # @return [Hash] A hash of relationship names (inbound and outbound) mapped to predicates used
-    def relationship_predicates_from_class
-      rels = {}
-      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
-    # @return [Array] of relationship names for relationships declared via has_relationship in the class
-    def relationship_names
-      names = []
-      relationships_desc.each_key do |subject|
-            names = names.concat(relationships_desc[subject].keys)
-        end
-        names
-    end
-
-    # ** EXPERIMENTAL **
-    # 
-    # 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
-
-    # ** EXPERIMENTAL **
-    # 
-    # 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
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash of relationships_by_name defined within this object's RELS-EXT
-    # It returns a hash of relationship name to arrays of objects
-    # @return [Hash] Return hash of each relationship name mapped to an Array of objects linked to this object via outbound relationships
-    def outbound_relationships_by_name
-        relationships_desc.has_key?(:self) ? relationships_by_name[:self] : {}
-    end
-  
-    # ** EXPERIMENTAL **
-    # 
-    # 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
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return hash that persists relationship metadata defined by has_relationship calls
-    # @return [Hash] Hash of relationship subject (:self or :inbound) mapped to nested hashs of each relationship name mapped to another hash relationship options 
-    # @example For the following relationship
-    #
-    #  has_relationship "audio_records", :has_part, :type=>AudioRecord
-    #  
-    #  Results in the following returned by relationships_desc
-    #  {:self=>{"audio_records"=>{:type=>AudioRecord, :singular=>nil, :predicate=>:has_part, :inbound=>false}}}
-    def relationships_desc
-      @relationships_desc ||= relationships_desc_from_class
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Get class instance variable relationships_desc that holds has_relationship metadata
-    # @return [Hash] Hash of relationship subject (:self or :inbound) mapped to nested hashs of each relationship name mapped to another hash relationship options 
-    def relationships_desc_from_class
-      self.class.relationships_desc
-    end
-    
-    # ** EXPERIMENTAL **
-    # 
-    # Return the value of :type for the relationship for name passed in if defined
-    # It defaults to ActiveFedora::Base.
-    # @return [Class] the name of the class defined for a relationship by the :type option if present
-    def relationship_model_type(name)
-      if is_relationship_name?(name,true)
-        subject = outbound_relationship_names.include?(name)? :self : :inbound
-        if relationships_desc[subject][name].has_key?(:type)
-          return class_from_name(relationships_desc[subject][name][:type])
-        end
-      end
-      return nil  
-    end
-
-    # ** EXPERIMENTAL **
-    # 
-    # 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
-    
-    # ** EXPERIMENTAL **
-    # 
-    # 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
-
-    # ** EXPERIMENTAL **
-    # 
-    # 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
-    
-    # ** 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.
-    # @param [Class] the model class name to check if an object conforms_to that model
-    # @return [Boolean] true if this object conforms to the given model name
-    def conforms_to?(model_class)
-      if self.kind_of?(model_class)
-        #check has model and class match
-        mod = relationships.first(:predicate=>Predicates.find_graph_predicate(:has_model))
-        if mod
-          expected = ActiveFedora::ContentModel.pid_from_ruby_class(self.class)
-          if mod.object.to_s == expected
-            return true
-          else
-            raise "has_model relationship check failed for model #{model_class} raising exception, expected: '#{expected}' actual: '#{mod.object.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
-
-    # 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
-
-    # 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
-
-  ## Deprecated method checks for HYDRA-541 methods renamed
-  #
-  # Old Name                                                      New Name
-  # named_relationship                                            find_relationship_by_name
-  # register_named_subject                                        register_relationship_desc_subject
-  # register_named_relationship                                   register_relationship_desc
-  # named_relationships                                           relationships_by_name
-  # named_relationships_from_class                                relationships_by_name_from_class
-  # named_inbound_relationships                                   inbound_relationship_names
-  # outbound_named_relationship_predicates                        outbound_relationship_predicates
-  # inbound_named_relationship_predicates                         inbound_relationship_predicates
-  # named_relationship_predicates                                 relationship_predicates
-  # named_relationship_predicates_from_class                      relationship_predicates_from_class
-  # named_outbound_relationships                                  outbound_relationships_by_name
-  # is_named_relationship?                                        is_relationship_name?
-  # named_relationships_desc                                      relationships_desc
-  # named_relationships_desc_from_class                           relationships_desc_from_class
-  # named_relationship_type                                       relationship_model_type
-  # add_named_relationship                                        add_relationship_by_name
-  # remove_named_relationship                                     remove_relationship_by_name
-  # assert_kind_of_model                                          assert_conforms_to
-  # kind_of_model?                                                conforms_to?
-  # named_relationship_query                                      relationship_query
-  # CLASS METHODS                         
-  # named_relationships_desc                                      relationships_desc
-  # register_named_subject                                        register_relationship_desc_subject
-  # register_named_relationship                                   register_relationship_desc
-  # create_named_relationship_method                              create_relationship_name_methods
-  # create_bidirectional_named_relationship_methods               create_bidirectional_relationship_name_methods
-  # outbound_named_relationship_query                             outbound_relationship_query
-  # inbound_named_relationship_query                              inbound_relationship_query
-  # bidirectional_named_relationship_query                        bidirectional_relationship_query
-  # named_predicate_exists_with_different_name?                   predicate_exists_with_different_relationship_name?
-
-    # @deprecated Please use {#find_relationship_by_name} instead.
-    def named_relationship(name)
-      ActiveSupport::Deprecation.warn("Deprecation: named_relationship has been deprecated.  Please call find_relationship_by_name instead.")
-      find_relationship_by_name(name)
-    end
-
-    # @deprecated Please use {#register_relationship_desc_subject} instead.
-    def register_named_subject(subject)
-      ActiveSupport::Deprecation.warn("Deprecation: register_named_subject has been deprecated.  Please call register_relationship_desc_subject instead.")
-      register_relationship_desc_subject(subject)
-    end 
-    
-    # @deprecated Please use {#register_relationship_desc} instead.
-    def register_named_relationship(subject, name, predicate, opts)
-      ActiveSupport::Deprecation.warn("Deprecation: register_named_relationship has been deprecated.  Please call register_relationship_desc instead.")
-      register_relationship_desc(subject, name, predicate, opts)
-    end 
-
-    # @deprecated Please use {#relationships_by_name} instead.
-    def named_relationships(outbound_only=true)
-      ActiveSupport::Deprecation.warn("Deprecation: named_relationships has been deprecated.  Please call relationships_by_name instead.")
-      relationships_by_name(outbound_only)
-    end 
-
-    # @deprecated Please use {#relationships_by_name_from_class} instead.
-    def named_relationships_from_class
-      ActiveSupport::Deprecation.warn("Deprecation: named_relationships_from_class has been deprecated.  Please call relationships_by_name_from_class instead.")
-      relationships_by_name_from_class
-    end 
-
-    # @deprecated Please use {#inbound_relationships_by_name} instead.
-    def named_inbound_relationships
-      ActiveSupport::Deprecation.warn("Deprecation: named_inbound_relationships has been deprecated.  Please call inbound_relationships_by_name instead.")
-      inbound_relationships_by_name
-    end 
-
-    # @deprecated Please use {#outbound_relationships_by_name} instead.
-    def named_outbound_relationships
-      ActiveSupport::Deprecation.warn("Deprecation: named_outbound_relationships has been deprecated.  Please call outbound_relationships_by_name instead.")
-      outbound_relationships_by_name
-    end 
-
-    # @deprecated Please use {#outbound_relationship_predicates} instead.
-    def outbound_named_relationship_predicates
-      ActiveSupport::Deprecation.warn("Deprecation: outbound_named_relationship_predicates has been deprecated.  Please call outbound_relationship_predicates instead.")
-      outbound_relationship_predicates
-    end 
-
-    # @deprecated Please use {#inbound_relationship_predicates} instead.
-    def inbound_named_relationship_predicates
-      ActiveSupport::Deprecation.warn("Deprecation: inbound_named_relationship_predicates has been deprecated.  Please call inbound_relationship_predicates instead.")
-      inbound_relationship_predicates
-    end 
-
-    # @deprecated Please use {#relationship_predicates} instead.
-    def named_relationship_predicates
-      ActiveSupport::Deprecation.warn("Deprecation: named_relationship_predicates has been deprecated.  Please call relationship_predicates instead.")
-      relationship_predicates
-    end 
-
-    # @deprecated Please use {#relationship_predicates_from_class} instead.
-    def named_relationship_predicates_from_class
-      ActiveSupport::Deprecation.warn("Deprecation: named_relationship_predicates_from_class has been deprecated.  Please call relationship_predicates_from_class instead.")
-      relationship_predicates_from_class
-    end 
-
-    # @deprecated Please use {#is_relationship_name?} instead.
-    def is_named_relationship?(name, outbound_only=true)
-      ActiveSupport::Deprecation.warn("Deprecation: is_named_relationship? has been deprecated.  Please call is_relationship_name? instead.")
-      is_relationship_name?(name,outbound_only)
-    end 
-
-    # @deprecated Please use {#relationships_desc} instead.
-    def named_relationships_desc
-      ActiveSupport::Deprecation.warn("Deprecation: named_relationships_desc has been deprecated.  Please call relationships_desc instead.")
-      relationships_desc
-    end 
-
-    # @deprecated Please use {#relationships_desc_from_class} instead.
-    def named_relationships_desc_from_class
-      ActiveSupport::Deprecation.warn("Deprecation: named_relationships_desc_from_class has been deprecated.  Please call relationships_desc_from_class instead.")
-      relationships_desc_from_class
-    end 
-
-    # @deprecated Please use {#relationship_model_type} instead.
-    def named_relationship_type(name)
-      ActiveSupport::Deprecation.warn("Deprecation: named_relationship_type has been deprecated.  Please call relationship_model_type instead.")
-      relationship_model_type(name)
-    end 
-
-    # @deprecated Please use {#add_relationship_by_name} instead.
-    def add_named_relationship(name,object)
-      ActiveSupport::Deprecation.warn("Deprecation: add_named_relationship has been deprecated.  Please call add_relationship_by_name instead.")
-      add_relationship_by_name(name,object)
-    end 
-
-    # @deprecated Please use {#remove_relationship_by_name} instead.
-    def remove_named_relationship(name,object)
-      ActiveSupport::Deprecation.warn("Deprecation: remove_named_relationship has been deprecated.  Please call remove_relationship_by_name instead.")
-      remove_relationship_by_name(name,object)
-    end 
-
-    # @deprecated Please use {#assert_conforms_to} instead.
-    def assert_kind_of_model(name,object,model_class)
-      ActiveSupport::Deprecation.warn("Deprecation: assert_kind_of_model has been deprecated.  Please call assert_conforms_to instead.")
-      assert_conforms_to(name,object,model_class)
-    end 
-
-    # @deprecated Please use {#conforms_to?} instead.
-    def kind_of_model?(model_class)
-      ActiveSupport::Deprecation.warn("Deprecation: kind_of_model? has been deprecated.  Please call conforms_to? instead.")
-      conforms_to?(model_class)
-    end 
-
-    # @deprecated Please use {#relationship_query} instead.
-    def named_relationship_query(relationship_name)
-      ActiveSupport::Deprecation.warn("Deprecation: named_relationship_query has been deprecated.  Please call relationship_query instead.")
-      relationship_query(relationship_name)
-    end 
-
-    module ClassMethods
-
-      # ** EXPERIMENTAL **
-      #  
-      # Return hash that persists relationship metadata defined by has_relationship calls.  If you implement a child class of ActiveFedora::Base it will inherit
-      # the relationship descriptions defined there by merging in the class
-      # instance variable values.  It will also do this for any level of 
-      # ancestors.
-      # @return [Hash] Hash of relationship subject (:self or :inbound) mapped to nested hashs of each relationship name mapped to another hash relationship options
-      # @example
-      #  For the following relationship
-      #
-      #  has_relationship "audio_records", :has_part, :type=>AudioRecord
-      #  
-      #  Results in the following returned by relationships_desc
-      #  {:self=>{"audio_records"=>{:type=>AudioRecord, :singular=>nil, :predicate=>:has_part, :inbound=>false}}}
-      def relationships_desc
-        #get any relationship descriptions from superclasses
-        if @class_relationships_desc.nil?
-          @class_relationships_desc ||= Hash[:self => {}]
-
-          #get super classes
-          super_klasses = []
-          #insert in reverse order so the child overwrites anything in parent
-          super_klass = self.superclass
-          while !super_klass.nil?
-            super_klasses.insert(0,super_klass)
-            super_klass = super_klass.superclass
-          end
-        
-          super_klasses.each do |super_klass|
-            if super_klass.respond_to?(:relationships_desc)
-              super_rels = super_klass.relationships_desc
-              super_rels.each_pair do |subject,rels|
-                @class_relationships_desc[subject] = {} unless @class_relationships_desc.has_key?(subject)
-                @class_relationships_desc[subject].merge!(rels)
-              end
-            end
-          end
-        end
-        @class_relationships_desc
-      end
-
-      # ** EXPERIMENTAL **
-      #   
-      # 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
-  
-      # ** EXPERIMENTAL **
-      # 
-      # 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
-
-      # 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
-
-      # ** EXPERIMENTAL **
-      #   
-      # 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 
-
-      #  ** EXPERIMENTAL **
-      #  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
-
-      # 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
-
-      # 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
-
-      # ** 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.
-      # @param [Symbol] subject to check (:self or :inbound)
-      # @param [String] relationship name
-      # @param [Symbol] symbol for Fedora relationship ontology predicate
-      def predicate_exists_with_different_relationship_name?(subject,name,predicate)
-        if relationships_desc.has_key?(subject)
-          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
-
-      ## Deprecated class method checks for HYDRA-541 methods renamed
-      # 
-      # Old Name                                                      New Name
-      # named_relationships_desc                                      relationships_desc
-      # register_named_subject                                        register_relationship_desc_subject
-      # register_named_relationship                                   register_relationship_desc
-      # create_named_relationship_method                              create_relationship_name_methods
-      # create_bidirectional_named_relationship_methods               create_bidirectional_relationship_name_methods
-      # outbound_named_relationship_query                             outbound_relationship_query
-      # inbound_named_relationship_query                              inbound_relationship_query
-      # bidirectional_named_relationship_query                        bidirectional_relationship_query
-      # named_predicate_exists_with_different_name?                   predicate_exists_with_different_relationship_name?
-
-      # @deprecated Please use {#relationships_desc} instead.
-      def named_relationships_desc
-        ActiveSupport::Deprecation.warn("Deprecation: named_relationships_desc has been deprecated.  Please call relationships_desc instead.")
-        relationships_desc
-      end
-
-      # @deprecated Please use {#register_relationship_desc_subject} instead.
-      def register_named_subject(subject)
-        ActiveSupport::Deprecation.warn("Deprecation: register_named_subject has been deprecated.  Please call register_relationship_desc_subject instead.")
-        register_relationship_desc_subject(subject)
-      end
-
-      # @deprecated Please use {#register_relationship_desc} instead.
-      def register_named_relationship(subject, name, predicate, opts)
-        ActiveSupport::Deprecation.warn("Deprecation: register_named_relationship has been deprecated.  Please call register_relationship_desc instead.")
-        register_relationship_desc(subject, name, predicate, opts)
-      end
-
-      # @deprecated Please use {#create_relationship_name_methods} instead.
-      def create_named_relationship_methods(name)
-        ActiveSupport::Deprecation.warn("Deprecation: create_named_relationship_methods has been deprecated.  Please call create_relationship_name_methods instead.")
-        create_relationship_name_methods(name)
-      end
-
-      # @deprecated Please use {#create_bidirectional_relationship_name_methods} instead.
-      def create_bidirectional_named_relationship_methods(name,outbound_name)
-        ActiveSupport::Deprecation.warn("Deprecation: create_bidirectional_named_relationship_methods has been deprecated.  Please call create_bidirectional_relationship_name_methods instead.")
-        create_bidirectional_relationship_name_methods(name,outbound_name)
-      end
-
-      # @deprecated Please use {#outbound_relationship_query} instead.
-      def outbound_named_relationship_query(relationship_name,outbound_pids)
-        ActiveSupport::Deprecation.warn("Deprecation: outbound_named_relationship_query has been deprecated.  Please call outbound_relationship_query instead.")
-        outbound_relationship_query(relationship_name,outbound_pids)
-      end
-
-      # @deprecated Please use {#inbound_relationship_query} instead.
-      def inbound_named_relationship_query(pid,relationship_name)
-        ActiveSupport::Deprecation.warn("Deprecation: inbound_named_relationship_query has been deprecated.  Please call inbound_relationship_query instead.")
-        inbound_relationship_query(pid,relationship_name)
-      end
-
-      # @deprecated Please use {#bidirectional_relationship_query} instead.
-      def bidirectional_named_relationship_query(pid,relationship_name,outbound_pids)
-        ActiveSupport::Deprecation.warn("Deprecation: bidirectional_named_relationship_query has been deprecated.  Please call bidirectional_relationship_query instead.")
-        bidirectional_relationship_query(pid,relationship_name,outbound_pids)
-      end
-
-      # @deprecated Please use {#predicate_exists_with_different_relationship_name?} instead.
-      def named_predicate_exists_with_different_name?(subject,name,predicate)
-        ActiveSupport::Deprecation.warn("Deprecation: named_predicate_exists_with_different_name? has been deprecated.  Please call predicate_exists_with_different_relationship_name? instead.")
-        predicate_exists_with_different_relationship_name?(subject,name,predicate)
-      end
-    end
-  end
-end