activerecord 3.2.22.5 → 4.2.11.3

data/lib/active_record/associations/association.rb

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/object/inclusion'
 
 module ActiveRecord
   module Associations
@@ -14,39 +13,37 @@ module ActiveRecord
     #       BelongsToAssociation
     #         BelongsToPolymorphicAssociation
     #     CollectionAssociation
-    #       HasAndBelongsToManyAssociation
     #       HasManyAssociation
     #         HasManyThroughAssociation + ThroughAssociation
     class Association #:nodoc:
       attr_reader :owner, :target, :reflection
+      attr_accessor :inversed
 
       delegate :options, :to => :reflection
 
       def initialize(owner, reflection)
         reflection.check_validity!
 
-        @target = nil
         @owner, @reflection = owner, reflection
-        @updated = false
 
         reset
         reset_scope
       end
 
-      # Returns the name of the table of the related class:
+      # Returns the name of the table of the associated class:
       #
       #   post.comments.aliased_table_name # => "comments"
       #
       def aliased_table_name
-        reflection.klass.table_name
+        klass.table_name
       end
 
       # Resets the \loaded flag to +false+ and sets the \target to +nil+.
       def reset
         @loaded = false
-        IdentityMap.remove(target) if IdentityMap.enabled? && target
         @target = nil
         @stale_state = nil
+        @inversed = false
       end
 
       # Reloads the \target and returns +self+ on success.
@@ -64,18 +61,19 @@ module ActiveRecord
 
       # Asserts the \target has been loaded setting the \loaded flag to +true+.
       def loaded!
-        @loaded      = true
+        @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
       # 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.
+      # stale_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
+        !inversed && loaded? && @stale_state != stale_state
       end
 
       # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
@@ -84,19 +82,19 @@ module ActiveRecord
         loaded!
       end
 
-      def scoped
+      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
-      # scoped method is called. This is because at that point the call may be surrounded
+      # 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
+          @association_scope ||= AssociationScope.scope(self, klass.connection)
         end
       end
 
@@ -106,13 +104,15 @@ module ActiveRecord
 
       # Set the inverse association, if possible
       def set_inverse_instance(record)
-        if record && invertible_for?(record)
+        if invertible_for?(record)
           inverse = record.association(inverse_reflection_for(record).name)
           inverse.target = owner
+          inverse.inversed = true
         end
+        record
       end
 
-      # This class of the target. belongs_to polymorphic overrides this to look at the
+      # Returns the class of the target. belongs_to polymorphic overrides this to look at the
       # polymorphic_type field on the owner.
       def klass
         reflection.klass
@@ -121,7 +121,7 @@ module ActiveRecord
       # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
       # through association's scope)
       def target_scope
-        klass.scoped
+        AssociationRelation.create(klass, klass.arel_table, self).merge!(klass.all)
       end
 
       # Loads the \target if needed and returns it.
@@ -129,28 +129,14 @@ module ActiveRecord
       # 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 stale(the target no longer points to the record(s) that the
-      # relevant foreign_key(s) refers to.), force reload the \target.
-      #
-      # Otherwise if the \target is already \loaded it is just returned. Thus, you can
-      # call +load_target+ unconditionally to get the \target.
+      # If the \target is already \loaded it is just returned. Thus, you can call
+      # +load_target+ unconditionally to get the \target.
       #
       # ActiveRecord::RecordNotFound is rescued within the method, and it is
       # not reraised. The proxy is \reset and +nil+ is the return value.
       def load_target
-        if (@stale_state && stale_target?) || find_target?
-          begin
-            if IdentityMap.enabled? && association_class && association_class.respond_to?(:base_class)
-              @target = IdentityMap.get(association_class, owner[reflection.foreign_key])
-            elsif @stale_state && stale_target?
-              @target = find_target
-            end
-          rescue NameError
-            nil
-          ensure
-            @target ||= find_target
-          end
-        end
+        @target = find_target if (@stale_state && stale_target?) || find_target?
+
         loaded! unless loaded?
         target
       rescue ActiveRecord::RecordNotFound
@@ -158,13 +144,32 @@ module ActiveRecord
       end
 
       def interpolate(sql, record = nil)
-        if sql.respond_to?(:to_proc) && !sql.is_a?(Hash)
-          owner.send(:instance_exec, record, &sql)
+        if sql.respond_to?(:to_proc)
+          owner.instance_exec(record, &sql)
         else
           sql
         end
       end
 
+      # We can't dump @reflection since it contains the scope proc
+      def marshal_dump
+        ivars = (instance_variables - [:@reflection]).map { |name| [name, instance_variable_get(name)] }
+        [@reflection.name, ivars]
+      end
+
+      def marshal_load(data)
+        reflection_name, ivars = data
+        ivars.each { |name, val| instance_variable_set(name, val) }
+        @reflection = @owner.class._reflect_on_association(reflection_name)
+      end
+
+      def initialize_attributes(record) #:nodoc:
+        skip_assign = [reflection.foreign_key, reflection.type].compact
+        attributes = create_scope.except(*(record.changed - skip_assign))
+        record.assign_attributes(attributes)
+        set_inverse_instance(record)
+      end
+
       private
 
         def find_target?
@@ -174,7 +179,7 @@ module ActiveRecord
         def creation_attributes
           attributes = {}
 
-          if reflection.macro.in?([:has_one, :has_many]) && !options[:through]
+          if (reflection.has_one? || reflection.collection?) && !options[:through]
             attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
 
             if reflection.options[:as]
@@ -190,13 +195,14 @@ module ActiveRecord
           creation_attributes.each { |key, value| record[key] = value }
         end
 
-        # Should be true if there is a foreign key present on the owner which
+        # 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).
+        # 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 (vanilla and polymorphic) and
-        # has_one/has_many :through associations which go through a belongs_to
+        # has_one/has_many :through associations which go through a belongs_to.
         def foreign_key_present?
           false
         end
@@ -204,10 +210,13 @@ module ActiveRecord
         # Raises ActiveRecord::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 ActiveRecord::AssociationTypeMismatch, message
+        def raise_on_type_mismatch!(record)
+          unless record.is_a?(reflection.klass)
+            fresh_class = reflection.class_name.safe_constantize
+            unless fresh_class && record.is_a?(fresh_class)
+              message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+              raise ActiveRecord::AssociationTypeMismatch, message
+            end
           end
         end
 
@@ -218,29 +227,38 @@ module ActiveRecord
           reflection.inverse_of
         end
 
-        # Is this association invertible? Can be redefined by subclasses.
+        # 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)
+          foreign_key_for?(record) && inverse_reflection_for(record)
+        end
+
+        # Returns true if record contains the foreign_key
+        def foreign_key_for?(record)
+          record.has_attribute?(reflection.foreign_key)
         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,
+        # so that when stale_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
 
-        def association_class
-          @reflection.klass
+        def build_record(attributes)
+          reflection.build_association(attributes) do |record|
+            initialize_attributes(record)
+          end
         end
 
-        def build_record(attributes, options)
-          reflection.build_association(attributes, options) do |record|
-            skip_assign = [reflection.foreign_key, reflection.type].compact
-            attributes = create_scope.except(*(record.changed - skip_assign))
-            record.assign_attributes(attributes, :without_protection => true)
-          end
+        # Returns true if statement cache should be skipped on the association reader.
+        def skip_statement_cache?
+          reflection.scope_chain.any?(&:any?) ||
+            scope.eager_loading? ||
+            klass.current_scope ||
+            klass.default_scopes.any? ||
+            reflection.source_reflection.active_record.default_scopes.any?
         end
     end
   end

data/lib/active_record/associations/association_scope.rb

@@ -1,110 +1,183 @@
 module ActiveRecord
   module Associations
     class AssociationScope #:nodoc:
-      include JoinHelper
+      def self.scope(association, connection)
+        INSTANCE.scope association, connection
+      end
 
-      attr_reader :association, :alias_tracker
+      class BindSubstitution
+        def initialize(block)
+          @block = block
+        end
 
-      delegate :klass, :owner, :reflection, :interpolate, :to => :association
-      delegate :chain, :conditions, :options, :source_options, :active_record, :to => :reflection
+        def bind_value(scope, column, value, alias_tracker)
+          substitute = alias_tracker.connection.substitute_at(column)
+          scope.bind_values += [[column, @block.call(value)]]
+          substitute
+        end
+      end
 
-      def initialize(association)
-        @association   = association
-        @alias_tracker = AliasTracker.new klass.connection
+      def self.create(&block)
+        block = block ? block : lambda { |val| val }
+        new BindSubstitution.new(block)
       end
 
-      def scope
-        scope = klass.unscoped
-        scope = scope.extending(*Array.wrap(options[:extend]))
+      def initialize(bind_substitution)
+        @bind_substitution = bind_substitution
+      end
 
-        # It's okay to just apply all these like this. The options will only be present if the
-        # association supports that option; this is enforced by the association builder.
-        scope = scope.apply_finder_options(options.slice(
-          :readonly, :include, :order, :limit, :joins, :group, :having, :offset, :select))
+      INSTANCE = create
 
-        if options[:through] && !options[:include]
-          scope = scope.includes(source_options[:include])
-        end
+      def scope(association, connection)
+        klass         = association.klass
+        reflection    = association.reflection
+        scope         = klass.unscoped
+        owner         = association.owner
+        alias_tracker = AliasTracker.empty connection
 
-        scope = scope.uniq if options[:uniq]
+        scope.extending! Array(reflection.options[:extend])
+        add_constraints(scope, owner, klass, reflection, alias_tracker)
+      end
 
-        add_constraints(scope)
+      def join_type
+        Arel::Nodes::InnerJoin
+      end
+
+      def self.get_bind_values(owner, chain)
+        binds = []
+        last_reflection = chain.last
+
+        binds << last_reflection.join_id_for(owner)
+        if last_reflection.type
+          binds << owner.class.base_class.name
+        end
+
+        chain.each_cons(2).each do |reflection, next_reflection|
+          if reflection.type
+            binds << next_reflection.klass.base_class.name
+          end
+        end
+        binds
       end
 
       private
 
-      def add_constraints(scope)
-        tables = construct_tables
+      def construct_tables(chain, klass, refl, alias_tracker)
+        chain.map do |reflection|
+          alias_tracker.aliased_table_for(
+            table_name_for(reflection, klass, refl),
+            table_alias_for(reflection, refl, reflection != refl)
+          )
+        end
+      end
 
-        chain.each_with_index do |reflection, i|
-          table, foreign_table = tables.shift, tables.first
+      def table_alias_for(reflection, refl, join = false)
+        name = "#{reflection.plural_name}_#{alias_suffix(refl)}"
+        name << "_join" if join
+        name
+      end
 
-          if reflection.source_macro == :has_and_belongs_to_many
-            join_table = tables.shift
+      def join(table, constraint)
+        table.create_join(table, table.create_on(constraint), join_type)
+      end
 
-            scope = scope.joins(join(
-              join_table,
-              table[reflection.association_primary_key].
-                eq(join_table[reflection.association_foreign_key])
-            ))
+      def column_for(table_name, column_name, alias_tracker)
+        columns = alias_tracker.connection.schema_cache.columns_hash(table_name)
+        columns[column_name]
+      end
 
-            table, foreign_table = join_table, tables.first
-          end
+      def bind_value(scope, column, value, alias_tracker)
+        @bind_substitution.bind_value scope, column, value, alias_tracker
+      end
 
-          if reflection.source_macro == :belongs_to
-            if reflection.options[:polymorphic]
-              key = reflection.association_primary_key(klass)
-            else
-              key = reflection.association_primary_key
-            end
+      def bind(scope, table_name, column_name, value, tracker)
+        column   = column_for table_name, column_name, tracker
+        bind_value scope, column, value, tracker
+      end
 
-            foreign_key = reflection.foreign_key
-          else
-            key         = reflection.foreign_key
-            foreign_key = reflection.active_record_primary_key
-          end
+      def last_chain_scope(scope, table, reflection, owner, tracker, assoc_klass)
+        join_keys = reflection.join_keys(assoc_klass)
+        key = join_keys.key
+        foreign_key = join_keys.foreign_key
 
-          conditions = self.conditions[i]
+        bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
+        scope    = scope.where(table[key].eq(bind_val))
 
-          if reflection == chain.last
-            scope = scope.where(table[key].eq(owner[foreign_key]))
+        if reflection.type
+          value    = owner.class.base_class.name
+          bind_val = bind scope, table.table_name, reflection.type, value, tracker
+          scope    = scope.where(table[reflection.type].eq(bind_val))
+        else
+          scope
+        end
+      end
 
-            if reflection.type
-              scope = scope.where(table[reflection.type].eq(owner.class.base_class.name))
-            end
+      def next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
+        join_keys = reflection.join_keys(assoc_klass)
+        key = join_keys.key
+        foreign_key = join_keys.foreign_key
 
-            conditions.each do |condition|
-              if options[:through] && condition.is_a?(Hash)
-                condition = disambiguate_condition(table, condition)
-              end
+        constraint = table[key].eq(foreign_table[foreign_key])
 
-              scope = scope.where(interpolate(condition))
-            end
-          else
-            constraint = table[key].eq(foreign_table[foreign_key])
+        if reflection.type
+          value    = next_reflection.klass.base_class.name
+          bind_val = bind scope, table.table_name, reflection.type, value, tracker
+          scope    = scope.where(table[reflection.type].eq(bind_val))
+        end
 
-            if reflection.type
-              type = chain[i + 1].klass.base_class.name
-              constraint = constraint.and(table[reflection.type].eq(type))
-            end
+        scope = scope.joins(join(foreign_table, constraint))
+      end
+
+      def add_constraints(scope, owner, assoc_klass, refl, tracker)
+        chain = refl.chain
+        scope_chain = refl.scope_chain
+
+        tables = construct_tables(chain, assoc_klass, refl, tracker)
+
+        owner_reflection = chain.last
+        table = tables.last
+        scope = last_chain_scope(scope, table, owner_reflection, owner, tracker, assoc_klass)
 
-            scope = scope.joins(join(foreign_table, constraint))
+        chain.each_with_index do |reflection, i|
+          table, foreign_table = tables.shift, tables.first
+
+          unless reflection == chain.last
+            next_reflection = chain[i + 1]
+            scope = next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
+          end
+
+          is_first_chain = i == 0
+          klass = is_first_chain ? assoc_klass : reflection.klass
+
+          # Exclude the scope of the association itself, because that
+          # was already merged in the #scope method.
+          scope_chain[i].each do |scope_chain_item|
+            item  = eval_scope(klass, scope_chain_item, owner)
 
-            unless conditions.empty?
-              scope = scope.where(sanitize(conditions, table))
+            if scope_chain_item == refl.scope
+              scope.merge! item.except(:where, :includes, :bind)
             end
+
+            if is_first_chain
+              scope.includes! item.includes_values
+            end
+
+            scope.unscope!(*item.unscope_values)
+            scope.where_values += item.where_values
+            scope.bind_values  += item.bind_values
+            scope.order_values |= item.order_values
           end
         end
 
         scope
       end
 
-      def alias_suffix
-        reflection.name
+      def alias_suffix(refl)
+        refl.name
       end
 
-      def table_name_for(reflection)
-        if reflection == self.reflection
+      def table_name_for(reflection, klass, refl)
+        if reflection == refl
           # If this is a polymorphic belongs_to, we want to get the klass from the
           # association because it depends on the polymorphic_type attribute of
           # the owner
@@ -114,20 +187,8 @@ module ActiveRecord
         end
       end
 
-      def disambiguate_condition(table, condition)
-        if condition.is_a?(Hash)
-          Hash[
-            condition.map do |k, v|
-              if v.is_a?(Hash)
-                [k, v]
-              else
-                [table.table_alias || table.name, { k => v }]
-              end
-            end
-          ]
-        else
-          condition
-        end
+      def eval_scope(klass, scope, owner)
+        klass.unscoped.instance_exec(owner, &scope)
       end
     end
   end