active-fedora 2.3.8 → 3.0.0

data/lib/active_fedora/datastream.rb

@@ -21,7 +21,6 @@ module ActiveFedora
     #set this Datastream's content
     def content=(content)
       self.blob = content
-      self.dirty = true
     end
 
     def self.delete(parent_pid, dsid)

data/lib/active_fedora/delegating.rb

@@ -0,0 +1,53 @@
+module ActiveFedora
+  module Delegating
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Provides a delegate class method to expose methods in metadata streams
+      # as member of the base object. Pass the target datastream via the 
+      # <tt>:to</tt> argument. If you want to return a unique result, (e.g. string 
+      # instead of an array) set the <tt>:unique</tt> argument to true.
+      #   
+      #   class Foo < ActiveFedora::Base
+      #     has_metadata :name => "descMetadata", :type => MyDatastream 
+      #     
+      #     delegate :field1, :to=>"descMetadata", :unique=>true
+      #   end
+      #
+      #   foo = Foo.new
+      #   foo.field1 = "My Value"
+      #   foo.field1                 # => "My Value"
+      #   foo.field2                 # => NoMethodError: undefined method `field2' for #<Foo:0x1af30c>
+
+      def delegate(field, args ={})
+        create_delegate_accessor(field, args)
+        create_delegate_setter(field, args)
+      end
+
+      private
+        def create_delegate_accessor(field, args)
+            define_method field do
+              ds = self.send(args[:to])
+              val = if ds.kind_of? ActiveFedora::NokogiriDatastream 
+                ds.send(:term_values, field)
+              else 
+                ds.send(:get_values, field)
+              end 
+              args[:unique] ? val.first : val
+                
+            end
+        end
+
+        def create_delegate_setter(field, args)
+            define_method "#{field}=".to_sym do |v|
+              ds = self.send(args[:to])
+              if ds.kind_of? ActiveFedora::NokogiriDatastream 
+                ds.send(:update_indexed_attributes, {[field] => v})
+              else 
+                ds.send(:set_value, field, v)
+              end
+            end
+        end
+    end
+  end
+end

data/lib/active_fedora/model.rb

@@ -61,8 +61,10 @@ module ActiveFedora
         return_multiple = false
         if args == :all
           return_multiple = true
-          escaped_class_name = self.name.gsub(/(:)/, '\\:')
-          q = "#{ActiveFedora::SolrService.solr_name(:active_fedora_model, :symbol)}:#{escaped_class_name}"
+          # escaped_class_name = self.name.gsub(/(:)/, '\\:')
+          escaped_class_uri = "info:fedora/afmodel:#{self.name}".gsub(/(:)/, '\\:')
+          # q = "#{ActiveFedora::SolrService.solr_name(:active_fedora_model, :symbol)}:#{escaped_class_name}"
+          q = "#{ActiveFedora::SolrService.solr_name(:has_model, :symbol)}:#{escaped_class_uri}"
         elsif args.class == String
           escaped_id = args.gsub(/(:)/, '\\:')
           q = "#{SOLR_DOCUMENT_ID}:#{escaped_id}"

data/lib/active_fedora/nested_attributes.rb

@@ -0,0 +1,153 @@
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/indifferent_access'
+
+
+module ActiveFedora
+  module NestedAttributes #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      class_inheritable_accessor :nested_attributes_options, :instance_writer => false
+      self.nested_attributes_options = {}
+    end
+
+
+    # Defines an attributes writer for the specified association(s). If you
+    # are using <tt>attr_protected</tt> or <tt>attr_accessible</tt>, then you
+    # will need to add the attribute writer to the allowed list.
+    #
+    # Supported options:
+    # [:allow_destroy]
+    #   If true, destroys any members from the attributes hash with a
+    #   <tt>_destroy</tt> key and a value that evaluates to +true+
+    #   (eg. 1, '1', true, or 'true'). This option is off by default.
+    # [:reject_if]
+    #   Allows you to specify a Proc or a Symbol pointing to a method
+    #   that checks whether a record should be built for a certain attribute
+    #   hash. The hash is passed to the supplied Proc or the method
+    #   and it should return either +true+ or +false+. When no :reject_if
+    #   is specified, a record will be built for all attribute hashes that
+    #   do not have a <tt>_destroy</tt> value that evaluates to true.
+    #   Passing <tt>:all_blank</tt> instead of a Proc will create a proc
+    #   that will reject a record where all the attributes are blank.
+    # [:limit]
+    #   Allows you to specify the maximum number of the associated records that
+    #   can be processed with the nested attributes. If the size of the
+    #   nested attributes array exceeds the specified limit, NestedAttributes::TooManyRecords
+    #   exception is raised. If omitted, any number associations can be processed.
+    #   Note that the :limit option is only applicable to one-to-many associations.
+    # [:update_only]
+    #   Allows you to specify that an existing record may only be updated.
+    #   A new record may only be created when there is no existing record.
+    #   This option only works for one-to-one associations and is ignored for
+    #   collection associations. This option is off by default.
+    #
+    # Examples:
+    #   # creates avatar_attributes=
+    #   accepts_nested_attributes_for :avatar, :reject_if => proc { |attributes| attributes['name'].blank? }
+    #   # creates avatar_attributes=
+    #   accepts_nested_attributes_for :avatar, :reject_if => :all_blank
+    #   # creates avatar_attributes= and posts_attributes=
+    #   accepts_nested_attributes_for :avatar, :posts, :allow_destroy => true
+    module ClassMethods
+      def accepts_nested_attributes_for(*attr_names)
+        options = { :allow_destroy => false, :update_only => false }
+        options.update(attr_names.extract_options!)
+        # options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only)
+        options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
+
+        attr_names.each do |association_name|
+          if reflection = reflect_on_association(association_name)
+            reflection.options[:autosave] = true
+            # add_autosave_association_callbacks(reflection)
+            ## TODO this ought to work, but doesn't seem to do the class inheitance right
+            nested_attributes_options[association_name.to_sym] = options
+            type = (reflection.collection? ? :collection : :one_to_one)
+
+            # def pirate_attributes=(attributes)
+            #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes)
+            # end
+            class_eval <<-eoruby, __FILE__, __LINE__ + 1
+              if method_defined?(:#{association_name}_attributes=)
+                remove_method(:#{association_name}_attributes=)
+              end
+              def #{association_name}_attributes=(attributes)
+                assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
+                ## in lieu of autosave_association_callbacks just save all of em.
+                send(:#{association_name}).each {|obj| obj.save}
+              end
+            eoruby
+          else
+            raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
+          end
+        end
+      end
+    end
+
+    private 
+
+    # Attribute hash keys that should not be assigned as normal attributes.
+    # These hash keys are nested attributes implementation details.
+    UNASSIGNABLE_KEYS = %w( id _destroy )
+
+
+    def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
+      options= {}
+      #options = nested_attributes_options[association_name]
+      if attributes_collection.is_a? Hash
+        keys = attributes_collection.keys
+        attributes_collection = if keys.include?('id') || keys.include?(:id)
+          Array.wrap(attributes_collection)
+        else
+          attributes_collection.sort_by { |i, _| i.to_i }.map { |_, attributes| attributes }
+        end
+      end
+
+      association = send(association_name)
+
+      existing_records = if association.loaded?
+        association.to_a
+      else
+        attribute_ids = attributes_collection.map {|a| a['id'] || a[:id] }.compact
+        attribute_ids.present? ? association.select{ |x| attribute_ids.include?(x.pid)} : []
+      end
+
+      attributes_collection.each do |attributes|
+        attributes = attributes.with_indifferent_access
+
+        if attributes['id'].blank?
+          association.build(attributes.except(*UNASSIGNABLE_KEYS))
+
+        elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes['id'].to_s }
+          association.send(:add_record_to_target_with_callbacks, existing_record) if !association.loaded? && !call_reject_if(association_name, attributes)
+          assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+
+        else
+          raise_nested_attributes_record_not_found(association_name, attributes['id'])
+        end
+      end
+
+    end
+
+    # Updates a record with the +attributes+ or marks it for destruction if
+    # +allow_destroy+ is +true+ and has_destroy_flag? returns +true+.
+    def assign_to_or_mark_for_destruction(record, attributes, allow_destroy)
+      record.attributes = attributes.except(*UNASSIGNABLE_KEYS)
+      record.mark_for_destruction if has_destroy_flag?(attributes) && allow_destroy
+    end
+
+    # Determines if a hash contains a truthy _destroy key.
+    def has_destroy_flag?(hash)
+      ["1", "true"].include?(hash['_destroy'].to_s)
+    end
+
+    def raise_nested_attributes_record_not_found(association_name, record_id)
+      reflection = self.class.reflect_on_association(association_name)
+      raise ObjectNotFoundError, "Couldn't find #{reflection.klass.name} with ID=#{record_id} for #{self.class.name} with ID=#{id}"
+    end
+
+  end
+end
+
+  

data/lib/active_fedora/nokogiri_datastream.rb

@@ -14,8 +14,7 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
   alias_method(:om_term_values, :term_values) unless method_defined?(:om_term_values)
   alias_method(:om_update_values, :update_values) unless method_defined?(:om_update_values)
   
-  attr_accessor :internal_solr_doc
-  attr_reader :ng_xml
+  attr_accessor :ng_xml, :internal_solr_doc
   
   #constructor, calls up to ActiveFedora::Datastream's constructor
   def initialize(attrs=nil)
@@ -44,22 +43,22 @@ class ActiveFedora::NokogiriDatastream < ActiveFedora::Datastream
     Nokogiri::XML::Document.parse("<xml/>")
   end
   
-  def ng_xml=(new_xml)
-    case new_xml 
-    when Nokogiri::XML::Document, Nokogiri::XML::Element, Nokogiri::XML::Node
-      @ng_xml = new_xml
-    when String 
-      @ng_xml = Nokogiri::XML::Document.parse(new_xml)
-    else
-      raise TypeError, "You passed a #{new_xml.class} into the ng_xml of the #{self.dsid} datastream. NokogiriDatastream.ng_xml= only accepts Nokogiri::XML::Document, Nokogiri::XML::Element, Nokogiri::XML::Node, or raw XML (String) as inputs."
-    end
-    self.dirty = true
-  end
-  
-  def content=(content)
-    super
-    self.ng_xml = Nokogiri::XML::Document.parse(content)
-  end
+  # class << self
+  #   from_xml_original = self.instance_method(:from_xml)
+  #   
+  #   define_method(:from_xml, xml, tmpl=self.new) do
+  #     from_xml_original.bind(self).call(xml, tmpl)
+  #     tmpl.send(:dirty=, false)
+  #   end
+  #   
+  #   # def from_xml_custom(xml, tmpl=self.new)
+  #   #   from_xml_original(xml, tmpl)
+  #   #   tmpl.send(:dirty=, false)
+  #   # end
+  #   # 
+  #   # alias_method :from_xml_original, :from_xml 
+  #   # alias_method :from_xml, :from_xml_custom
+  # end
   
   
   def to_xml(xml = self.ng_xml)

data/lib/active_fedora/reflection.rb

@@ -0,0 +1,140 @@
+module ActiveFedora
+  module Reflection # :nodoc:
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def create_reflection(macro, name, options, active_fedora)
+        case macro
+          when :has_many, :belongs_to
+            klass = AssociationReflection
+            reflection = klass.new(macro, name, options, active_fedora)
+        end
+        write_inheritable_hash :reflections, name => reflection
+        reflection
+      end
+
+      # Returns a hash containing all AssociationReflection objects for the current class.
+      # Example:
+      #
+      #   Invoice.reflections
+      #   Account.reflections
+      #
+      def reflections
+        read_inheritable_attribute(:reflections) || write_inheritable_attribute(:reflections, {})
+      end
+
+      # Returns the AssociationReflection object for the +association+ (use the symbol).
+      #
+      #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      #
+      def reflect_on_association(association)
+        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+      end
+
+      class MacroReflection
+
+        # Returns the target association's class.
+        #
+        #   class Author < ActiveRecord::Base
+        #     has_many :books
+        #   end
+        #
+        #   Author.reflect_on_association(:books).klass
+        #   # => Book
+        #
+        # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+        # a new association object. Use +build_association+ or +create_association+
+        # instead. This allows plugins to hook into association object creation.
+        def klass
+          #@klass ||= active_record.send(:compute_type, class_name)
+          @klass ||= class_name
+        end
+
+
+
+        def initialize(macro, name, options, active_fedora)
+          @macro, @name, @options, @active_fedora = macro, name, options, active_fedora
+        end
+
+        # Returns a new, unsaved instance of the associated class. +options+ will
+        # be passed to the class's constructor.
+        def build_association(*options)
+          klass.new(*options)
+        end
+
+        # Returns the name of the macro.
+        #
+        # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:balance</tt>
+        # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+        attr_reader :name
+
+
+        # Returns the hash of options used for the macro.
+        #
+        # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>{ :class_name => "Money" }</tt>
+        # <tt>has_many :clients</tt> returns +{}+
+        attr_reader :options
+
+
+        # Returns the class for the macro.
+        #
+        # <tt>composed_of :balance, :class_name => 'Money'</tt> returns the Money class
+        # <tt>has_many :clients</tt> returns the Client class
+        def klass
+          @klass ||= class_name.constantize
+        end
+
+        # Returns the class name for the macro.
+        #
+        # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
+        # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+        def class_name
+          @class_name ||= options[:class_name] || derive_class_name
+        end
+
+
+        # Returns whether or not this association reflection is for a collection
+        # association. Returns +true+ if the +macro+ is either +has_many+ or
+        # +has_and_belongs_to_many+, +false+ otherwise.
+        def collection?
+          @collection
+        end
+
+
+
+        private
+          def derive_class_name
+            class_name = name.to_s.camelize
+            class_name = class_name.singularize if collection?
+            class_name
+          end
+
+
+      end
+
+      # Holds all the meta-data about an association as it was specified in the
+      # Active Record class.
+      class AssociationReflection < MacroReflection #:nodoc:
+
+        def initialize(macro, name, options, active_record)
+          super
+          @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
+        end
+
+        def primary_key_name
+          @primary_key_name ||= options[:foreign_key] || derive_primary_key_name
+        end
+
+        private
+
+        def derive_primary_key_name
+          'pid'
+        end        
+
+      end
+    end
+  end
+end
+
+

data/lib/active_fedora/relationships_helper.rb

@@ -1,3 +1,4 @@
+require 'active_support/core_ext/class/inheritable_attributes'
 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.
@@ -22,13 +23,17 @@ module ActiveFedora
   #
   #   Then obj.parents will only return parents where their eyes are blue.
   module RelationshipsHelper
+    extend ActiveSupport::Concern
 
-    include MediaShelfClassLevelInheritableAttributes
-    ms_inheritable_attributes :class_relationships_desc
-
-    def self.included(klass)
-      klass.extend(ClassMethods)
+#    ms_inheritable_attributes :class_relationships_desc
+    included do
+      class_inheritable_accessor  :class_relationships_desc
+#    self.class_relationships_desc = {}
     end
+
+    # def self.included(klass)
+    #   klass.extend(ClassMethods)
+    # end
     
 
     # ** EXPERIMENTAL **

data/lib/active_fedora/semantic_node.rb

@@ -1,18 +1,13 @@
-require 'active_fedora/relationships_helper'
-
 module ActiveFedora
   module SemanticNode 
-    include MediaShelfClassLevelInheritableAttributes
-    
-    ms_inheritable_attributes  :class_relationships, :internal_uri
-    
-    attr_accessor :internal_uri, :relationships_are_dirty, :load_from_solr
-    
-
-    def self.included(klass)
-      klass.extend(ClassMethods)
-      klass.send(:include, ActiveFedora::RelationshipsHelper)
+    extend ActiveSupport::Concern
+    included do
+      class_inheritable_accessor  :class_relationships, :internal_uri, :class_named_relationships_desc
+      self.class_relationships = {}
+      self.class_named_relationships_desc = {}
     end
+    attr_accessor :internal_uri, :named_relationship_desc, :relationships_are_dirty, :load_from_solr
+    #TODO I think we can remove named_relationship_desc from attr_accessor  - jcoyne
 
     def assert_kind_of(n, o,t)
       raise "Assertion failure: #{n}: #{o} is not of type #{t}" unless o.kind_of?(t)
@@ -176,6 +171,56 @@ module ActiveFedora
       xml.to_s
     end
 
+    def load_inbound_relationship(name, predicate, opts={})
+      opts = {:rows=>25}.merge(opts)
+      query = self.class.inbound_relationship_query(self.pid,"#{name}")
+      return [] if query.empty?
+      solr_result = SolrService.instance.conn.query(query, :rows=>opts[:rows])
+      if opts[:response_format] == :solr
+        return solr_result
+      else
+        if opts[:response_format] == :id_array
+          id_array = []
+          solr_result.hits.each do |hit|
+            id_array << hit[SOLR_DOCUMENT_ID]
+          end
+          return id_array
+        elsif opts[:response_format] == :load_from_solr || self.load_from_solr
+          return ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+        else
+          return ActiveFedora::SolrService.reify_solr_results(solr_result)
+        end
+      end
+    end
+
+    def load_outbound_relationship(name, predicate, opts={})
+      id_array = []
+      if !outbound_relationships[predicate].nil? 
+        outbound_relationships[predicate].each do |rel|
+          id_array << rel.gsub("info:fedora/", "")
+        end
+      end
+      if opts[:response_format] == :id_array  && !self.class.relationship_has_solr_filter_query?(:self,"#{name}")
+        return id_array
+      else
+        query = self.class.outbound_relationship_query("#{name}",id_array)
+        solr_result = SolrService.instance.conn.query(query)
+        if opts[:response_format] == :solr
+          return solr_result
+        elsif opts[:response_format] == :id_array
+          id_array = []
+          solr_result.hits.each do |hit|
+            id_array << hit[SOLR_DOCUMENT_ID]
+          end
+          return id_array
+        elsif opts[:response_format] == :load_from_solr || self.load_from_solr
+          return ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
+        else
+          return ActiveFedora::SolrService.reify_solr_results(solr_result)
+        end
+      end
+    end
+    
     module ClassMethods
       #include ActiveFedora::RelationshipsHelper::ClassMethods
 
@@ -227,7 +272,7 @@ module ActiveFedora
           register_predicate(:inbound, predicate)
           create_inbound_relationship_finders(name, predicate, opts)
         else
-          #raise "Duplicate use of predicate for outbound relationship name not allowed" if predicate_exists_with_different_relationship_name?(:self,name,predicate)
+          #raise "Duplicate use of predicate for named outbound relationship \"#{predicate.inspect}\" not allowed" if named_predicate_exists_with_different_name?(:self,name,predicate)
           register_relationship_desc(:self, name, predicate, opts)
           register_predicate(:self, predicate)
           create_relationship_name_methods(name)
@@ -253,29 +298,96 @@ module ActiveFedora
       def has_bidirectional_relationship(name, outbound_predicate, inbound_predicate, opts={})
         create_bidirectional_relationship_finders(name, outbound_predicate, inbound_predicate, opts)
       end
+      
+      # ** EXPERIMENTAL **
+      # 
+      # Check to make sure a subject,name, and predicate triple does not already exist
+      # with the same subject but different name.
+      # This method is used to ensure conflicting has_relationship calls are not made because
+      # predicates cannot be reused across relationship names.  Otherwise, the mapping of relationship name
+      # to predicate in RELS-EXT would be broken.
+      def named_predicate_exists_with_different_name?(subject,name,predicate)
+        if named_relationships_desc.has_key?(subject)
+          named_relationships_desc[subject].each_pair do |existing_name, args|
+            return true if !args[:predicate].nil? && args[:predicate] == predicate && existing_name != name 
+          end
+        end
+        return false
+      end
+      
+      # ** EXPERIMENTAL **
+      #  
+      # Return hash that stores named relationship metadata defined by has_relationship calls
+      # ====Example
+      # For the following relationship
+      #
+      #  has_relationship "audio_records", :has_part, :type=>AudioRecord
+      # Results in the following returned by named_relationships_desc
+      #  {:self=>{"audio_records"=>{:type=>AudioRecord, :singular=>nil, :predicate=>:has_part, :inbound=>false}}}
+      def named_relationships_desc
+        @class_named_relationships_desc ||= Hash[:self => {}]
+        #class_named_relationships_desc
+      end
+      
+      # ** EXPERIMENTAL **
+      #   
+      # Internal method that ensures a relationship subject such as :self and :inbound
+      # exist within the named_relationships_desc hash tracking named relationships metadata. 
+      def register_named_subject(subject)
+        unless named_relationships_desc.has_key?(subject) 
+          named_relationships_desc[subject] = {} 
+        end
+      end
+  
+      # ** EXPERIMENTAL **
+      # 
+      # Internal method that adds relationship name and predicate pair to either an outbound (:self)
+      # or inbound (:inbound) relationship types.
+      def register_named_relationship(subject, name, predicate, opts)
+        register_named_subject(subject)
+        opts.merge!({:predicate=>predicate})
+        named_relationships_desc[subject][name] = opts
+      end
+      
+      # ** EXPERIMENTAL **
+      #   
+      # Used in has_relationship call to create dynamic helper methods to 
+      # append and remove objects to and from a named relationship
+      # ====Example
+      # For the following relationship
+      #
+      #  has_relationship "audio_records", :has_part, :type=>AudioRecord
+      #
+      # Methods audio_records_append and audio_records_remove are created.
+      # Boths methods take an object that is kind_of? ActiveFedora::Base as a parameter
+      def create_named_relationship_methods(name)
+        append_method_name = "#{name.to_s.downcase}_append"
+        remove_method_name = "#{name.to_s.downcase}_remove"
+        self.send(:define_method,:"#{append_method_name}") {|object| add_named_relationship(name,object)}
+        self.send(:define_method,:"#{remove_method_name}") {|object| remove_named_relationship(name,object)}
+      end 
+
+      #  ** EXPERIMENTAL **
+      #  Similar to +create_named_relationship_methods+ except we are merely creating an alias for outbound portion of bidirectional
+      #
+      #  ====Example
+      #    has_bidirectional_relationship "members", :has_collection_member, :is_member_of_collection
+      #    
+      #    Method members_outbound_append and members_outbound_remove added
+      #    This method will create members_append which does same thing as members_outbound_append
+      #    and will create members_remove which does same thing as members_outbound_remove
+      def create_bidirectional_named_relationship_methods(name,outbound_name)
+        append_method_name = "#{name.to_s.downcase}_append"
+        remove_method_name = "#{name.to_s.downcase}_remove"
+        self.send(:define_method,:"#{append_method_name}") {|object| add_named_relationship(outbound_name,object)}
+        self.send(:define_method,:"#{remove_method_name}") {|object| remove_named_relationship(outbound_name,object)}
+      end
+
     
       def create_inbound_relationship_finders(name, predicate, opts = {})
         class_eval <<-END
         def #{name}(opts={})
-          opts = {:rows=>25}.merge(opts)
-          query = self.class.inbound_relationship_query(self.pid,"#{name}")
-          return [] if query.empty?
-          solr_result = SolrService.instance.conn.query(query, :rows=>opts[:rows])
-          if opts[:response_format] == :solr
-            return solr_result
-          else
-            if opts[:response_format] == :id_array
-              id_array = []
-              solr_result.hits.each do |hit|
-                id_array << hit[SOLR_DOCUMENT_ID]
-              end
-              return id_array
-            elsif opts[:response_format] == :load_from_solr || self.load_from_solr
-              return ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
-            else
-              return ActiveFedora::SolrService.reify_solr_results(solr_result)
-            end
-          end
+          load_inbound_relationship('#{name}', '#{predicate}', opts)
         end
         def #{name}_ids
           #{name}(:response_format => :id_array)
@@ -292,31 +404,7 @@ module ActiveFedora
       def create_outbound_relationship_finders(name, predicate, opts = {})
         class_eval <<-END
         def #{name}(opts={})
-          id_array = []
-          if !outbound_relationships[#{predicate.inspect}].nil? 
-            outbound_relationships[#{predicate.inspect}].each do |rel|
-              id_array << rel.gsub("info:fedora/", "")
-            end
-          end
-          if opts[:response_format] == :id_array && !self.class.relationship_has_solr_filter_query?(:self,"#{name}")
-            return id_array
-          else
-            query = self.class.outbound_relationship_query("#{name}",id_array)
-            solr_result = SolrService.instance.conn.query(query)
-            if opts[:response_format] == :solr
-              return solr_result
-            elsif opts[:response_format] == :id_array
-              id_array = []
-              solr_result.hits.each do |hit|
-                id_array << hit[SOLR_DOCUMENT_ID]
-              end
-              return id_array
-            elsif opts[:response_format] == :load_from_solr || self.load_from_solr
-              return ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
-            else
-              return ActiveFedora::SolrService.reify_solr_results(solr_result)
-            end
-          end
+          load_outbound_relationship(#{name.inspect}, #{predicate.inspect}, opts)
         end
         def #{name}_ids
           #{name}(:response_format => :id_array)
@@ -390,6 +478,7 @@ module ActiveFedora
       #   ds.relationships # => {:self=>{:has_model=>["afmodel:SimpleThing"],:has_part=>["demo:20"]},:inbound=>{:is_part_of=>["demo:6"]} 
       def relationships
         @class_relationships ||= Hash[:self => {}]
+        #class_relationships
       end