active-fedora 2.3.4 → 2.3.7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active-fedora (2.3.4)
+    active-fedora (2.3.5)
       activeresource
       equivalent-xml
       facets
@@ -17,7 +17,7 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
-    RedCloth (4.2.7)
+    RedCloth (4.2.8)
     activeresource (2.3.14)
       activesupport (= 2.3.14)
     activesupport (2.3.14)
@@ -26,7 +26,7 @@ GEM
     daemons (1.1.4)
     equivalent-xml (0.2.7)
       nokogiri (>= 1.4.3)
-    facets (2.9.1)
+    facets (2.9.2)
     fastercsv (1.5.4)
     jettywrapper (0.0.10)
       logger
@@ -39,7 +39,8 @@ GEM
     mocha (0.9.12)
     multipart-post (1.1.2)
     nokogiri (1.5.0)
-    om (1.3.0)
+    om (1.4.0)
+      mediashelf-loggable
       nokogiri (>= 1.4.2)
     rake (0.9.2)
     rbx-require-relative (0.0.5)

data/History.txt

@@ -1,4 +1,20 @@
+2.3.7 
+
+HYDRA-650 -- Fixed relationship inheritance (Rick Johnson)
+
+2.3.6
+
+YANKED
+Removed Bundler.require, which was causing odd dependency order resolving.
+
+2.3.5 
+
+YANKED
+branched so that trunk now require rails 3.
+Named finders HYDRA-541 (Rick Johnson)
+
 2.3.4
+
 moved dirty assignment to NokogiriDatastream#update_values; added test (Benjamin Armintor)
 Fixed HYDRA-590
 

data/README.textile

@@ -1,6 +1,6 @@
 h2. Description
 
-RubyFedora and ActiveFedora provide a set of Ruby gems for creating and managing objects in the Fedora Repository Architecture ("http://fedora-commons.org":http://fedora-commons.org).  ActiveFedora is loosely based on "ActiveRecord" in Rails.
+RubyFedora and ActiveFedora provide a set of Ruby gems for creating and managing objects in the Fedora Repository Architecture ("http://fedora-commons.org":http://fedora-commons.org).  ActiveFedora is loosely based on "ActiveRecord" in Rails. This version of ActiveFedora depends on Rails 2.3.11 and has been superceeded by ActiveFedora 3.x which requires Rails 3.
 
 h2. Getting Help
 

data/active-fedora.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.add_dependency('solr-ruby', '>= 0.0.6')
   s.add_dependency('xml-simple', '>= 1.0.12')
   s.add_dependency('mime-types', '>= 1.16')
-  s.add_dependency('multipart-post', "1.1.2")
+  s.add_dependency('multipart-post', "= 1.1.2")
   s.add_dependency('nokogiri')
   s.add_dependency('om', '>= 1.0')
   s.add_dependency('solrizer', '>1.0.0')

data/lib/active_fedora.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
-require "bundler/setup"
-Bundler.require(:default)
+# require "bundler/setup"
+# Bundler.require(:default)
 
 gem 'solr-ruby'
 require "loggable"
@@ -68,14 +68,14 @@ module ActiveFedora #:nodoc:
   # 2. If it does not find a solr.yml and the fedora.yml contains a solr url, it will raise an configuration error 
   # 3. If it does not find a solr.yml and the fedora.yml does not contain a solr url, it will look in: +Rails.root+/config, +current working directory+/config, then the solr.yml shipped with gem
   def self.init( options={} )
-    logger.level = Logger::ERROR
+    logger.level = Logger::ERROR if logger.respond_to? :level ###MediaShelf StubLogger doesn't have a level= method
     # Make config_options into a Hash if nil is passed in as the value
     options = {} if options.nil?
 
     # For backwards compatibility, handle cases where config_path (a String) is passed in as the argument rather than a config_options hash
     # In all other cases, set config_path to config_options[:config_path], which is ok if it's nil
     if options.is_a? String
-      logger.warn "DEPRECATION WARNING: Calling ActiveFedora.init with a path as an argument is deprecated.  Use ActiveFedora.init(:config_path=>#{options})"
+      logger.warn "DEPRECATION WARNING: Calling ActiveFedora.init with a path as an argument is deprecated.  Use ActiveFedora.init(:fedora_config_path=>#{options})"
       @config_options = {:fedora_config_path=>options}
     else
       @config_options = options

data/lib/active_fedora/relationships_helper.rb

@@ -0,0 +1,889 @@
+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
+
+    include MediaShelfClassLevelInheritableAttributes
+    ms_inheritable_attributes :class_relationships_desc
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    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)
+      #make sure to update if relationships have been updated
+      if @relationships_are_dirty == true
+        @relationships_by_name = relationships_by_name_from_class()
+        @relationships_are_dirty = false
+      end
+      
+      #this will get called normally on first fetch if relationships are not dirty
+      @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|
+        if relationships.has_key?(subj)
+          rels[subj] = {}
+          names.each_pair do |name, predicate|
+            rels[subj][name] = (relationships[subj].has_key?(predicate) ? relationships[subj][predicate] : [])
+          end
+        end
+      end
+      return rels
+    end
+
+        
+    # ** EXPERIMENTAL **
+    # 
+    # Return hash of 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
+        #r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>outbound_relationship_predicates[name],:object=>object})
+        #add_relationship(r)
+        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
+        if relationships[:self].has_key?(:has_model)
+          r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:has_model, :object=>ActiveFedora::ContentModel.pid_from_ruby_class(self.class))
+          if relationships[:self][:has_model].first.to_s.eql?(r.object.to_s)
+            return true
+          else
+            raise "has_model relationship check failed for model #{model_class} raising exception, expected: '#{r.object.to_s}' actual: '#{relationships[:self][:has_model].to_s}'"
+          end
+        else
+          raise "has_model relationship does not exist for model #{model_class} check raising exception"
+        end
+      else
+        raise "kind_of? check failed for model #{model_class}, actual #{self.class} raising exception"
+      end
+      return false
+    end
+
+    # 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)
+        id_array = []
+        predicate = outbound_relationship_predicates["#{relationship_name}_outbound"]
+        if !outbound_relationships[predicate].nil? 
+          outbound_relationships[predicate].each do |rel|
+            id_array << rel.gsub("info:fedora/", "")
+          end
+        end
+        query = self.class.bidirectional_relationship_query(pid,relationship_name,id_array)
+      elsif outbound_relationship_names.include?(relationship_name)
+        id_array = []
+        predicate = outbound_relationship_predicates[relationship_name]
+        if !outbound_relationships[predicate].nil? 
+          outbound_relationships[predicate].each do |rel|
+            id_array << rel.gsub("info:fedora/", "")
+          end
+        end
+        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)
+      logger.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)
+      logger.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)
+      logger.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)
+      logger.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
+      logger.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
+      logger.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
+      logger.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
+      logger.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
+      logger.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
+      logger.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
+      logger.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)
+      logger.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
+      logger.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
+      logger.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)
+      logger.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)
+      logger.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)
+      logger.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)
+      logger.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)
+      logger.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)
+      logger.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
+        logger.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)
+        logger.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)
+        logger.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)
+        logger.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)
+        logger.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)
+        logger.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)
+        logger.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)
+        logger.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)
+        logger.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