active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/rdf/indexing.rb

@@ -2,33 +2,37 @@ module ActiveFedora
   module RDF
     module Indexing
       extend ActiveSupport::Concern
+      included do
+        include Solrizer::Common
+      end
 
-      def apply_prefix(name)
-        prefix + name.to_s
+      def apply_prefix(name, file_path)
+        name.to_s
       end
 
-      def to_solr(solr_doc = Hash.new) # :nodoc:
-        fields.each do |field_key, field_info|
-          values = resource.get_values(field_key)
-          Array(values).each do |val|
-            if val.kind_of? ::RDF::URI
-              val = val.to_s 
-            elsif val.kind_of? ActiveTriples::Resource
-              val = val.solrize
+      def to_solr(solr_doc={}, opts={}) # :nodoc:
+        super.tap do |solr_doc|
+          fields.each do |field_key, field_info|
+            values = resource.get_values(field_key)
+            Array(values).each do |val|
+              if val.kind_of? ::RDF::URI
+                val = val.to_s
+              elsif val.kind_of? ActiveTriples::Resource
+                val = val.solrize
+              end
+              self.class.create_and_insert_terms(apply_prefix(field_key, opts[:name]), val, field_info[:behaviors], solr_doc)
             end
-            self.class.create_and_insert_terms(apply_prefix(field_key), val, field_info[:behaviors], solr_doc)
           end
         end
-        solr_doc
       end
 
-      # Gives the primary solr name for a column. If there is more than one indexer on the field definition, it gives the first 
-      def primary_solr_name(field)
+      # Gives the primary solr name for a column. If there is more than one indexer on the field definition, it gives the first
+      def primary_solr_name(field, file_path)
         config = self.class.config_for_term_or_uri(field)
         return nil unless config # punt on index names for deep nodes!
         if behaviors = config.behaviors
           behaviors.each do |behavior|
-            result = ActiveFedora::SolrService.solr_name(apply_prefix(field), behavior, type: config.type)
+            result = ActiveFedora::SolrService.solr_name(apply_prefix(field, file_path), behavior, type: config.type)
             return result if Solrizer::DefaultDescriptors.send(behavior).evaluate_suffix(:text).stored?
           end
           raise RuntimeError "no stored fields were found"
@@ -41,7 +45,7 @@ module ActiveFedora
           config_for_term_or_uri(field).type
         end
       end
-      
+
       private
         # returns a Hash, e.g.: {field => {:values => [], :type => :something, :behaviors => []}, ...}
         def fields

data/lib/active_fedora/rdf/ldp.rb

@@ -0,0 +1,6 @@
+require 'rdf'
+class ActiveFedora::RDF::Ldp < RDF::StrictVocabulary("http://www.w3.org/ns/ldp#")
+  # Property definitions
+  property :contains
+  property :member
+end

data/lib/active_fedora/rdf/ntriples_rdf_datastream.rb

@@ -3,7 +3,7 @@ require 'rdf/ntriples'
 module ActiveFedora
   class NtriplesRDFDatastream < RDFDatastream
     def self.default_attributes
-      super.merge(:controlGroup => 'M', :mimeType => 'application/n-triples')
+      super.merge(:mimeType => 'text/plain')
     end
 
     def serialization_format

data/lib/active_fedora/rdf/persistence.rb

@@ -5,7 +5,7 @@ module ActiveFedora
     # descendant so that it may be used to back an ActiveFedora::RDFDatastream.
     #
     # @see ActiveFedora::RDFDatastream.resource_class
-    # @see ActiveFedora::Rdf::ObjectResource
+    # @see ActiveFedora::RDF::ObjectResource
     #
     module Persistence
       extend ActiveSupport::Concern
@@ -16,18 +16,17 @@ module ActiveFedora
         configure :base_uri => BASE_URI unless base_uri
         attr_accessor :datastream
       end
-     
+
       # Overrides ActiveTriples::Resource
       def persist!
-        return false unless datastream and datastream.respond_to? :digital_object
-        @persisted ||= datastream.digital_object.save
+        return false unless datastream and datastream.respond_to? :save
+        @persisted ||= datastream.save
       end
 
       # Overrides ActiveTriples::Resource
       def persisted?
-        @persisted ||= (not datastream.new?)
+        @persisted ||= (not datastream.new_record?)
       end
-
     end
   end
 end

data/lib/active_fedora/rdf/rdf_datastream.rb

@@ -1,8 +1,7 @@
 module ActiveFedora
-  class RDFDatastream < ActiveFedora::Datastream
-    include Solrizer::Common
+  class RDFDatastream < File
     include ActiveTriples::NestedAttributes
-    include RDF::Indexing
+    include RDF::DatastreamIndexing
     include ActiveTriples::Properties
     include ActiveTriples::Reflection
 
@@ -14,12 +13,22 @@ module ActiveFedora
           return @subject_block = block
         end
 
-        @subject_block ||= lambda { |ds| ds.pid }
+        @subject_block ||= lambda { |ds| parent_uri(ds) }
+      end
+
+      # Trim the last segment off the URI to get the parents uri
+      def parent_uri(ds)
+        m = /^(.*)\/[^\/]*$/.match(ds.uri)
+        if m
+          m[1]
+        else
+          ::RDF::URI.new(nil)
+        end
       end
 
       ##
       # @param [Class] an object to set as the resource class, Must be a descendant of 
-      # ActiveTriples::Resource and include ActiveFedora::Rdf::Persistence.
+      # ActiveTriples::Resource and include ActiveFedora::RDF::Persistence.
       #
       # @return [Class] the object resource class
       def resource_class(klass=nil)
@@ -27,26 +36,26 @@ module ActiveFedora
           raise ArgumentError, "#{self} already has a resource_class #{@resource_class}, cannot redefine it to #{klass}" if @resource_class and klass != @resource_class
           raise ArgumentError, "#{klass} must be a subclass of ActiveTriples::Resource" unless klass < ActiveTriples::Resource
         end
-        
+
         @resource_class ||= begin
                               klass = Class.new(klass || ActiveTriples::Resource)
                               klass.send(:include, RDF::Persistence)
                               klass
                             end
-      end                                                    
+      end
     end
 
     before_save do
       if content.blank?
         ActiveFedora::Base.logger.warn "Cowardly refusing to save a datastream with empty content: #{self.inspect}" if ActiveFedora::Base.logger
-        if ActiveSupport.version >= Gem::Version.new('5.0')
-          throw(:abort)
-        else
-          false
-        end
+        false
       end
     end
 
+    def parent_uri
+      self.class.parent_uri(self)
+    end
+
     def metadata?
       true
     end
@@ -58,15 +67,25 @@ module ActiveFedora
     def content=(new_content)
       resource.clear!
       resource << deserialize(new_content)
-      new_content
+      content
+    end
+
+    def uri=(uri)
+      super
+      resource.set_subject!(parent_uri) if empty_or_blank_subject?
     end
 
     def content_changed?
       return false unless instance_variable_defined? :@resource
+      return true if empty_or_blank_subject? # can't be serialized because a subject hasn't been assigned yet.
       @content = serialize
       super
     end
 
+    def empty_or_blank_subject?
+      resource.rdf_subject.node? || resource.rdf_subject.value.blank?
+    end
+
     def freeze
       @resource.freeze
     end
@@ -81,13 +100,13 @@ module ActiveFedora
       @resource ||= begin
                       klass = self.class.resource_class
                       klass.properties.merge(self.class.properties).each do |prop, config|
-                        klass.property(config.term, 
-                                       predicate: config.predicate, 
-                                       class_name: config.class_name, 
+                        klass.property(config.term,
+                                       predicate: config.predicate,
+                                       class_name: config.class_name,
                                        multivalue: config.multivalue)
                       end
                       klass.accepts_nested_attributes_for(*nested_attributes_options.keys) unless nested_attributes_options.blank?
-                      uri_stub = digital_object ? self.class.rdf_subject.call(self) : nil
+                      uri_stub = self.class.rdf_subject.call(self)
 
                       r = klass.new(uri_stub)
                       r.datastream = self
@@ -98,10 +117,14 @@ module ActiveFedora
 
     alias_method :graph, :resource
 
+    def refresh_attributes
+      @resource = nil
+    end
+
     ##
     # This method allows for delegation.
     # This patches the fact that there's no consistent API for allowing delegation - we're matching the
-    # OMDatastream implementation as our "consistency" point.
+    # OmDatastream implementation as our "consistency" point.
     # @TODO: We may need to enable deep RDF delegation at one point.
     def term_values(*values)
       self.send(values.first)
@@ -116,18 +139,13 @@ module ActiveFedora
     end
 
     def serialize
-      resource.set_subject!(pid) if (digital_object or pid) and rdf_subject.node?
+      resource.set_subject!(parent_uri) if parent_uri and rdf_subject.node?
       resource.dump serialization_format
     end
 
     def deserialize(data=nil)
-      return ::RDF::Graph.new if new? && data.nil?
-
-      if data.nil?
-        data = datastream_content
-      elsif behaves_like_io?(data)
-        data = io_content(data)
-      end
+      return ::RDF::Graph.new if new_record? && data.nil?
+      data ||= remote_content
 
       # Because datastream_content can return nil, we should check that here.
       return ::RDF::Graph.new if data.nil?
@@ -140,16 +158,5 @@ module ActiveFedora
       raise "you must override the `serialization_format' method in a subclass"
     end
 
-    private
-
-    def io_content(data)
-      begin
-        data.rewind
-        data.read
-      ensure
-        data.rewind
-      end
-    end
-
   end
 end

data/lib/active_fedora/rdf/rdfxml_datastream.rb

@@ -0,0 +1,13 @@
+require 'rdf/rdfxml'
+
+module ActiveFedora
+  class RDFXMLDatastream < RDFDatastream
+    def serialization_format
+      :rdfxml 
+    end
+
+    def mime_type 
+      'text/xml'
+    end
+  end
+end

data/lib/active_fedora/rdf/rels_ext.rb

@@ -0,0 +1,26 @@
+require 'rdf'
+class ActiveFedora::RDF::RelsExt < RDF::StrictVocabulary("http://fedora.info/definitions/v4/rels-ext#")
+  property :hasAnnotation
+  property :hasCollectionMember
+  property :hasConstituent
+  property :hasDependent
+  property :hasDerivation
+  property :hasDescription
+  property :hasEquivalent
+  property :hasExternalContent
+  property :hasMember
+  property :hasMetadata
+  property :hasPart
+  property :hasSubset
+  property :isAnnotationOf
+  property :isConstituentOf
+  property :isDependentOf
+  property :isDerivationOf
+  property :isDescriptionOf
+  property :isExternalContentOf
+  property :isMemberOf
+  property :isMemberOfCollection
+  property :isMetadataFor
+  property :isPartOf
+  property :isSubsetOf
+end

data/lib/active_fedora/reflection.rb

@@ -8,23 +8,24 @@ module ActiveFedora
     end
 
     module ClassMethods
-      def reflection_name_for_predicate(predicate)
-        reflections.each do |k, v|
-          return k if v.options[:property] == predicate
-        end
-      end
-
       def create_reflection(macro, name, options, active_fedora)
-        case macro
-          when :has_many, :belongs_to, :has_and_belongs_to_many
-            klass = AssociationReflection
-            reflection = klass.new(macro, name, options, active_fedora)
+        klass = case macro
+          when :has_many, :belongs_to, :has_and_belongs_to_many, :contains
+            AssociationReflection
+          when :rdf, :singular_rdf
+            RDFPropertyReflection
         end
+        reflection = klass.new(macro, name, options, active_fedora)
+        add_reflection name, reflection
 
-        self.reflections = self.reflections.merge(name => reflection)
         reflection
       end
 
+      def add_reflection(name, reflection)
+        # FIXME this is where the problem with association_spec is caused (key is string now)
+        self.reflections = self.reflections.merge(name => reflection)
+      end
+
       # Returns a hash containing all AssociationReflection objects for the current class.
       # Example:
       #
@@ -35,6 +36,14 @@ module ActiveFedora
         read_inheritable_attribute(:reflections) || write_inheritable_attribute(:reflections, {})
       end
 
+      def outgoing_reflections
+        reflections.select { |_, reflection| reflection.kind_of? RDFPropertyReflection }
+      end
+
+      def child_resource_reflections
+        reflections.select { |_, reflection| reflection.kind_of?(AssociationReflection) && reflection.macro == :contains }
+      end
+
       # Returns the AssociationReflection object for the +association+ (use the symbol).
       #
       #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
@@ -43,242 +52,290 @@ module ActiveFedora
       def reflect_on_association(association)
         val = reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
         unless val
-          # When a has_many is paired with a has_and_belongs_to_many the assocation will have a plural name 
+          # When a has_many is paired with a has_and_belongs_to_many the assocation will have a plural name
           association = association.to_s.pluralize.to_sym
           val = reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
         end
-        val 
+        val
       end
 
       def reflect_on_all_autosave_associations
         reflections.values.select { |reflection| reflection.options[:autosave] }
       end
+    end
 
 
-      class MacroReflection
-        # Returns the name of the macro.
-        #
-        # <tt>has_many :clients</tt> returns <tt>:clients</tt>
-        attr_reader :name
-
-        # Returns the macro type.
-        #
-        # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
-        attr_reader :macro
-
-        # Returns the hash of options used for the macro.
-        #
-        # <tt>has_many :clients</tt> returns +{}+
-        attr_reader :options
-
-        attr_reader :active_fedora
-
-        # 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 ||= class_name.constantize
-        end
+    class MacroReflection
+      # Returns the name of the macro.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
 
-        def initialize(macro, name, options, active_fedora)
-          @macro, @name, @options, @active_fedora = macro, name, options, active_fedora
-          @automatic_inverse_of = nil
-        end
+      # Returns the macro type.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      attr_reader :macro
 
-        # 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 hash of options used for the macro.
+      #
+      # <tt>has_many :clients</tt> returns +{}+
+      attr_reader :options
 
+      attr_reader :active_fedora
 
-        # Returns the class name for the macro.
-        #
-        # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
-        def class_name
-          @class_name ||= options[:class_name] || derive_class_name
-        end
+      # 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 ||= class_name.constantize
+      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
+      def initialize(macro, name, options, active_fedora)
+        @macro, @name, @options, @active_fedora = macro, name, options, active_fedora
+        @automatic_inverse_of = nil
+      end
 
-        # Returns +true+ if +self+ is a +belongs_to+ reflection.
-        def belongs_to?
-          macro == :belongs_to
-        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
 
-        private
-          def derive_class_name
-            class_name = name.to_s.camelize
-            class_name = class_name.singularize if collection?
-            class_name
-          end
 
-          def derive_foreign_key
-            if belongs_to?
-              "#{name}_id"
-            elsif options[:as]
-              "#{options[:as]}_id"
-            else
-              active_fedora.name.foreign_key
-            end
-          end
+      # Returns the class name for the macro.
+      #
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= options[:class_name] || derive_class_name
       end
 
-      # Holds all the meta-data about an association as it was specified in the
-      # Active Record class.
-      class AssociationReflection < MacroReflection #:nodoc:
+      # 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
 
-        def initialize(macro, name, options, active_fedora)
-          super
-          @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
-        end
+      # Returns +true+ if +self+ is a +belongs_to+ reflection.
+      def belongs_to?
+        macro == :belongs_to
+      end
 
+      def has_many?
+        macro == :has_many
+      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
+      def has_and_belongs_to_many?
+        macro == :has_and_belongs_to_many
+      end
 
-        # Creates a new instance of the associated class, and immediately saves it
-        # with ActiveFedora::Base#save. +options+ will be passed to the class's
-        # creation method. Returns the newly created object.
-        def create_association(*options)
-          klass.create(*options)
+      private
+        def derive_class_name
+          class_name = name.to_s.camelize
+          class_name = class_name.singularize if collection?
+          class_name
         end
 
-        def foreign_key
-          @foreign_key ||= options[:foreign_key] || derive_foreign_key
+        def derive_foreign_key
+          if belongs_to?
+            "#{name}_id"
+          elsif has_and_belongs_to_many?
+            "#{name.to_s.singularize}_ids"
+          elsif options[:as]
+            "#{options[:as]}_id"
+          else
+            # This works well if this is a has_many that is the inverse of a belongs_to, but it isn't correct for a has_many that is the invers of a has_and_belongs_to_many
+            active_fedora.name.foreign_key
+          end
         end
+    end
 
-        # A chain of reflections from this one back to the owner. For more see the explanation in
-        # ThroughReflection.
-        def chain
-          [self]
-        end
+    # Holds all the meta-data about an association as it was specified in the
+    # Active Record class.
+    class AssociationReflection < MacroReflection #:nodoc:
 
-        alias :source_macro :macro
+      def initialize(macro, name, options, active_fedora)
+        super
+        @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
+      end
 
-        def inverse_of
-          return unless inverse_name
 
-          @inverse_of ||= klass.reflect_on_association inverse_name
-        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 whether or not the association should be validated as part of
-        # the parent's validation.
-        #
-        # Unless you explicitly disable validation with
-        # <tt>:validate => false</tt>, validation will take place when:
-        #
-        # * you explicitly enable validation; <tt>:validate => true</tt>
-        # * you use autosave; <tt>:autosave => true</tt>
-        # * the association is a +has_many+ association
-        def validate?
-          !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
-        end
+      # Creates a new instance of the associated class, and immediately saves it
+      # with ActiveFedora::Base#save. +options+ will be passed to the class's
+      # creation method. Returns the newly created object.
+      def create_association(*options)
+        klass.create(*options)
+      end
 
-        def association_class
-          case macro
-          when :belongs_to
-            Associations::BelongsToAssociation
-          when :has_and_belongs_to_many
-            Associations::HasAndBelongsToManyAssociation
-          when :has_many
-            Associations::HasManyAssociation
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key
+      end
+
+      # Returns the RDF predicate as defined by the :predicate option
+      def predicate
+        options[:predicate]
+      end
+
+      def solr_key
+        ActiveFedora::SolrService.solr_name(predicate.to_s, :symbol)
+      end
+
+      def check_validity!
+        check_validity_of_inverse!
+      end
+
+      def check_validity_of_inverse!
+        unless options[:polymorphic]
+          if has_inverse? && inverse_of.nil?
+            raise InverseOfAssociationNotFoundError.new(self)
           end
         end
+      end
 
-        VALID_AUTOMATIC_INVERSE_MACROS = [:has_many, :has_and_belongs_to_many, :belongs_to]
-        INVALID_AUTOMATIC_INVERSE_OPTIONS = [:conditions, :through, :polymorphic, :foreign_key]
-        
+      # A chain of reflections from this one back to the owner. For more see the explanation in
+      # ThroughReflection.
+      def chain
+        [self]
+      end
 
-        private
+      alias :source_macro :macro
 
-        def inverse_name
-          options.fetch(:inverse_of) do
-            if @automatic_inverse_of == false
-              nil
-            else
-              @automatic_inverse_of ||= automatic_inverse_of
-            end
-          end
+      def has_inverse?
+        inverse_name
+      end
+
+      def inverse_of
+        return unless inverse_name
+
+        @inverse_of ||= klass.reflect_on_association inverse_name
+      end
+
+
+      # Returns whether or not the association should be validated as part of
+      # the parent's validation.
+      #
+      # Unless you explicitly disable validation with
+      # <tt>:validate => false</tt>, validation will take place when:
+      #
+      # * you explicitly enable validation; <tt>:validate => true</tt>
+      # * you use autosave; <tt>:autosave => true</tt>
+      # * the association is a +has_many+ association
+      def validate?
+        !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
+      end
+
+      def association_class
+        case macro
+        when :contains
+          Associations::ContainsAssociation
+        when :belongs_to
+          Associations::BelongsToAssociation
+        when :has_and_belongs_to_many
+          Associations::HasAndBelongsToManyAssociation
+        when :has_many
+          Associations::HasManyAssociation
+        when :singular_rdf
+          Associations::SingularRDF
+        when :rdf
+          Associations::RDF
         end
+      end
 
-        # Checks if the inverse reflection that is returned from the
-        # +automatic_inverse_of+ method is a valid reflection. We must
-        # make sure that the reflection's active_record name matches up
-        # with the current reflection's klass name.
-        #
-        # Note: klass will always be valid because when there's a NameError
-        # from calling +klass+, +reflection+ will already be set to false.
-        def valid_inverse_reflection?(reflection)
-          reflection &&
-            klass.name == reflection.active_fedora.name &&
-            can_find_inverse_of_automatically?(reflection)
+      VALID_AUTOMATIC_INVERSE_MACROS = [:has_many, :has_and_belongs_to_many, :belongs_to]
+      INVALID_AUTOMATIC_INVERSE_OPTIONS = [:conditions, :through, :polymorphic, :foreign_key]
+
+
+      private
+
+      def inverse_name
+        options.fetch(:inverse_of) do
+          if @automatic_inverse_of == false
+            nil
+          else
+            @automatic_inverse_of ||= automatic_inverse_of
+          end
         end
-        
-
-        # returns either nil or the inverse association name that it finds.
-        def automatic_inverse_of
-          if can_find_inverse_of_automatically?(self)
-            inverse_name = ActiveSupport::Inflector.underscore(active_fedora.name).to_sym
-
-            begin
-              reflection = klass.reflect_on_association(inverse_name)
-            rescue NameError
-              # Give up: we couldn't compute the klass type so we won't be able
-              # to find any associations either.
-              reflection = false
-            end
-
-            if valid_inverse_reflection?(reflection)
-              return inverse_name
-            end
+      end
+
+      # Checks if the inverse reflection that is returned from the
+      # +automatic_inverse_of+ method is a valid reflection. We must
+      # make sure that the reflection's active_record name matches up
+      # with the current reflection's klass name.
+      #
+      # Note: klass will always be valid because when there's a NameError
+      # from calling +klass+, +reflection+ will already be set to false.
+      def valid_inverse_reflection?(reflection)
+        reflection &&
+          klass.name == reflection.active_fedora.name &&
+          can_find_inverse_of_automatically?(reflection)
+      end
+
+
+      # returns either false or the inverse association name that it finds.
+      def automatic_inverse_of
+        if can_find_inverse_of_automatically?(self)
+          inverse_name = ActiveSupport::Inflector.underscore(active_fedora.name).to_sym
+
+          begin
+            reflection = klass.reflect_on_association(inverse_name)
+          rescue NameError
+            # Give up: we couldn't compute the klass type so we won't be able
+            # to find any associations either.
+            reflection = false
           end
 
-          false
+          if valid_inverse_reflection?(reflection)
+            return inverse_name
+          end
         end
 
-        # Checks to see if the reflection doesn't have any options that prevent
-        # us from being able to guess the inverse automatically. First, the
-        # <tt>inverse_of</tt> option cannot be set to false. Second, we must
-        # have <tt>has_many</tt>, <tt>has_one</tt>, <tt>belongs_to</tt> associations.
-        # Third, we must not have options such as <tt>:polymorphic</tt> or
-        # <tt>:foreign_key</tt> which prevent us from correctly guessing the
-        # inverse association.
-        #
-        # Anything with a scope can additionally ruin our attempt at finding an
-        # inverse, so we exclude reflections with scopes.
-        def can_find_inverse_of_automatically?(reflection)
-          reflection.options[:inverse_of] != false &&
-            VALID_AUTOMATIC_INVERSE_MACROS.include?(reflection.macro) &&
-            !INVALID_AUTOMATIC_INVERSE_OPTIONS.any? { |opt| reflection.options[opt] } 
-            #&& !reflection.scope
-        end
+        false
+      end
 
-        # def derive_primary_key_name
-        #   'pid'
-        # end        
+      # Checks to see if the reflection doesn't have any options that prevent
+      # us from being able to guess the inverse automatically. First, the
+      # <tt>inverse_of</tt> option cannot be set to false. Second, we must
+      # have <tt>has_many</tt>, <tt>has_one</tt>, <tt>belongs_to</tt> associations.
+      # Third, we must not have options such as <tt>:polymorphic</tt> or
+      # <tt>:foreign_key</tt> which prevent us from correctly guessing the
+      # inverse association.
+      #
+      # Anything with a scope can additionally ruin our attempt at finding an
+      # inverse, so we exclude reflections with scopes.
+      def can_find_inverse_of_automatically?(reflection)
+        reflection.options[:inverse_of] != false &&
+          VALID_AUTOMATIC_INVERSE_MACROS.include?(reflection.macro) &&
+          !INVALID_AUTOMATIC_INVERSE_OPTIONS.any? { |opt| reflection.options[opt] }
+          #&& !reflection.scope
+      end
+    end
 
+    class RDFPropertyReflection < AssociationReflection
+
+      def derive_foreign_key
+        name
+      end
+
+      def derive_class_name
+        class_name = name.to_s.sub(/_ids?$/, '').camelize
+        class_name = class_name.singularize if collection?
+        class_name
       end
     end
   end
 end
-
-