activerecord 3.2.6 → 6.0.0

data/lib/active_record/associations/alias_tracker.rb

@@ -1,75 +1,80 @@
-require 'active_support/core_ext/string/conversions'
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/conversions"
 
 module ActiveRecord
   module Associations
-    # Keeps track of table aliases for ActiveRecord::Associations::ClassMethods::JoinDependency and
-    # ActiveRecord::Associations::ThroughAssociationScope
+    # Keeps track of table aliases for ActiveRecord::Associations::JoinDependency
     class AliasTracker # :nodoc:
-      attr_reader :aliases, :table_joins, :connection
-
-      # table_joins is an array of arel joins which might conflict with the aliases we assign here
-      def initialize(connection = ActiveRecord::Model.connection, table_joins = [])
-        @aliases     = Hash.new { |h,k| h[k] = initial_count_for(k) }
-        @table_joins = table_joins
-        @connection  = connection
+      def self.create(connection, initial_table, joins)
+        if joins.empty?
+          aliases = Hash.new(0)
+        else
+          aliases = Hash.new { |h, k|
+            h[k] = initial_count_for(connection, k, joins)
+          }
+        end
+        aliases[initial_table] = 1
+        new(connection, aliases)
       end
 
-      def aliased_table_for(table_name, aliased_name = nil)
-        table_alias = aliased_name_for(table_name, aliased_name)
+      def self.initial_count_for(connection, name, table_joins)
+        quoted_name = nil
 
-        if table_alias == table_name
-          Arel::Table.new(table_name)
-        else
-          Arel::Table.new(table_name).alias(table_alias)
+        counts = table_joins.map do |join|
+          if join.is_a?(Arel::Nodes::StringJoin)
+            # quoted_name should be case ignored as some database adapters (Oracle) return quoted name in uppercase
+            quoted_name ||= connection.quote_table_name(name)
+
+            # Table names + table aliases
+            join.left.scan(
+              /JOIN(?:\s+\w+)?\s+(?:\S+\s+)?(?:#{quoted_name}|#{name})\sON/i
+            ).size
+          elsif join.is_a?(Arel::Nodes::Join)
+            join.left.name == name ? 1 : 0
+          elsif join.is_a?(Hash)
+            join[name]
+          else
+            raise ArgumentError, "joins list should be initialized by list of Arel::Nodes::Join"
+          end
         end
+
+        counts.sum
       end
 
-      def aliased_name_for(table_name, aliased_name = nil)
-        aliased_name ||= table_name
+      # table_joins is an array of arel joins which might conflict with the aliases we assign here
+      def initialize(connection, aliases)
+        @aliases    = aliases
+        @connection = connection
+      end
 
+      def aliased_table_for(table_name, aliased_name, type_caster)
         if aliases[table_name].zero?
           # If it's zero, we can have our table_name
           aliases[table_name] = 1
-          table_name
+          Arel::Table.new(table_name, type_caster: type_caster)
         else
           # Otherwise, we need to use an alias
-          aliased_name = connection.table_alias_for(aliased_name)
+          aliased_name = @connection.table_alias_for(aliased_name)
 
           # Update the count
           aliases[aliased_name] += 1
 
-          if aliases[aliased_name] > 1
+          table_alias = if aliases[aliased_name] > 1
             "#{truncate(aliased_name)}_#{aliases[aliased_name]}"
           else
             aliased_name
           end
+          Arel::Table.new(table_name, type_caster: type_caster).alias(table_alias)
         end
       end
 
-      private
-
-        def initial_count_for(name)
-          return 0 if Arel::Table === table_joins
-
-          # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
-          quoted_name = connection.quote_table_name(name).downcase
+      attr_reader :aliases
 
-          counts = table_joins.map do |join|
-            if join.is_a?(Arel::Nodes::StringJoin)
-              # Table names + table aliases
-              join.left.downcase.scan(
-                /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
-              ).size
-            else
-              join.left.table_name == name ? 1 : 0
-            end
-          end
-
-          counts.sum
-        end
+      private
 
         def truncate(name)
-          name.slice(0, connection.table_alias_length - 2)
+          name.slice(0, @connection.table_alias_length - 2)
         end
     end
   end

data/lib/active_record/associations/association.rb

@@ -1,5 +1,6 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/object/inclusion'
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/wrap"
 
 module ActiveRecord
   module Associations
@@ -9,47 +10,56 @@ module ActiveRecord
     #
     #   Association
     #     SingularAssociation
-    #       HasOneAssociation
+    #       HasOneAssociation + ForeignAssociation
     #         HasOneThroughAssociation + ThroughAssociation
     #       BelongsToAssociation
     #         BelongsToPolymorphicAssociation
     #     CollectionAssociation
-    #       HasAndBelongsToManyAssociation
-    #       HasManyAssociation
+    #       HasManyAssociation + ForeignAssociation
     #         HasManyThroughAssociation + ThroughAssociation
+    #
+    # Associations in Active Record are middlemen between the object that
+    # holds the association, known as the <tt>owner</tt>, and the associated
+    # result set, known as the <tt>target</tt>. Association metadata is available in
+    # <tt>reflection</tt>, which is an instance of <tt>ActiveRecord::Reflection::AssociationReflection</tt>.
+    #
+    # For example, given
+    #
+    #   class Blog < ActiveRecord::Base
+    #     has_many :posts
+    #   end
+    #
+    #   blog = Blog.first
+    #
+    # The association of <tt>blog.posts</tt> has the object +blog+ as its
+    # <tt>owner</tt>, the collection of its posts as <tt>target</tt>, and
+    # the <tt>reflection</tt> object represents a <tt>:has_many</tt> macro.
     class Association #:nodoc:
       attr_reader :owner, :target, :reflection
 
-      delegate :options, :to => :reflection
+      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:
-      #
-      #   post.comments.aliased_table_name # => "comments"
-      #
-      def aliased_table_name
-        reflection.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.
-      def reload
+      # The QueryCache is cleared if +force+ is true.
+      def reload(force = false)
+        klass.connection.clear_query_cache if force && klass
         reset
         reset_scope
         load_target
@@ -63,18 +73,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+.
@@ -83,20 +94,8 @@ module ActiveRecord
         loaded!
       end
 
-      def scoped
-        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
-      # 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
+      def scope
+        target_scope.merge!(association_scope)
       end
 
       def reset_scope
@@ -105,22 +104,46 @@ module ActiveRecord
 
       # 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
+        if inverse = inverse_association_for(record)
+          inverse.inversed_from(owner)
         end
+        record
       end
 
-      # This class of the target. belongs_to polymorphic overrides this to look at the
+      def set_inverse_instance_from_queries(record)
+        if inverse = inverse_association_for(record)
+          inverse.inversed_from_queries(owner)
+        end
+        record
+      end
+
+      # Remove the inverse association, if possible
+      def remove_inverse_instance(record)
+        if inverse = inverse_association_for(record)
+          inverse.inversed_from(nil)
+        end
+      end
+
+      def inversed_from(record)
+        self.target = record
+        @inversed = !!record
+      end
+      alias :inversed_from_queries :inversed_from
+
+      # 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
       end
 
-      # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
-      # through association's scope)
-      def target_scope
-        klass.scoped
+      def extensions
+        extensions = klass.default_extensions | reflection.extensions
+
+        if reflection.scope
+          extensions |= reflection.scope_for(klass.unscoped, owner).extensions
+        end
+
+        extensions
       end
 
       # Loads the \target if needed and returns it.
@@ -134,32 +157,80 @@ module ActiveRecord
       # 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 find_target?
-          begin
-            if IdentityMap.enabled? && association_class && association_class.respond_to?(:base_class)
-              @target = IdentityMap.get(association_class, owner[reflection.foreign_key])
-            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
         reset
       end
 
-      def interpolate(sql, record = nil)
-        if sql.respond_to?(:to_proc)
-          owner.send(:instance_exec, record, &sql)
-        else
-          sql
-        end
+      # We can't dump @reflection and @through_reflection since it contains the scope proc
+      def marshal_dump
+        ivars = (instance_variables - [:@reflection, :@through_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, except_from_scope_attributes = nil) #:nodoc:
+        except_from_scope_attributes ||= {}
+        skip_assign = [reflection.foreign_key, reflection.type].compact
+        assigned_keys = record.changed_attribute_names_to_save
+        assigned_keys += except_from_scope_attributes.keys.map(&:to_s)
+        attributes = scope_for_create.except!(*(assigned_keys - skip_assign))
+        record.send(:_assign_attributes, attributes) if attributes.any?
+        set_inverse_instance(record)
+      end
+
+      def create(attributes = {}, &block)
+        _create_record(attributes, &block)
+      end
+
+      def create!(attributes = {}, &block)
+        _create_record(attributes, true, &block)
       end
 
       private
+        def find_target
+          scope = self.scope
+          return scope.to_a if skip_statement_cache?(scope)
+
+          conn = klass.connection
+          sc = reflection.association_scope_cache(conn, owner) do |params|
+            as = AssociationScope.create { params.bind }
+            target_scope.merge!(as.scope(self))
+          end
+
+          binds = AssociationScope.get_bind_values(owner, reflection.chain)
+          sc.execute(binds, conn) { |record| set_inverse_instance(record) } || []
+        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 unscoped { ... } etc, which affects the scope which
+        # actually gets built.
+        def association_scope
+          if klass
+            @association_scope ||= AssociationScope.scope(self)
+          end
+        end
+
+        # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
+        # through association's scope)
+        def target_scope
+          AssociationRelation.create(klass, self).merge!(klass.scope_for_association)
+        end
+
+        def scope_for_create
+          scope.scope_for_create
+        end
 
         def find_target?
           !loaded? && (!owner.new_record? || foreign_key_present?) && klass
@@ -168,11 +239,11 @@ 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]
-              attributes[reflection.type] = owner.class.base_class.name
+            if reflection.type
+              attributes[reflection.type] = owner.class.polymorphic_name
             end
           end
 
@@ -184,13 +255,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
@@ -198,10 +270,20 @@ 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.inspect} which is an instance of #{record.class}(##{record.class.object_id})"
+              raise ActiveRecord::AssociationTypeMismatch, message
+            end
+          end
+        end
+
+        def inverse_association_for(record)
+          if invertible_for?(record)
+            record.association(inverse_reflection_for(record).name)
           end
         end
 
@@ -212,28 +294,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.
+        # 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, attributes)
+            yield(record) if block_given?
+          end
         end
 
-        def build_record(attributes, options)
-          reflection.build_association(attributes, options) do |record|
-            attributes = create_scope.except(*(record.changed - [reflection.foreign_key]))
-            record.assign_attributes(attributes, :without_protection => true)
-          end
+        # Returns true if statement cache should be skipped on the association reader.
+        def skip_statement_cache?(scope)
+          reflection.has_scope? ||
+            scope.eager_loading? ||
+            klass.scope_attributes? ||
+            reflection.source_reflection.active_record.default_scopes.any?
         end
     end
   end