active-fedora 6.8.0 → 7.0.0.pre1

data/lib/active_fedora/associations/association.rb

@@ -0,0 +1,163 @@
+module ActiveFedora
+  module Associations
+    # This is the root class of all associations:
+    #
+    #   Association
+    #     BelongsToAssociation
+    #     AssociationCollection
+    #       HasManyAssociation
+    #
+    #
+    class Association
+      attr_reader :owner, :target, :reflection
+      delegate :options, :klass, to: :reflection
+
+      def initialize(owner, reflection)
+        #reflection.check_validity!
+        @owner, @reflection = owner, reflection
+        @updated = false
+        reset
+        # construct_scope
+      end
+
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        @loaded = false
+        @target = nil
+      end
+
+      # Reloads the \target and returns +self+ on success.
+      def reload
+        reset
+        # construct_scope
+        load_target
+        self unless @target.nil?
+      end
+
+      # Has the \target been already \loaded?
+      def loaded?
+        @loaded
+      end
+
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      def loaded!
+        @loaded = true
+        @stale_state = stale_state
+      end
+
+      # The target is stale if the target no longer points to the record(s) that the
+      # relevant foreign_key(s) refers to. If stale, the association accessor method
+      # on the owner will reload the target. It's up to subclasses to implement the
+      # state_state method if relevant.
+      #
+      # Note that if the target has not been loaded, it is not considered stale.
+      def stale_target?
+        loaded? && @stale_state != stale_state
+      end
+
+      # Sets the target of this proxy to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = target
+        loaded!
+      end
+
+      def scope
+        target_scope.merge(association_scope)
+      end
+
+      # The scope for this association.
+      #
+      # Note that the association_scope is merged into the target_scope only when the
+      # scope method is called. This is because at that point the call may be surrounded
+      # by scope.scoping { ... } or with_scope { ... } etc, which affects the scope which
+      # actually gets built.
+      def association_scope
+        if klass
+          @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
+        end
+      end
+
+      
+      # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
+      # through association's scope)
+      def target_scope
+        klass.all
+      end
+
+      # Loads the \target if needed and returns it.
+      #
+      # This method is abstract in the sense that it relies on +find_target+,
+      # which is expected to be provided by descendants.
+      #
+      # If the \target is already \loaded it is just returned. Thus, you can call
+      # +load_target+ unconditionally to get the \target.
+      #
+      # ActiveFedora::ObjectNotFoundError is rescued within the method, and it is
+      # not reraised. The proxy is \reset and +nil+ is the return value.
+      def load_target
+        @target = find_target if (@stale_state && stale_target?) || find_target?
+        loaded! unless loaded?
+        target
+      end
+
+        private
+
+        
+        def find_target?
+          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
+        end
+
+        # Returns true if there is a foreign key present on the owner which
+        # references the target. This is used to determine whether we can load
+        # the target if the owner is currently a new record (and therefore
+        # without a key). If the owner is a new record then foreign_key must
+        # be present in order to load target.
+        #
+        # Currently implemented by belongs_to
+        def foreign_key_present?
+          false
+        end
+
+        # Raises ActiveFedora::AssociationTypeMismatch unless +record+ is of
+        # the kind of the class of the associated objects. Meant to be used as
+        # a sanity check when you are about to assign an associated record.
+        def raise_on_type_mismatch(record)
+          unless record.is_a?(@reflection.klass) || record.is_a?(@reflection.class_name.constantize)
+            message = "#{@reflection.class_name}(##{@reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+            raise ActiveFedora::AssociationTypeMismatch, message
+          end
+        end
+
+        # Can be redefined by subclasses, notably polymorphic belongs_to
+        # The record parameter is necessary to support polymorphic inverses as we must check for
+        # the association in the specific class of the record.
+        def inverse_reflection_for(record)
+          reflection.inverse_of
+        end
+
+        # Returns true if inverse association on the given record needs to be set.
+        # This method is redefined by subclasses.
+        def invertible_for?(record)
+          inverse_reflection_for(record)
+        end
+
+
+        # This should be implemented to return the values of the relevant key(s) on the owner,
+        # so that when state_state is different from the value stored on the last find_target,
+        # the target is stale.
+        #
+        # This is only relevant to certain associations, which is why it returns nil by default.
+        def stale_state
+        end
+
+    end
+  end
+end

data/lib/active_fedora/associations/association_scope.rb

@@ -0,0 +1,39 @@
+module ActiveFedora
+  module Associations
+    class AssociationScope #:nodoc:
+
+      attr_reader :association
+      
+      delegate :klass, :owner, :reflection, :interpolate, :to => :association
+      delegate :chain, :scope_chain, :options, :source_options, :active_record, :to => :reflection
+
+      def initialize(association)
+        @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
+          elsif reflection.source_macro == :has_and_belongs_to_many
+          else
+            scope = scope.where( association.send(:find_predicate) => owner.internal_uri)
+          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

@@ -1,70 +1,92 @@
 module ActiveFedora
   module Associations
-    class BelongsToAssociation < AssociationProxy #:nodoc:
+    class BelongsToAssociation < SingularAssociation #:nodoc:
 
-      def create(attributes = {})
-        replace(@reflection.create_association(attributes))
+      def id_writer(id)
+        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 build(attributes = {})
-        replace(@reflection.build_association(attributes))
+      def id_reader
+        # 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
+        results = SolrService.query(ActiveFedora::SolrService.construct_query_for_pids(ids))
+        results.each do |result|
+          return result['id'] if SolrService.class_from_solr_document(result) == klass
+        end
+        return nil
       end
 
       def replace(record)
         if record.nil?
-          remove_matching_property_relationship
+          id_writer(nil)
         else
           raise_on_type_mismatch(record)
-
-          remove_matching_property_relationship
-
-          @target = (AssociationProxy === record ? record.target : record)
-          @owner.add_relationship(@reflection.options[:property], record) unless record.new_record?
+          id_writer(record.id)
           @updated = true
+
+          #= (AssociationProxy === record ? record.target : record)
         end
+        self.target = record
 
-        loaded
+        loaded!
         record
       end
 
+      def reset
+        super
+        @updated = false
+      end
+
+      def updated?
+        @updated
+      end
+
       private
         def find_target
-          pid = @owner.ids_for_outbound(@reflection.options[:property])
-          return if pid.empty?          
-          class_name = @reflection.options[:class_name] ? @reflection.options[:class_name] : @reflection.class_name
-          query = construct_query(pid, class_name)    
-          solr_result = SolrService.query(query) 
+          pid = id_reader
+          return unless pid
+          solr_result = SolrService.query(construct_query(pid)) 
           return ActiveFedora::SolrService.reify_solr_results(solr_result).first
         end
 
-        def construct_query pid, class_name
-          if class_name && class_name != "ActiveFedora::Base"
+        def construct_query pid
+          if klass != ActiveFedora::Base
             clauses = {}  
-            clauses[:has_model] = class_name.constantize.to_class_uri
-            query = ActiveFedora::SolrService.construct_query_for_rel(clauses) + " AND (" + ActiveFedora::SolrService.construct_query_for_pids(pid) + ")"
+            clauses[:has_model] = klass.to_class_uri
+            query = ActiveFedora::SolrService.construct_query_for_rel(clauses) + " AND (" + ActiveFedora::SolrService.construct_query_for_pids([pid]) + ")"
           else
             query = ActiveFedora::SolrService.construct_query_for_pids(pid)
           end
         end
 
         def remove_matching_property_relationship
-          class_name = @reflection.options[:class_name] ? @reflection.options[:class_name] : @reflection.class_name
           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.to_s == class_name || hit.nil?
+            if hit.class == klass || hit.nil?
               @owner.remove_relationship(@reflection.options[:property], hit)
             end
           end
         end
 
-        def foreign_key_present
-          !@owner.send(@reflection.primary_key_name).nil?
+        def foreign_key_present?
+          owner[reflection.foreign_key]
         end
 
+        def stale_state
+          owner[reflection.foreign_key]
+        end
     end
   end
 end

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

@@ -0,0 +1,55 @@
+module ActiveFedora::Associations::Builder
+  class Association #:nodoc:
+    class_attribute :valid_options
+    self.valid_options = [:class_name, :property]
+
+    # Set by subclasses
+    class_attribute :macro
+
+    attr_reader :model, :name, :options, :reflection, :mixin
+
+    def self.build(model, name, options)
+      new(model, name, options).build
+    end
+
+    def initialize(model, name, options)
+      @model, @name, @options = model, name, options
+      @mixin = Module.new
+      @model.__send__(:include, @mixin)
+    end
+
+    def build
+      validate_options
+      reflection = model.create_reflection(self.class.macro, name, options, model)
+      define_accessors
+      reflection
+    end
+
+    private
+
+      def validate_options
+        options.assert_valid_keys(self.class.valid_options)
+      end
+
+      def define_accessors
+        define_readers
+        define_writers
+      end
+
+      def define_readers
+        name = self.name
+
+        mixin.send(:define_method, name) do |*params|
+          association(name).reader(*params)
+        end
+      end
+
+      def define_writers
+        name = self.name
+
+        mixin.send(:define_method, "#{name}=") do |value|
+          association(name).writer(value)
+        end
+      end
+  end
+end

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

@@ -0,0 +1,100 @@
+module ActiveFedora::Associations::Builder
+  class BelongsTo < SingularAssociation #:nodoc:
+    self.macro = :belongs_to
+
+    self.valid_options += [:touch]
+
+
+    def build
+      reflection = super
+      add_counter_cache_callbacks(reflection) if options[:counter_cache]
+      add_touch_callbacks(reflection)         if options[:touch]
+      configure_dependency
+      reflection
+    end
+
+    private
+
+      def add_counter_cache_callbacks(reflection)
+        cache_column = reflection.counter_cache_column
+        name         = self.name
+
+        method_name = "belongs_to_counter_cache_after_create_for_#{name}"
+        mixin.redefine_method(method_name) do
+          record = send(name)
+          record.class.increment_counter(cache_column, record.id) unless record.nil?
+        end
+        model.after_create(method_name)
+
+        method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
+        mixin.redefine_method(method_name) do
+          record = send(name)
+          record.class.decrement_counter(cache_column, record.id) unless record.nil?
+        end
+        model.before_destroy(method_name)
+
+        model.send(:module_eval,
+          "#{reflection.class_name}.send(:attr_readonly,\"#{cache_column}\".intern) if defined?(#{reflection.class_name}) && #{reflection.class_name}.respond_to?(:attr_readonly)", __FILE__, __LINE__
+        )
+      end
+
+      def add_touch_callbacks(reflection)
+        name        = self.name
+        method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
+        touch       = options[:touch]
+
+        mixin.redefine_method(method_name) do
+          record = send(name)
+
+          unless record.nil?
+            if touch == true
+              record.touch
+            else
+              record.touch(touch)
+            end
+          end
+        end
+
+        model.after_save(method_name)
+        model.after_touch(method_name)
+        model.after_destroy(method_name)
+      end
+
+      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
+
+      def define_readers
+        super
+        name = self.name
+        accessor_name = "#{name}_id"
+        model.find_or_create_defined_attribute(accessor_name, 'RELS-EXT', {})
+        mixin.redefine_method(accessor_name) do
+          association(name).id_reader
+        end
+      end
+
+      def define_writers
+        super
+        name = self.name
+        writer_name = "#{name}_id"
+        model.find_or_create_defined_attribute(writer_name, 'RELS-EXT', {})
+        mixin.redefine_method("#{writer_name}=") do |id|
+          association(name).id_writer(id)
+        end
+      end
+  end
+end