activerecord 6.1.4.6 → 7.0.2.3

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2020 David Heinemeier Hansson
+Copyright (c) 2004-2022 David Heinemeier Hansson
 
 Arel originally copyright (c) 2007-2016 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
 

data/README.rdoc

@@ -140,7 +140,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
 
 * Database agnostic schema management with Migrations.
 
-    class AddSystemSettings < ActiveRecord::Migration[6.0]
+    class AddSystemSettings < ActiveRecord::Migration[7.0]
       def up
         create_table :system_settings do |t|
           t.string  :name

data/lib/active_record/aggregations.rb

@@ -264,7 +264,7 @@ module ActiveRecord
               end
 
               hash_from_multiparameter_assignment = part.is_a?(Hash) &&
-                part.each_key.all? { |k| k.is_a?(Integer) }
+                part.keys.all?(Integer)
               if hash_from_multiparameter_assignment
                 raise ArgumentError unless part.size == part.each_key.max
                 part = klass.new(*part.sort.map(&:last))

data/lib/active_record/association_relation.rb

@@ -27,16 +27,6 @@ module ActiveRecord
       RUBY
     end
 
-    def build(attributes = nil, &block)
-      if attributes.is_a?(Array)
-        attributes.collect { |attr| build(attr, &block) }
-      else
-        block = current_scope_restoring_block(&block)
-        scoping { _new(attributes, &block) }
-      end
-    end
-    alias new build
-
     private
       def _new(attributes, &block)
         @association.build(attributes, &block)

data/lib/active_record/associations/association.rb

@@ -32,8 +32,8 @@ module ActiveRecord
     # 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
+    class Association # :nodoc:
+      attr_reader :owner, :target, :reflection, :disable_joins
 
       delegate :options, to: :reflection
 
@@ -41,6 +41,7 @@ module ActiveRecord
         reflection.check_validity!
 
         @owner, @reflection = owner, reflection
+        @disable_joins = @reflection.options[:disable_joins] || false
 
         reset
         reset_scope
@@ -51,7 +52,6 @@ module ActiveRecord
         @loaded = false
         @target = nil
         @stale_state = nil
-        @inversed = false
       end
 
       def reset_negative_cache # :nodoc:
@@ -77,7 +77,6 @@ module ActiveRecord
       def loaded!
         @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
@@ -87,7 +86,7 @@ module ActiveRecord
       #
       # Note that if the target has not been loaded, it is not considered stale.
       def stale_target?
-        !@inversed && loaded? && @stale_state != stale_state
+        loaded? && @stale_state != stale_state
       end
 
       # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
@@ -97,8 +96,12 @@ module ActiveRecord
       end
 
       def scope
-        if (scope = klass.current_scope) && scope.try(:proxy_association) == self
+        if disable_joins
+          DisableJoinsAssociationScope.create.scope(self)
+        elsif (scope = klass.current_scope) && scope.try(:proxy_association) == self
           scope.spawn
+        elsif scope = klass.global_current_scope
+          target_scope.merge!(association_scope).merge!(scope)
         else
           target_scope.merge!(association_scope)
         end
@@ -132,15 +135,11 @@ module ActiveRecord
 
       def inversed_from(record)
         self.target = record
-        @inversed = !!record
       end
 
       def inversed_from_queries(record)
         if inversable?(record)
           self.target = record
-          @inversed = true
-        else
-          @inversed = false
         end
       end
 
@@ -191,7 +190,7 @@ module ActiveRecord
         @reflection = @owner.class._reflect_on_association(reflection_name)
       end
 
-      def initialize_attributes(record, except_from_scope_attributes = nil) #:nodoc:
+      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
@@ -210,8 +209,14 @@ module ActiveRecord
       end
 
       private
+        # Reader and writer methods call this so that consistent errors are presented
+        # when the association target class does not exist.
+        def ensure_klass_exists!
+          klass
+        end
+
         def find_target
-          if strict_loading? && owner.validation_context.nil?
+          if violates_strict_loading? && owner.validation_context.nil?
             Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
           end
 
@@ -224,13 +229,20 @@ module ActiveRecord
           end
 
           binds = AssociationScope.get_bind_values(owner, reflection.chain)
-          sc.execute(binds, klass.connection) { |record| set_inverse_instance(record) }
+          sc.execute(binds, klass.connection) do |record|
+            set_inverse_instance(record)
+            if owner.strict_loading_n_plus_one_only? && reflection.macro == :has_many
+              record.strict_loading!
+            else
+              record.strict_loading!(false, mode: owner.strict_loading_mode)
+            end
+          end
         end
 
-        def strict_loading?
+        def violates_strict_loading?
           return reflection.strict_loading? if reflection.options.key?(:strict_loading)
 
-          owner.strict_loading?
+          owner.strict_loading? && !owner.strict_loading_n_plus_one_only?
         end
 
         # The scope for this association.
@@ -241,7 +253,11 @@ module ActiveRecord
         # actually gets built.
         def association_scope
           if klass
-            @association_scope ||= AssociationScope.scope(self)
+            @association_scope ||= if disable_joins
+              DisableJoinsAssociationScope.scope(self)
+            else
+              AssociationScope.scope(self)
+            end
           end
         end
 
@@ -273,7 +289,7 @@ 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.
+        # a safety check when you are about to assign an associated record.
         def raise_on_type_mismatch!(record)
           unless record.is_a?(reflection.klass)
             fresh_class = reflection.class_name.safe_constantize

data/lib/active_record/associations/association_scope.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   module Associations
-    class AssociationScope #:nodoc:
+    class AssociationScope # :nodoc:
       def self.scope(association)
         INSTANCE.scope(association)
       end
@@ -123,8 +123,6 @@ module ActiveRecord
 
           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)
 

data/lib/active_record/associations/belongs_to_association.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module Associations
     # = Active Record Belongs To Association
-    class BelongsToAssociation < SingularAssociation #:nodoc:
+    class BelongsToAssociation < SingularAssociation # :nodoc:
       def handle_dependency
         return unless load_target
 
@@ -55,7 +55,8 @@ module ActiveRecord
 
       def decrement_counters_before_last_save
         if reflection.polymorphic?
-          model_was = owner.attribute_before_last_save(reflection.foreign_type)&.constantize
+          model_type_was = owner.attribute_before_last_save(reflection.foreign_type)
+          model_was = owner.class.polymorphic_class_for(model_type_was) if model_type_was
         else
           model_was = klass
         end
@@ -68,6 +69,14 @@ module ActiveRecord
       end
 
       def target_changed?
+        owner.attribute_changed?(reflection.foreign_key) || (!foreign_key_present? && target&.new_record?)
+      end
+
+      def target_previously_changed?
+        owner.attribute_previously_changed?(reflection.foreign_key)
+      end
+
+      def saved_change_to_target?
         owner.saved_change_to_attribute?(reflection.foreign_key)
       end
 
@@ -77,6 +86,8 @@ module ActiveRecord
             raise_on_type_mismatch!(record)
             set_inverse_instance(record)
             @updated = true
+          elsif target
+            remove_inverse_instance(target)
           end
 
           replace_keys(record, force: true)
@@ -110,7 +121,7 @@ module ActiveRecord
         def replace_keys(record, force: false)
           target_key = record ? record._read_attribute(primary_key(record.class)) : nil
 
-          if force || owner[reflection.foreign_key] != target_key
+          if force || owner._read_attribute(reflection.foreign_key) != target_key
             owner[reflection.foreign_key] = target_key
           end
         end
@@ -125,7 +136,7 @@ module ActiveRecord
 
         def invertible_for?(record)
           inverse = inverse_reflection_for(record)
-          inverse && (inverse.has_one? || ActiveRecord::Base.has_many_inversing)
+          inverse && (inverse.has_one? || inverse.klass.has_many_inversing)
         end
 
         def stale_state

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -3,13 +3,21 @@
 module ActiveRecord
   module Associations
     # = Active Record Belongs To Polymorphic Association
-    class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
+    class BelongsToPolymorphicAssociation < BelongsToAssociation # :nodoc:
       def klass
         type = owner[reflection.foreign_type]
         type.presence && owner.class.polymorphic_class_for(type)
       end
 
       def target_changed?
+        super || owner.attribute_changed?(reflection.foreign_type)
+      end
+
+      def target_previously_changed?
+        super || owner.attribute_previously_changed?(reflection.foreign_type)
+      end
+
+      def saved_change_to_target?
         super || owner.saved_change_to_attribute?(reflection.foreign_type)
       end
 
@@ -19,7 +27,7 @@ module ActiveRecord
 
           target_type = record ? record.class.polymorphic_name : nil
 
-          if force || owner[reflection.foreign_type] != target_type
+          if force || owner._read_attribute(reflection.foreign_type) != target_type
             owner[reflection.foreign_type] = target_type
           end
         end

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

@@ -12,7 +12,7 @@
 #      - HasManyAssociation
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class Association #:nodoc:
+  class Association # :nodoc:
     class << self
       attr_accessor :extensions
     end
@@ -33,6 +33,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       define_accessors model, reflection
       define_callbacks model, reflection
       define_validations model, reflection
+      define_change_tracking_methods model, reflection
       reflection
     end
 
@@ -117,6 +118,10 @@ module ActiveRecord::Associations::Builder # :nodoc:
       # noop
     end
 
+    def self.define_change_tracking_methods(model, reflection)
+      # noop
+    end
+
     def self.valid_dependent_options
       raise NotImplementedError
     end
@@ -158,6 +163,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     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, :add_after_commit_jobs_callback
+      :define_change_tracking_methods, :valid_dependent_options, :check_dependent_options,
+      :add_destroy_callbacks, :add_after_commit_jobs_callback
   end
 end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class BelongsTo < SingularAssociation #:nodoc:
+  class BelongsTo < SingularAssociation # :nodoc:
     def self.macro
       :belongs_to
     end
@@ -30,7 +30,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       model.after_update lambda { |record|
         association = association(reflection.name)
 
-        if association.target_changed?
+        if association.saved_change_to_target?
           association.increment_counters
           association.decrement_counters_before_last_save
         end
@@ -49,7 +49,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
         if reflection.polymorphic?
           foreign_type = reflection.foreign_type
           klass = changes[foreign_type] && changes[foreign_type].first || o.public_send(foreign_type)
-          klass = klass.constantize
+          klass = o.class.polymorphic_class_for(klass)
         else
           klass = association.klass
         end
@@ -87,7 +87,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       if reflection.counter_cache_column
         touch_callback = callback.(:saved_changes)
         update_callback = lambda { |record|
-          instance_exec(record, &touch_callback) unless association(reflection.name).target_changed?
+          instance_exec(record, &touch_callback) unless association(reflection.name).saved_change_to_target?
         }
         model.after_update update_callback, if: :saved_changes?
       else
@@ -127,7 +127,20 @@ module ActiveRecord::Associations::Builder # :nodoc:
       end
     end
 
-    private_class_method :macro, :valid_options, :valid_dependent_options, :define_callbacks, :define_validations,
-      :add_counter_cache_callbacks, :add_touch_callbacks, :add_default_callbacks, :add_destroy_callbacks
+    def self.define_change_tracking_methods(model, reflection)
+      model.generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{reflection.name}_changed?
+          association(:#{reflection.name}).target_changed?
+        end
+
+        def #{reflection.name}_previously_changed?
+          association(:#{reflection.name}).target_previously_changed?
+        end
+      CODE
+    end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options, :define_callbacks,
+      :define_validations, :define_change_tracking_methods, :add_counter_cache_callbacks,
+      :add_touch_callbacks, :add_default_callbacks, :add_destroy_callbacks
   end
 end

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

@@ -3,7 +3,7 @@
 require "active_record/associations"
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class CollectionAssociation < Association #:nodoc:
+  class CollectionAssociation < Association # :nodoc:
     CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
 
     def self.valid_options(options)
@@ -30,11 +30,18 @@ module ActiveRecord::Associations::Builder # :nodoc:
     def self.define_callback(model, callback_name, name, options)
       full_callback_name = "#{callback_name}_for_#{name}"
 
-      unless model.method_defined?(full_callback_name)
+      callback_values = Array(options[callback_name.to_sym])
+      method_defined = model.respond_to?(full_callback_name)
+
+      # If there are no callbacks, we must also check if a superclass had
+      # previously defined this association
+      return if callback_values.empty? && !method_defined
+
+      unless method_defined
         model.class_attribute(full_callback_name, instance_accessor: false, instance_predicate: false)
       end
 
-      callbacks = Array(options[callback_name.to_sym]).map do |callback|
+      callbacks = callback_values.map do |callback|
         case callback
         when Symbol
           ->(method, owner, record) { owner.send(callback, record) }

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

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class HasMany < CollectionAssociation #:nodoc:
+  class HasMany < CollectionAssociation # :nodoc:
     def self.macro
       :has_many
     end
 
     def self.valid_options(options)
-      valid = super + [:counter_cache, :join_table, :index_errors, :ensuring_owner_was]
+      valid = super + [:counter_cache, :join_table, :index_errors]
       valid += [:as, :foreign_type] if options[:as]
       valid += [:through, :source, :source_type] if options[:through]
       valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
+      valid += [:disable_joins] if options[:disable_joins] && options[:through]
       valid
     end
 

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class HasOne < SingularAssociation #:nodoc:
+  class HasOne < SingularAssociation # :nodoc:
     def self.macro
       :has_one
     end
@@ -11,6 +11,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       valid += [:as, :foreign_type] if options[:as]
       valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
       valid += [:through, :source, :source_type] if options[:through]
+      valid += [:disable_joins] if options[:disable_joins] && options[:through]
       valid
     end
 

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

@@ -3,7 +3,7 @@
 # This class is inherited by the has_one and belongs_to association classes
 
 module ActiveRecord::Associations::Builder # :nodoc:
-  class SingularAssociation < Association #:nodoc:
+  class SingularAssociation < Association # :nodoc:
     def self.valid_options(options)
       super + [:required, :touch]
     end
@@ -13,7 +13,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       mixin = model.generated_association_methods
       name = reflection.name
 
-      define_constructors(mixin, name) if reflection.constructable?
+      define_constructors(mixin, name) unless reflection.polymorphic?
 
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def reload_#{name}

data/lib/active_record/associations/collection_association.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/enumerable"
+
 module ActiveRecord
   module Associations
     # = Active Record Association Collection
@@ -25,9 +27,11 @@ module ActiveRecord
     #
     # If you need to work on all current children, new and existing records,
     # +load_target+ and the +loaded+ flag are your friends.
-    class CollectionAssociation < Association #:nodoc:
+    class CollectionAssociation < Association # :nodoc:
       # Implements the reader method, e.g. foo.items for Foo.has_many :items
       def reader
+        ensure_klass_exists!
+
         if stale_target?
           reload
         end
@@ -75,6 +79,7 @@ module ActiveRecord
       def reset
         super
         @target = []
+        @replaced_or_added_targets = Set.new
         @association_ids = nil
       end
 
@@ -121,21 +126,6 @@ module ActiveRecord
         end
       end
 
-      # Starts a transaction in the association class's database connection.
-      #
-      #   class Author < ActiveRecord::Base
-      #     has_many :books
-      #   end
-      #
-      #   Author.first.books.transaction do
-      #     # same effect as calling Book.transaction
-      #   end
-      def transaction(*args)
-        reflection.klass.transaction(*args) do
-          yield
-        end
-      end
-
       # Removes all records from the association without calling callbacks
       # on the associated records. It honors the +:dependent+ option. However
       # if the +:dependent+ value is +:destroy+ then in that case the +:delete_all+
@@ -279,20 +269,19 @@ module ActiveRecord
       end
 
       def add_to_target(record, skip_callbacks: false, replace: false, &block)
-        if replace || association_scope.distinct_value
-          index = @target.index(record)
-        end
-        replace_on_target(record, index, skip_callbacks, &block)
+        replace_on_target(record, skip_callbacks, replace: replace || association_scope.distinct_value, &block)
       end
 
       def target=(record)
-        return super unless ActiveRecord::Base.has_many_inversing
+        return super unless reflection.klass.has_many_inversing
 
         case record
+        when nil
+          # It's not possible to remove the record from the inverse association.
         when Array
           super
         else
-          add_to_target(record, skip_callbacks: true, replace: true)
+          replace_on_target(record, true, replace: true, inversing: true)
         end
       end
 
@@ -315,6 +304,10 @@ module ActiveRecord
       end
 
       private
+        def transaction(&block)
+          reflection.klass.transaction(&block)
+        end
+
         # We have some records loaded from the database (persisted) and some that are
         # in-memory (memory). The same record may be represented in the persisted array
         # and in the memory array.
@@ -342,12 +335,12 @@ module ActiveRecord
             end
           end
 
-          persisted + memory
+          persisted + memory.reject(&:persisted?)
         end
 
         def _create_record(attributes, raise = false, &block)
           unless owner.persisted?
-            raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
+            raise ActiveRecord::RecordNotSaved.new("You cannot call create unless the parent is saved", owner)
           end
 
           if attributes.is_a?(Array)
@@ -425,7 +418,7 @@ module ActiveRecord
           common_records = intersection(new_target, original_target)
           common_records.each do |record|
             skip_callbacks = true
-            replace_on_target(record, @target.index(record), skip_callbacks)
+            replace_on_target(record, skip_callbacks, replace: true)
           end
         end
 
@@ -448,7 +441,11 @@ module ActiveRecord
           records
         end
 
-        def replace_on_target(record, index, skip_callbacks)
+        def replace_on_target(record, skip_callbacks, replace:, inversing: false)
+          if replace && (!record.new_record? || @replaced_or_added_targets.include?(record))
+            index = @target.index(record)
+          end
+
           catch(:abort) do
             callback(:before_add, record)
           end || return unless skip_callbacks
@@ -459,6 +456,12 @@ module ActiveRecord
 
           yield(record) if block_given?
 
+          if !index && @replaced_or_added_targets.include?(record)
+            index = @target.index(record)
+          end
+
+          @replaced_or_added_targets << record if inversing || index || record.new_record?
+
           if index
             target[index] = record
           elsif @_was_loaded || !loaded?
@@ -481,7 +484,11 @@ module ActiveRecord
 
         def callbacks_for(callback_name)
           full_callback_name = "#{callback_name}_for_#{reflection.name}"
-          owner.class.send(full_callback_name)
+          if owner.class.respond_to?(full_callback_name)
+            owner.class.send(full_callback_name)
+          else
+            []
+          end
         end
 
         def include_in_memory?(record)

data/lib/active_record/associations/collection_proxy.rb

@@ -27,7 +27,7 @@ module ActiveRecord
     # is computed directly through SQL and does not trigger by itself the
     # instantiation of the actual post records.
     class CollectionProxy < Relation
-      def initialize(klass, association, **) #:nodoc:
+      def initialize(klass, association, **) # :nodoc:
         @association = association
         super klass
 
@@ -46,7 +46,7 @@ module ActiveRecord
       # Returns +true+ if the association has been loaded, otherwise +false+.
       #
       #   person.pets.loaded? # => false
-      #   person.pets
+      #   person.pets.records
       #   person.pets.loaded? # => true
       def loaded?
         @association.loaded?
@@ -813,7 +813,7 @@ module ActiveRecord
       # to <tt>collection.size.zero?</tt>. If the collection has not been loaded,
       # it is equivalent to <tt>!collection.exists?</tt>. If the collection has
       # not already been loaded and you are going to fetch the records anyway it
-      # is better to check <tt>collection.length.zero?</tt>.
+      # is better to check <tt>collection.load.empty?</tt>.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets
@@ -849,6 +849,11 @@ module ActiveRecord
       #   person.pets.count # => 1
       #   person.pets.any?  # => true
       #
+      # Calling it without a block when the collection is not yet
+      # loaded is equivalent to <tt>collection.exists?</tt>.
+      # If you're going to load the collection anyway, it is better
+      # to call <tt>collection.load.any?</tt> to avoid an extra query.
+      #
       # You can also pass a +block+ to define criteria. The behavior
       # is the same, it returns true if the collection based on the
       # criteria is not empty.