active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/associations.rb

@@ -2,18 +2,28 @@ require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/object/blank'
 
 module ActiveFedora
+  class InverseOfAssociationNotFoundError < RuntimeError #:nodoc:
+    def initialize(reflection, associated_class = nil)
+      super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
+    end
+  end
+
   module Associations
+
     extend ActiveSupport::Concern
 
     autoload :Association,           'active_fedora/associations/association'
     autoload :AssociationScope,      'active_fedora/associations/association_scope'
     autoload :SingularAssociation,   'active_fedora/associations/singular_association'
+    autoload :RDF,                   'active_fedora/associations/rdf'
+    autoload :SingularRDF,           'active_fedora/associations/singular_rdf'
     autoload :CollectionAssociation, 'active_fedora/associations/collection_association'
     autoload :CollectionProxy,       'active_fedora/associations/collection_proxy'
 
     autoload :HasManyAssociation,             'active_fedora/associations/has_many_association'
     autoload :BelongsToAssociation,           'active_fedora/associations/belongs_to_association'
     autoload :HasAndBelongsToManyAssociation, 'active_fedora/associations/has_and_belongs_to_many_association'
+    autoload :ContainsAssociation,            'active_fedora/associations/contains_association'
 
     module Builder
       autoload :Association,             'active_fedora/associations/builder/association'
@@ -23,8 +33,11 @@ module ActiveFedora
       autoload :BelongsTo,           'active_fedora/associations/builder/belongs_to'
       autoload :HasMany,             'active_fedora/associations/builder/has_many'
       autoload :HasAndBelongsToMany, 'active_fedora/associations/builder/has_and_belongs_to_many'
-    end
+      autoload :Contains,            'active_fedora/associations/builder/contains'
 
+      autoload :Property,         'active_fedora/associations/builder/property'
+      autoload :SingularProperty, 'active_fedora/associations/builder/singular_property'
+    end
 
     # Clears out the association cache.
     def clear_association_cache #:nodoc:
@@ -47,13 +60,14 @@ module ActiveFedora
 
       association
     end
-    
-    
-    private 
+
+
+    private
 
       # Returns the specified association instance if it responds to :loaded?, nil otherwise.
       def association_instance_get(name)
-        @association_cache[name.to_sym]
+        raise "use a symbol" if name.is_a? String
+        @association_cache[name]
       end
 
       # Set the specified association instance.
@@ -67,7 +81,23 @@ module ActiveFedora
         Builder::HasMany.build(self, name, options)
       end
 
-  
+      # This method is used to specify the details of a contained resource.
+      # Pass the name as the first argument and a hash of options as the second argument
+      # Note that this method doesn't actually execute the block, but stores it, to be executed
+      # by any the implementation of the datastream(specified as :class_name)
+      #
+      # @param [String] :name the handle to refer to this child as
+      # @param [Hash] options
+      # @option options [Class] :class_name The class that will represent this child, should extend ``ActiveFedora::File''
+      # @option options [String] :url
+      # @option options [Boolean] :autocreate Always create this datastream on new objects
+      # @yield block executed by some types of child resources
+      def contains(name, options = {}, &block)
+        options[:block] = block if block
+        raise ArgumentError, "You must provide a name (dsid) for the datastream" unless name
+        Associations::Builder::Contains.build(self, name.to_sym, options)
+      end
+
       # Specifies a one-to-one association with another class. This method should only be used
       # if this class contains the foreign key.
       #
@@ -86,12 +116,12 @@ module ActiveFedora
       #
       # A Post class declares <tt>belongs_to :author</tt>, which will add:
       # * <tt>Post#author</tt> (similar to <tt>Author.find(author_id)</tt>)
-      # * <tt>Post#author=(author)</tt> 
+      # * <tt>Post#author=(author)</tt>
       # The declaration can also include an options hash to specialize the behavior of the association.
       #
       # === Options
       #
-      # [:property]
+      # [:predicate]
       #   the association predicate to use when storing the association +REQUIRED+
       # [:class_name]
       #   Specify the class name of the association. Use it only if that name can't be inferred
@@ -99,11 +129,12 @@ module ActiveFedora
       #   if the real class name is Person, you'll have to specify it with this option.
       #
       # Option examples:
-      #   belongs_to :firm, :property => :client_of
-      #   belongs_to :author, :class_name => "Person", :property => :author_of
+      #   belongs_to :firm, predicate: OurVocab.clientOf
+      #   belongs_to :author, class_name: "Person", predicate: OurVocab.authorOf
       def belongs_to(name, options = {})
-        raise "You must specify a property name for #{name}" if !options[:property]
         Builder::BelongsTo.build(self, name, options)
+
+        Builder::SingularProperty.build(self, name, options)
       end
 
 
@@ -160,17 +191,18 @@ module ActiveFedora
       #   Specify the class name of the association. Use it only if that name can't be inferred
       #   from the association name. So <tt>has_and_belongs_to_many :projects</tt> will by default be linked to the
       #   Project class, but if the real class name is SuperProject, you'll have to specify it with this option.
-      # [:property]
+      # [:predicate]
       #   <b>REQUIRED</b> Specify the predicate to use when storing the relationship.
       # [:inverse_of]
       #   Specify the predicate to use when storing the relationship on the foreign object. If it is not provided, the relationship will not set the foriegn association.
       #
       # Option examples:
-      #   has_and_belongs_to_many :projects, :property=>:works_on
-      #   has_and_belongs_to_many :nations, :class_name => "Country", :property=>:is_citizen_of
-      #   has_and_belongs_to_many :topics, :property=>:has_topic, :inverse_of=>:is_topic_of
+      #   has_and_belongs_to_many :projects, predicate: OurVocab.worksOn
+      #   has_and_belongs_to_many :nations, class_name: "Country", predicate: OurVocab.isCitizenOf
+      #   has_and_belongs_to_many :topics, predicate: RDF::FOAF.isPrimaryTopicOf, inverse_of: :is_topic_of
       def has_and_belongs_to_many(name, options = {})
         Builder::HasAndBelongsToMany.build(self, name, options)
+        Builder::Property.build(self, name, options.slice(:class_name, :predicate))
       end
     end
   end

data/lib/active_fedora/associations/association.rb

@@ -10,12 +10,12 @@ module ActiveFedora
     #
     class Association
       attr_reader :owner, :target, :reflection
+      attr_accessor :inversed
       delegate :options, :klass, to: :reflection
 
       def initialize(owner, reflection)
-        #reflection.check_validity!
+        reflection.check_validity!
         @owner, @reflection = owner, reflection
-        @updated = false
         reset
         # construct_scope
       end
@@ -24,6 +24,7 @@ module ActiveFedora
       def reset
         @loaded = false
         @target = nil
+        @inversed = false
       end
 
       # Reloads the \target and returns +self+ on success.
@@ -43,6 +44,7 @@ module ActiveFedora
       def loaded!
         @loaded = true
         @stale_state = stale_state
+        @inversed = false
       end
 
       # The target is stale if the target no longer points to the record(s) that the
@@ -52,7 +54,7 @@ module ActiveFedora
       #
       # Note that if the target has not been loaded, it is not considered stale.
       def stale_target?
-        loaded? && @stale_state != stale_state
+        !inversed && loaded? && @stale_state != stale_state
       end
 
       # Sets the target of this proxy to <tt>\target</tt>, and the \loaded flag to +true+.
@@ -76,16 +78,21 @@ module ActiveFedora
           @association_scope ||= AssociationScope.new(self).scope
         end
       end
-      
+
       # Set the inverse association, if possible
       def set_inverse_instance(record)
         if record && invertible_for?(record)
-          inverse = record.association(inverse_reflection_for(record).name)
-          inverse.target = owner
+          inverse = record.association(inverse_reflection_for(record).name.to_sym)
+          if inverse.is_a? ActiveFedora::Associations::HasAndBelongsToManyAssociation
+            inverse.target << owner
+          else
+            inverse.target = owner
+          end
+          inverse.inversed = true
         end
       end
 
-      
+
       # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
       # through association's scope)
       def target_scope
@@ -108,9 +115,16 @@ module ActiveFedora
         target
       end
 
+      def initialize_attributes(record) #:nodoc:
+        skip_assign = [reflection.foreign_key].compact
+        attributes = create_scope.except(*(record.changed - skip_assign))
+        record.attributes = attributes
+        set_inverse_instance(record)
+      end
+
         private
 
-        
+
         def find_target?
           !loaded? && (!owner.new_record? || foreign_key_present?) && klass
         end
@@ -158,6 +172,13 @@ module ActiveFedora
         def stale_state
         end
 
+        def build_record(attributes)
+          # TODO make initalize take a block and get rid of the tap
+          reflection.build_association(attributes).tap do |record|
+            initialize_attributes(record)
+          end
+        end
+
     end
   end
 end

data/lib/active_fedora/associations/association_scope.rb

@@ -3,7 +3,7 @@ module ActiveFedora
     class AssociationScope #:nodoc:
 
       attr_reader :association
-      
+
       delegate :klass, :owner, :reflection, :interpolate, :to => :association
       delegate :chain, :scope_chain, :options, :source_options, :active_record, :to => :reflection
 
@@ -11,29 +11,29 @@ module ActiveFedora
         @association = association
       end
 
-      
       def scope
         scope = klass.unscoped
         add_constraints(scope)
       end
 
       private
+
       def add_constraints(scope)
         chain.each_with_index do |reflection, i|
           if reflection.source_macro == :belongs_to
+            # Create a partial solr query using the ids. We may add additional filters such as class_name later
+            scope = scope.where( ActiveFedora::SolrService.construct_query_for_ids([owner[reflection.foreign_key]]))
           elsif reflection.source_macro == :has_and_belongs_to_many
           else
-            scope = scope.where( ActiveFedora::SolrService.construct_query_for_rel(association.send(:find_predicate) => owner.internal_uri))
+            scope = scope.where( ActiveFedora::SolrService.construct_query_for_rel(association.send(:find_predicate) => owner.id))
           end
 
-          
           is_first_chain = i == 0
           klass = is_first_chain ? self.klass : reflection.klass
         end
 
         scope
       end
-
     end
   end
 end

data/lib/active_fedora/associations/belongs_to_association.rb

@@ -2,49 +2,19 @@ module ActiveFedora
   module Associations
     class BelongsToAssociation < SingularAssociation #:nodoc:
 
-      def id_writer(id)
-        @full_result = nil
-        remove_matching_property_relationship
-        return if id.blank? or id == ActiveFedora::UnsavedDigitalObject::PLACEHOLDER
-        @owner.add_relationship(@reflection.options[:property], ActiveFedora::Base.internal_uri(id))
-      end
-
-      def id_reader
-        begin
-          # need to find the id with the correct class
-          ids = @owner.ids_for_outbound(@reflection.options[:property])
-
-          return if ids.empty?
-
-          # This incurs a lot of overhead, but it's necessary if the users use one property for more than one association.
-          # e.g.
-          #   belongs_to :author, property: :has_member, class_name: 'Person'
-          #   belongs_to :publisher, property: :has_member
-          
-          if @owner.reflections.one? { |k, v| v.options[:property] == @reflection.options[:property] }
-            @full_results = nil
-            ids.first
-          else
-            @full_results = SolrService.query(construct_query(ids))
-            @full_results.first['id'] if @full_results.present?
-          end
-        end
-      end
-
       def replace(record)
-        if record.nil?
-          id_writer(nil)
-        else
+        if record
           raise_on_type_mismatch(record)
-          id_writer(record.id)
+          # update_counters(record)
+          replace_keys(record)
+          set_inverse_instance(record)
           @updated = true
-
-          #= (AssociationProxy === record ? record.target : record)
+        else
+          # decrement_counters
+          remove_keys
         end
-        self.target = record
 
-        loaded!
-        record
+        self.target = record
       end
 
       def reset
@@ -57,18 +27,13 @@ module ActiveFedora
       end
 
       private
-        def find_target
-          return unless id_reader
 
-          if @full_result # side-effect from #id_reader
-            ActiveFedora::SolrService.reify_solr_results([@full_result]).first
-          else
-            begin
-              ActiveFedora::Base.find(id_reader, cast: true)
-            rescue ActiveFedora::ObjectNotFoundError
-              nil
-            end
-          end
+        def replace_keys(record)
+          owner[reflection.foreign_key] = record.id
+        end
+
+        def remove_keys
+          owner[reflection.foreign_key] = nil
         end
 
         # Constructs a query that checks solr for the correct id & class_name combination
@@ -77,27 +42,19 @@ module ActiveFedora
           candidate_classes = klass.descendants.select {|d| d.name }
           candidate_classes += [klass] unless klass == ActiveFedora::Base
           model_pairs = candidate_classes.inject([]) { |arr, klass| arr << [:has_model, klass.to_class_uri]; arr }
-          '(' + ActiveFedora::SolrService.construct_query_for_pids(ids) + ') AND (' +
+          '(' + ActiveFedora::SolrService.construct_query_for_ids(ids) + ') AND (' +
               ActiveFedora::SolrService.construct_query_for_rel(model_pairs, 'OR') + ')'
         end
 
-        def remove_matching_property_relationship
-          ids = @owner.ids_for_outbound(@reflection.options[:property])
-          return if ids.empty? 
-          ids.each do |id|
-            result = SolrService.query(ActiveFedora::SolrService.construct_query_for_pids([id]))
-            hit = ActiveFedora::SolrService.reify_solr_results(result).first
-            # We remove_relationship on subjects that match the same class, or if the subject is nil 
-            if hit.class == klass || hit.nil?
-              @owner.remove_relationship(@reflection.options[:property], hit)
-            end
-          end
-        end
-
         def foreign_key_present?
           owner[reflection.foreign_key]
         end
 
+        # belongs_to is not invertible (unless we implement has_one, then make an exception here)
+        def invertible_for?(_)
+          false
+        end
+
         def stale_state
           owner[reflection.foreign_key]
         end

data/lib/active_fedora/associations/builder/association.rb

@@ -1,55 +1,91 @@
 module ActiveFedora::Associations::Builder
   class Association #:nodoc:
     class_attribute :valid_options
-    self.valid_options = [:class_name, :property]
+    self.valid_options = [:class_name, :predicate]
 
     # Set by subclasses
     class_attribute :macro
 
-    attr_reader :model, :name, :options, :reflection, :mixin
+    attr_reader :model, :name, :options, :mixin
 
+    #configure_dependency
     def self.build(model, name, options)
-      new(model, name, options).build
+      reflection = new(model, name, options).build
+      define_accessors(model, reflection)
+      define_callbacks(model, reflection)
+      reflection
     end
 
     def initialize(model, name, options)
       @model, @name, @options = model, name, options
-      @mixin = Module.new
-      @model.__send__(:include, @mixin)
+      translate_property_to_predicate
+      validate_options
     end
 
     def build
-      validate_options
-      reflection = model.create_reflection(self.class.macro, name, options, model)
-      define_accessors
-      reflection
+      configure_dependency if options[:dependent] # see https://github.com/rails/rails/commit/9da52a5e55cc665a539afb45783f84d9f3607282
+      model.create_reflection(self.class.macro, name, options, model)
+    end
+
+    def translate_property_to_predicate
+      return unless options[:property]
+      Deprecation.warn Association, "the :property option to `#{model}.#{macro} :#{name}' is deprecated and will be removed in active-fedora 10.0. Use :predicate instead", caller(5)
+      options[:predicate] = predicate(options.delete(:property))
     end
 
-    private
+    def validate_options
+      options.assert_valid_keys(self.class.valid_options)
+    end
 
-      def validate_options
-        options.assert_valid_keys(self.class.valid_options)
-      end
 
-      def define_accessors
-        define_readers
-        define_writers
+    # Returns the RDF predicate as defined by the :property attribute
+    def predicate(property)
+      return property if property.kind_of? RDF::URI
+      ActiveFedora::Predicates.find_graph_predicate(property)
+    end
+
+    def self.define_callbacks(model, reflection)
+      if dependent = reflection.options[:dependent]
+        check_dependent_options(dependent)
+        add_destroy_callbacks(model, reflection)
       end
+    end
 
-      def define_readers
-        name = self.name
+    def self.define_accessors(model, reflection)
+      mixin = model.generated_association_methods
+      name = reflection.name
+      define_readers(mixin, name)
+      define_writers(mixin, name)
+    end
 
-        mixin.send(:define_method, name) do |*params|
-          association(name).reader(*params)
-        end
+    def self.define_readers(mixin, name)
+      mixin.send(:define_method, name) do |*params|
+        association(name).reader(*params)
       end
+    end
 
-      def define_writers
-        name = self.name
+    def self.define_writers(mixin, name)
+      mixin.send(:define_method, "#{name}=") do |value|
+        association(name).writer(value)
+      end
+    end
 
-        mixin.send(:define_method, "#{name}=") do |value|
-          association(name).writer(value)
+    def configure_dependency
+      if options[:dependent]
+        unless [:destroy, :delete].include?(options[:dependent])
+          raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{options[:dependent].inspect})"
         end
+
+        method_name = "belongs_to_dependent_#{options[:dependent]}_for_#{name}"
+        model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
+          def #{method_name}
+            association = #{name}
+            association.#{options[:dependent]} if association
+          end
+        eoruby
+        model.after_destroy method_name
       end
+    end
+
   end
 end