activerecord 4.2.0 → 6.0.5.1

data/lib/active_record/associations/association_scope.rb

@@ -1,46 +1,34 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class AssociationScope #:nodoc:
-      def self.scope(association, connection)
-        INSTANCE.scope association, connection
-      end
-
-      class BindSubstitution
-        def initialize(block)
-          @block = block
-        end
-
-        def bind_value(scope, column, value, alias_tracker)
-          substitute = alias_tracker.connection.substitute_at(column)
-          scope.bind_values += [[column, @block.call(value)]]
-          substitute
-        end
+      def self.scope(association)
+        INSTANCE.scope(association)
       end
 
       def self.create(&block)
-        block = block ? block : lambda { |val| val }
-        new BindSubstitution.new(block)
+        block ||= lambda { |val| val }
+        new(block)
       end
 
-      def initialize(bind_substitution)
-        @bind_substitution = bind_substitution
+      def initialize(value_transformation)
+        @value_transformation = value_transformation
       end
 
       INSTANCE = create
 
-      def scope(association, connection)
-        klass         = association.klass
-        reflection    = association.reflection
-        scope         = klass.unscoped
-        owner         = association.owner
-        alias_tracker = AliasTracker.empty connection
+      def scope(association)
+        klass = association.klass
+        reflection = association.reflection
+        scope = klass.unscoped
+        owner = association.owner
+        chain = get_chain(reflection, association, scope.alias_tracker)
 
-        scope.extending! Array(reflection.options[:extend])
-        add_constraints(scope, owner, klass, reflection, alias_tracker)
-      end
-
-      def join_type
-        Arel::Nodes::InnerJoin
+        scope.extending! reflection.extensions
+        scope = add_constraints(scope, owner, chain)
+        scope.limit!(1) unless reflection.collection?
+        scope
       end
 
       def self.get_bind_values(owner, chain)
@@ -49,146 +37,136 @@ module ActiveRecord
 
         binds << last_reflection.join_id_for(owner)
         if last_reflection.type
-          binds << owner.class.base_class.name
+          binds << owner.class.polymorphic_name
         end
 
         chain.each_cons(2).each do |reflection, next_reflection|
           if reflection.type
-            binds << next_reflection.klass.base_class.name
+            binds << next_reflection.klass.polymorphic_name
           end
         end
         binds
       end
 
       private
+        attr_reader :value_transformation
 
-      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)
-          )
+        def join(table, constraint)
+          table.create_join(table, table.create_on(constraint), Arel::Nodes::LeadingJoin)
         end
-      end
-
-      def table_alias_for(reflection, refl, join = false)
-        name = "#{reflection.plural_name}_#{alias_suffix(refl)}"
-        name << "_join" if join
-        name
-      end
-
-      def join(table, constraint)
-        table.create_join(table, table.create_on(constraint), join_type)
-      end
 
-      def column_for(table_name, column_name, alias_tracker)
-        columns = alias_tracker.connection.schema_cache.columns_hash(table_name)
-        columns[column_name]
-      end
+        def last_chain_scope(scope, reflection, owner)
+          join_keys = reflection.join_keys
+          key = join_keys.key
+          foreign_key = join_keys.foreign_key
 
-      def bind_value(scope, column, value, alias_tracker)
-        @bind_substitution.bind_value scope, column, value, alias_tracker
-      end
+          table = reflection.aliased_table
+          value = transform_value(owner[foreign_key])
+          scope = apply_scope(scope, table, key, value)
 
-      def bind(scope, table_name, column_name, value, tracker)
-        column   = column_for table_name, column_name, tracker
-        bind_value scope, column, value, tracker
-      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
-
-        bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
-        scope    = scope.where(table[key].eq(bind_val))
+          if reflection.type
+            polymorphic_type = transform_value(owner.class.polymorphic_name)
+            scope = apply_scope(scope, table, reflection.type, polymorphic_type)
+          end
 
-        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
 
-      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
+        def transform_value(value)
+          value_transformation.call(value)
+        end
 
-        constraint = table[key].eq(foreign_table[foreign_key])
+        def next_chain_scope(scope, reflection, next_reflection)
+          join_keys = reflection.join_keys
+          key = join_keys.key
+          foreign_key = join_keys.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
+          table = reflection.aliased_table
+          foreign_table = next_reflection.aliased_table
+          constraint = table[key].eq(foreign_table[foreign_key])
 
-        scope = scope.joins(join(foreign_table, constraint))
-      end
+          if reflection.type
+            value = transform_value(next_reflection.klass.polymorphic_name)
+            scope = apply_scope(scope, table, reflection.type, value)
+          end
 
-      def add_constraints(scope, owner, assoc_klass, refl, tracker)
-        chain = refl.chain
-        scope_chain = refl.scope_chain
+          scope.joins!(join(foreign_table, constraint))
+        end
 
-        tables = construct_tables(chain, assoc_klass, refl, tracker)
+        class ReflectionProxy < SimpleDelegator # :nodoc:
+          attr_reader :aliased_table
 
-        owner_reflection = chain.last
-        table = tables.last
-        scope = last_chain_scope(scope, table, owner_reflection, owner, tracker, assoc_klass)
+          def initialize(reflection, aliased_table)
+            super(reflection)
+            @aliased_table = aliased_table
+          end
 
-        chain.each_with_index do |reflection, i|
-          table, foreign_table = tables.shift, tables.first
+          def all_includes; nil; end
+        end
 
-          unless reflection == chain.last
-            next_reflection = chain[i + 1]
-            scope = next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
+        def get_chain(reflection, association, tracker)
+          name = reflection.name
+          chain = [Reflection::RuntimeReflection.new(reflection, association)]
+          reflection.chain.drop(1).each do |refl|
+            aliased_table = tracker.aliased_table_for(
+              refl.table_name,
+              refl.alias_candidate(name),
+              refl.klass.type_caster
+            )
+            chain << ReflectionProxy.new(refl, aliased_table)
           end
+          chain
+        end
 
-          is_first_chain = i == 0
-          klass = is_first_chain ? assoc_klass : reflection.klass
+        def add_constraints(scope, owner, chain)
+          scope = last_chain_scope(scope, chain.last, owner)
 
-          # 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)
+          chain.each_cons(2) do |reflection, next_reflection|
+            scope = next_chain_scope(scope, reflection, next_reflection)
+          end
 
-            if scope_chain_item == refl.scope
-              scope.merge! item.except(:where, :includes, :bind)
+          chain_head = chain.first
+          chain.reverse_each do |reflection|
+            # Exclude the scope of the association itself, because that
+            # was already merged in the #scope method.
+            reflection.constraints.each do |scope_chain_item|
+              item = eval_scope(reflection, scope_chain_item, owner)
+
+              if scope_chain_item == chain_head.scope
+                scope.merge! item.except(:where, :includes, :unscope, :order)
+              elsif !item.references_values.empty?
+                join_dependency = item.construct_join_dependency(
+                  item.eager_load_values | item.includes_values, Arel::Nodes::OuterJoin
+                )
+                scope.joins!(*item.joins_values, join_dependency)
+                scope.left_outer_joins!(*item.left_outer_joins_values)
+              end
+
+              reflection.all_includes do
+                scope.includes! item.includes_values
+              end
+
+              scope.unscope!(*item.unscope_values)
+              scope.where_clause += item.where_clause
+              scope.order_values = item.order_values | scope.order_values
             end
+          end
 
-            if is_first_chain
-              scope.includes! item.includes_values
-            end
+          scope
+        end
 
-            scope.where_values += item.where_values
-            scope.bind_values  += item.bind_values
-            scope.order_values |= item.order_values
+        def apply_scope(scope, table, key, value)
+          if scope.table == table
+            scope.where!(key => value)
+          else
+            scope.where!(table.name => { key => value })
           end
         end
 
-        scope
-      end
-
-      def alias_suffix(refl)
-        refl.name
-      end
-
-      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
-          klass.table_name
-        else
-          reflection.table_name
+        def eval_scope(reflection, scope, owner)
+          relation = reflection.build_scope(reflection.aliased_table)
+          relation.instance_exec(owner, &scope) || relation
         end
-      end
-
-      def eval_scope(klass, scope, owner)
-        klass.unscoped.instance_exec(owner, &scope)
-      end
     end
   end
 end

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,25 +1,28 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Belongs To Association
   module Associations
+    # = Active Record Belongs To Association
     class BelongsToAssociation < SingularAssociation #:nodoc:
-
       def handle_dependency
-        target.send(options[:dependent]) if load_target
-      end
+        return unless load_target
 
-      def replace(record)
-        if record
-          raise_on_type_mismatch!(record)
-          update_counters(record)
-          replace_keys(record)
-          set_inverse_instance(record)
-          @updated = true
+        case options[:dependent]
+        when :destroy
+          target.destroy
+          raise ActiveRecord::Rollback unless target.destroyed?
         else
-          decrement_counters
-          remove_keys
+          target.send(options[:dependent])
         end
+      end
+
+      def inversed_from(record)
+        replace_keys(record)
+        super
+      end
 
-        self.target = record
+      def default(&block)
+        writer(owner.instance_exec(&block)) if reader.nil?
       end
 
       def reset
@@ -31,61 +34,78 @@ module ActiveRecord
         @updated
       end
 
-      def decrement_counters # :nodoc:
-        with_cache_name { |name| decrement_counter name }
+      def decrement_counters
+        update_counters(-1)
       end
 
-      def increment_counters # :nodoc:
-        with_cache_name { |name| increment_counter name }
+      def increment_counters
+        update_counters(1)
       end
 
-      private
-
-        def find_target?
-          !loaded? && foreign_key_present? && klass
+      def decrement_counters_before_last_save
+        if reflection.polymorphic?
+          model_was = owner.attribute_before_last_save(reflection.foreign_type).try(:constantize)
+        else
+          model_was = klass
         end
 
-        def with_cache_name
-          counter_cache_name = reflection.counter_cache_column
-          return unless counter_cache_name && owner.persisted?
-          yield counter_cache_name
+        foreign_key_was = owner.attribute_before_last_save(reflection.foreign_key)
+
+        if foreign_key_was && model_was < ActiveRecord::Base
+          update_counters_via_scope(model_was, foreign_key_was, -1)
         end
+      end
 
-        def update_counters(record)
-          with_cache_name do |name|
-            return unless different_target? record
-            record.class.increment_counter(name, record.id)
-            decrement_counter name
+      def target_changed?
+        owner.saved_change_to_attribute?(reflection.foreign_key)
+      end
+
+      private
+        def replace(record)
+          if record
+            raise_on_type_mismatch!(record)
+            set_inverse_instance(record)
+            @updated = true
           end
+
+          replace_keys(record)
+
+          self.target = record
         end
 
-        def decrement_counter(counter_cache_name)
-          if foreign_key_present?
-            klass.decrement_counter(counter_cache_name, target_id)
+        def update_counters(by)
+          if require_counter_update? && foreign_key_present?
+            if target && !stale_target?
+              target.increment!(reflection.counter_cache_column, by, touch: reflection.options[:touch])
+            else
+              update_counters_via_scope(klass, owner._read_attribute(reflection.foreign_key), by)
+            end
           end
         end
 
-        def increment_counter(counter_cache_name)
-          if foreign_key_present?
-            klass.increment_counter(counter_cache_name, target_id)
-          end
+        def update_counters_via_scope(klass, foreign_key, by)
+          scope = klass.unscoped.where!(primary_key(klass) => foreign_key)
+          scope.update_counters(reflection.counter_cache_column => by, touch: reflection.options[:touch])
         end
 
-        # Checks whether record is different to the current target, without loading it
-        def different_target?(record)
-          record.id != owner[reflection.foreign_key]
+        def find_target?
+          !loaded? && foreign_key_present? && klass
+        end
+
+        def require_counter_update?
+          reflection.counter_cache_column && owner.persisted?
         end
 
         def replace_keys(record)
-          owner[reflection.foreign_key] = record[reflection.association_primary_key(record.class)]
+          owner[reflection.foreign_key] = record ? record._read_attribute(primary_key(record.class)) : nil
         end
 
-        def remove_keys
-          owner[reflection.foreign_key] = nil
+        def primary_key(klass)
+          reflection.association_primary_key(klass)
         end
 
         def foreign_key_present?
-          owner[reflection.foreign_key]
+          owner._read_attribute(reflection.foreign_key)
         end
 
         # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
@@ -95,16 +115,9 @@ module ActiveRecord
           inverse && inverse.has_one?
         end
 
-        def target_id
-          if options[:primary_key]
-            owner.send(reflection.name).try(:id)
-          else
-            owner[reflection.foreign_key]
-          end
-        end
-
         def stale_state
-          owner[reflection.foreign_key] && owner[reflection.foreign_key].to_s
+          result = owner._read_attribute(reflection.foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
+          result && result.to_s
         end
     end
   end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -1,26 +1,22 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Belongs To Polymorphic Association
   module Associations
+    # = Active Record Belongs To Polymorphic Association
     class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
       def klass
         type = owner[reflection.foreign_type]
         type.presence && type.constantize
       end
 
-      private
+      def target_changed?
+        super || owner.saved_change_to_attribute?(reflection.foreign_type)
+      end
 
+      private
         def replace_keys(record)
           super
-          owner[reflection.foreign_type] = record.class.base_class.name
-        end
-
-        def remove_keys
-          super
-          owner[reflection.foreign_type] = nil
-        end
-
-        def different_target?(record)
-          super || record.class != klass
+          owner[reflection.foreign_type] = record ? record.class.polymorphic_name : nil
         end
 
         def inverse_reflection_for(record)

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

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/module/attribute_accessors'
+# frozen_string_literal: true
 
 # This is the parent Association class which defines the variables
 # used by all associations.
@@ -11,19 +11,14 @@ require 'active_support/core_ext/module/attribute_accessors'
 #    - CollectionAssociation
 #      - HasManyAssociation
 
-module ActiveRecord::Associations::Builder
+module ActiveRecord::Associations::Builder # :nodoc:
   class Association #:nodoc:
     class << self
       attr_accessor :extensions
-      # TODO: This class accessor is needed to make activerecord-deprecated_finders work.
-      # We can move it to a constant in 5.0.
-      attr_accessor :valid_options
     end
     self.extensions = []
 
-    self.valid_options = [:class_name, :class, :foreign_key, :validate]
-
-    attr_reader :name, :scope, :options
+    VALID_OPTIONS = [:class_name, :anonymous_class, :foreign_key, :validate] # :nodoc:
 
     def self.build(model, name, scope, options, &block)
       if model.dangerous_attribute_method?(name)
@@ -32,57 +27,47 @@ module ActiveRecord::Associations::Builder
                              "Please choose a different association name."
       end
 
-      builder = create_builder model, name, scope, options, &block
-      reflection = builder.build(model)
+      reflection = create_reflection(model, name, scope, options, &block)
       define_accessors model, reflection
       define_callbacks model, reflection
       define_validations model, reflection
-      builder.define_extensions model
       reflection
     end
 
-    def self.create_builder(model, name, scope, options, &block)
+    def self.create_reflection(model, name, scope, options, &block)
       raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
 
-      new(model, name, scope, options, &block)
-    end
+      validate_options(options)
 
-    def initialize(model, name, scope, options)
-      # TODO: Move this to create_builder as soon we drop support to activerecord-deprecated_finders.
-      if scope.is_a?(Hash)
-        options = scope
-        scope   = nil
-      end
+      extension = define_extensions(model, name, &block)
+      options[:extend] = [*options[:extend], extension] if extension
 
-      # TODO: Remove this model argument as soon we drop support to activerecord-deprecated_finders.
-      @name    = name
-      @scope   = scope
-      @options = options
+      scope = build_scope(scope)
 
-      validate_options
+      ActiveRecord::Reflection.create(macro, name, scope, options, model)
+    end
 
+    def self.build_scope(scope)
       if scope && scope.arity == 0
-        @scope = proc { instance_exec(&scope) }
+        proc { instance_exec(&scope) }
+      else
+        scope
       end
     end
 
-    def build(model)
-      ActiveRecord::Reflection.create(macro, name, scope, options, model)
-    end
-
-    def macro
+    def self.macro
       raise NotImplementedError
     end
 
-    def valid_options
-      Association.valid_options + Association.extensions.flat_map(&:valid_options)
+    def self.valid_options(options)
+      VALID_OPTIONS + Association.extensions.flat_map(&:valid_options)
     end
 
-    def validate_options
-      options.assert_valid_keys(valid_options)
+    def self.validate_options(options)
+      options.assert_valid_keys(valid_options(options))
     end
 
-    def define_extensions(model)
+    def self.define_extensions(model, name)
     end
 
     def self.define_callbacks(model, reflection)
@@ -111,8 +96,8 @@ module ActiveRecord::Associations::Builder
 
     def self.define_readers(mixin, name)
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{name}(*args)
-          association(:#{name}).reader(*args)
+        def #{name}
+          association(:#{name}).reader
         end
       CODE
     end
@@ -133,8 +118,6 @@ module ActiveRecord::Associations::Builder
       raise NotImplementedError
     end
 
-    private
-
     def self.check_dependent_options(dependent)
       unless valid_dependent_options.include? dependent
         raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{dependent}"
@@ -145,5 +128,9 @@ module ActiveRecord::Associations::Builder
       name = reflection.name
       model.before_destroy lambda { |o| o.association(name).handle_dependency }
     end
+
+    private_class_method :build_scope, :macro, :valid_options, :validate_options, :define_extensions,
+      :define_callbacks, :define_accessors, :define_readers, :define_writers, :define_validations,
+      :valid_dependent_options, :check_dependent_options, :add_destroy_callbacks
   end
 end