activerecord 5.0.7.2 → 6.1.1

data/lib/active_record/associations/association_scope.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     class AssociationScope #:nodoc:
-      def self.scope(association, connection)
-        INSTANCE.scope(association, connection)
+      def self.scope(association)
+        INSTANCE.scope(association)
       end
 
       def self.create(&block)
@@ -16,20 +18,17 @@ module ActiveRecord
 
       INSTANCE = create
 
-      def scope(association, connection)
+      def scope(association)
         klass = association.klass
         reflection = association.reflection
         scope = klass.unscoped
         owner = association.owner
-        alias_tracker = AliasTracker.create connection, association.klass.table_name, klass.type_caster
-        chain_head, chain_tail = get_chain(reflection, association, alias_tracker)
+        chain = get_chain(reflection, association, scope.alias_tracker)
 
         scope.extending! reflection.extensions
-        add_constraints(scope, owner, klass, reflection, chain_head, chain_tail)
-      end
-
-      def join_type
-        Arel::Nodes::InnerJoin
+        scope = add_constraints(scope, owner, chain)
+        scope.limit!(1) unless reflection.collection?
+        scope
       end
 
       def self.get_bind_values(owner, chain)
@@ -38,129 +37,134 @@ 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
 
-      protected
+      private
+        attr_reader :value_transformation
 
-      attr_reader :value_transformation
+        def join(table, constraint)
+          Arel::Nodes::LeadingJoin.new(table, Arel::Nodes::On.new(constraint))
+        end
 
-      private
-      def join(table, constraint)
-        table.create_join(table, table.create_on(constraint), join_type)
-      end
+        def last_chain_scope(scope, reflection, owner)
+          primary_key = reflection.join_primary_key
+          foreign_key = reflection.join_foreign_key
 
-      def last_chain_scope(scope, table, reflection, owner, association_klass)
-        join_keys = reflection.join_keys(association_klass)
-        key = join_keys.key
-        foreign_key = join_keys.foreign_key
+          table = reflection.aliased_table
+          value = transform_value(owner[foreign_key])
+          scope = apply_scope(scope, table, primary_key, value)
 
-        value = transform_value(owner[foreign_key])
-        scope = scope.where(table.name => { key => value })
+          if reflection.type
+            polymorphic_type = transform_value(owner.class.polymorphic_name)
+            scope = apply_scope(scope, table, reflection.type, polymorphic_type)
+          end
 
-        if reflection.type
-          polymorphic_type = transform_value(owner.class.base_class.name)
-          scope = scope.where(table.name => { reflection.type => polymorphic_type })
+          scope
         end
 
-        scope
-      end
+        def transform_value(value)
+          value_transformation.call(value)
+        end
 
-      def transform_value(value)
-        value_transformation.call(value)
-      end
+        def next_chain_scope(scope, reflection, next_reflection)
+          primary_key = reflection.join_primary_key
+          foreign_key = reflection.join_foreign_key
 
-      def next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
-        join_keys = reflection.join_keys(association_klass)
-        key = join_keys.key
-        foreign_key = join_keys.foreign_key
+          table = reflection.aliased_table
+          foreign_table = next_reflection.aliased_table
+          constraint = table[primary_key].eq(foreign_table[foreign_key])
 
-        constraint = table[key].eq(foreign_table[foreign_key])
+          if reflection.type
+            value = transform_value(next_reflection.klass.polymorphic_name)
+            scope = apply_scope(scope, table, reflection.type, value)
+          end
 
-        if reflection.type
-          value = transform_value(next_reflection.klass.base_class.name)
-          scope = scope.where(table.name => { reflection.type => value })
+          scope.joins!(join(foreign_table, constraint))
         end
 
-        scope = scope.joins(join(foreign_table, constraint))
-      end
+        class ReflectionProxy < SimpleDelegator # :nodoc:
+          attr_reader :aliased_table
 
-      class ReflectionProxy < SimpleDelegator # :nodoc:
-        attr_accessor :next
-        attr_reader :alias_name
+          def initialize(reflection, aliased_table)
+            super(reflection)
+            @aliased_table = aliased_table
+          end
 
-        def initialize(reflection, alias_name)
-          super(reflection)
-          @alias_name = alias_name
+          def all_includes; nil; end
         end
 
-        def all_includes; nil; end
-      end
-
-      def get_chain(reflection, association, tracker)
-        name = reflection.name
-        runtime_reflection = Reflection::RuntimeReflection.new(reflection, association)
-        previous_reflection = runtime_reflection
-        reflection.chain.drop(1).each do |refl|
-          alias_name = tracker.aliased_table_for(refl.table_name, refl.alias_candidate(name))
-          proxy = ReflectionProxy.new(refl, alias_name)
-          previous_reflection.next = proxy
-          previous_reflection = proxy
+        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.klass.arel_table) do
+              refl.alias_candidate(name)
+            end
+            chain << ReflectionProxy.new(refl, aliased_table)
+          end
+          chain
         end
-        [runtime_reflection, previous_reflection]
-      end
 
-      def add_constraints(scope, owner, association_klass, refl, chain_head, chain_tail)
-        owner_reflection = chain_tail
-        table = owner_reflection.alias_name
-        scope = last_chain_scope(scope, table, owner_reflection, owner, association_klass)
+        def add_constraints(scope, owner, chain)
+          scope = last_chain_scope(scope, chain.last, owner)
 
-        reflection = chain_head
-        loop do
-          break unless reflection
-          table = reflection.alias_name
-
-          unless reflection == chain_tail
-            next_reflection = reflection.next
-            foreign_table = next_reflection.alias_name
-            scope = next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
+          chain.each_cons(2) do |reflection, next_reflection|
+            scope = next_chain_scope(scope, reflection, next_reflection)
           end
 
-          # 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.klass, scope_chain_item, owner)
+          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 == refl.scope
-              scope.merge! item.except(:where, :includes)
-            end
+              if scope_chain_item == chain_head.scope
+                scope.merge! item.except(:where, :includes, :unscope, :order)
+              elsif !item.references_values.empty?
+                scope.merge! item.only(:joins, :left_outer_joins)
 
-            reflection.all_includes do
-              scope.includes! item.includes_values
-            end
+                associations = item.eager_load_values | item.includes_values
+
+                unless associations.empty?
+                  scope.joins! item.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+                end
+              end
 
-            scope.unscope!(*item.unscope_values)
-            scope.where_clause += item.where_clause
-            scope.order_values |= item.order_values
+              reflection.all_includes do
+                scope.includes_values |= 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
 
-          reflection = reflection.next
+          scope
         end
 
-        scope
-      end
+        def apply_scope(scope, table, key, value)
+          if scope.table == table
+            scope.where!(key => value)
+          else
+            scope.where!(table.name => { key => value })
+          end
+        end
 
-      def eval_scope(klass, scope, owner)
-        klass.unscoped.instance_exec(owner, &scope)
-      end
+        def eval_scope(reflection, scope, owner)
+          relation = reflection.build_scope(reflection.aliased_table)
+          relation.instance_exec(owner, &scope) || relation
+        end
     end
   end
 end

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,25 +1,40 @@
+# 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
-
-      def replace(record)
-        if record
-          raise_on_type_mismatch!(record)
-          update_counters_on_replace(record)
-          replace_keys(record)
-          set_inverse_instance(record)
-          @updated = true
+        return unless load_target
+
+        case options[:dependent]
+        when :destroy
+          target.destroy
+          raise ActiveRecord::Rollback unless target.destroyed?
+        when :destroy_async
+          id = owner.public_send(reflection.foreign_key.to_sym)
+          primary_key_column = reflection.active_record_primary_key.to_sym
+
+          enqueue_destroy_association(
+            owner_model_name: owner.class.to_s,
+            owner_id: owner.id,
+            association_class: reflection.klass.to_s,
+            association_ids: [id],
+            association_primary_key_column: primary_key_column,
+            ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+          )
         else
-          decrement_counters
-          remove_keys
+          target.public_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,26 +46,60 @@ module ActiveRecord
         @updated
       end
 
-      def decrement_counters # :nodoc:
+      def decrement_counters
         update_counters(-1)
       end
 
-      def increment_counters # :nodoc:
+      def increment_counters
         update_counters(1)
       end
 
+      def decrement_counters_before_last_save
+        if reflection.polymorphic?
+          model_was = owner.attribute_before_last_save(reflection.foreign_type)&.constantize
+        else
+          model_was = klass
+        end
+
+        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 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, force: true)
+
+          self.target = record
+        end
 
         def update_counters(by)
           if require_counter_update? && foreign_key_present?
             if target && !stale_target?
-              target.increment!(reflection.counter_cache_column, by)
+              target.increment!(reflection.counter_cache_column, by, touch: reflection.options[:touch])
             else
-              klass.update_counters(target_id, reflection.counter_cache_column => by)
+              update_counters_via_scope(klass, owner._read_attribute(reflection.foreign_key), by)
             end
           end
         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
+
         def find_target?
           !loaded? && foreign_key_present? && klass
         end
@@ -59,44 +108,25 @@ module ActiveRecord
           reflection.counter_cache_column && owner.persisted?
         end
 
-        def update_counters_on_replace(record)
-          if require_counter_update? && different_target?(record)
-            owner.instance_variable_set :@_after_replace_counter_called, true
-            record.increment!(reflection.counter_cache_column)
-            decrement_counters
-          end
-        end
-
-        # Checks whether record is different to the current target, without loading it
-        def different_target?(record)
-          record.id != owner._read_attribute(reflection.foreign_key)
-        end
+        def replace_keys(record, force: false)
+          target_key = record ? record._read_attribute(primary_key(record.class)) : nil
 
-        def replace_keys(record)
-          owner[reflection.foreign_key] = record._read_attribute(reflection.association_primary_key(record.class))
+          if force || owner[reflection.foreign_key] != target_key
+            owner[reflection.foreign_key] = target_key
+          end
         end
 
-        def remove_keys
-          owner[reflection.foreign_key] = nil
+        def primary_key(klass)
+          reflection.association_primary_key(klass)
         end
 
         def foreign_key_present?
           owner._read_attribute(reflection.foreign_key)
         end
 
-        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
-        # has_one associations.
         def invertible_for?(record)
           inverse = inverse_reflection_for(record)
-          inverse && inverse.has_one?
-        end
-
-        def target_id
-          if options[:primary_key]
-            owner.send(reflection.name).try(:id)
-          else
-            owner._read_attribute(reflection.foreign_key)
-          end
+          inverse && (inverse.has_one? || ActiveRecord::Base.has_many_inversing)
         end
 
         def stale_state

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -1,26 +1,27 @@
+# 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
+        type.presence && owner.class.polymorphic_class_for(type)
       end
 
-      private
+      def target_changed?
+        super || owner.saved_change_to_attribute?(reflection.foreign_type)
+      end
 
-        def replace_keys(record)
+      private
+        def replace_keys(record, force: false)
           super
-          owner[reflection.foreign_type] = record.class.base_class.name
-        end
 
-        def remove_keys
-          super
-          owner[reflection.foreign_type] = nil
-        end
+          target_type = record ? record.class.polymorphic_name : nil
 
-        def different_target?(record)
-          super || record.class != klass
+          if force || owner[reflection.foreign_type] != target_type
+            owner[reflection.foreign_type] = target_type
+          end
         end
 
         def inverse_reflection_for(record)