activerecord 6.0.6.1 → 6.1.7.6

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

@@ -7,13 +7,15 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      valid = super + [:as, :touch]
+      valid = super
+      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
     end
 
     def self.valid_dependent_options
-      [:destroy, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
+      [:destroy, :destroy_async, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
     end
 
     def self.define_callbacks(model, reflection)
@@ -32,15 +34,12 @@ module ActiveRecord::Associations::Builder # :nodoc:
       end
     end
 
-    def self.touch_record(o, name, touch)
-      record = o.send name
+    def self.touch_record(record, name, touch)
+      instance = record.send(name)
 
-      return unless record && record.persisted?
-
-      if touch != true
-        record.touch(touch)
-      else
-        record.touch
+      if instance&.persisted?
+        touch != true ?
+          instance.touch(touch) : instance.touch
       end
     end
 
@@ -48,11 +47,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
       name  = reflection.name
       touch = reflection.options[:touch]
 
-      callback = lambda { |record|
-        HasOne.touch_record(record, name, touch)
-      }
-
+      callback = -> (record) { HasOne.touch_record(record, name, touch) }
       model.after_create callback, if: :saved_changes?
+      model.after_create_commit { association(name).reset_negative_cache }
       model.after_update callback, if: :saved_changes?
       model.after_destroy callback
       model.after_touch callback

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

@@ -5,7 +5,7 @@
 module ActiveRecord::Associations::Builder # :nodoc:
   class SingularAssociation < Association #:nodoc:
     def self.valid_options(options)
-      super + [:foreign_type, :dependent, :primary_key, :inverse_of, :required]
+      super + [:required, :touch]
     end
 
     def self.define_accessors(model, reflection)

data/lib/active_record/associations/collection_association.rb

@@ -56,7 +56,7 @@ module ActiveRecord
       def ids_writer(ids)
         primary_key = reflection.association_primary_key
         pk_type = klass.type_for_attribute(primary_key)
-        ids = Array(ids).reject(&:blank?)
+        ids = Array(ids).compact_blank
         ids.map! { |i| pk_type.cast(i) }
 
         records = klass.where(primary_key => ids).index_by do |r|
@@ -75,6 +75,7 @@ module ActiveRecord
       def reset
         super
         @target = []
+        @replaced_or_added_targets = Set.new
         @association_ids = nil
       end
 
@@ -101,11 +102,11 @@ module ActiveRecord
         end
       end
 
-      def build(attributes = {}, &block)
+      def build(attributes = nil, &block)
         if attributes.is_a?(Array)
           attributes.collect { |attr| build(attr, &block) }
         else
-          add_to_target(build_record(attributes, &block))
+          add_to_target(build_record(attributes, &block), replace: true)
         end
       end
 
@@ -228,7 +229,7 @@ module ActiveRecord
       # If the collection has been loaded
       # it is equivalent 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
+      # <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>.
       def empty?
@@ -278,11 +279,19 @@ module ActiveRecord
         target
       end
 
-      def add_to_target(record, skip_callbacks = false, &block)
-        if association_scope.distinct_value
-          index = @target.index(record)
+      def add_to_target(record, skip_callbacks: false, replace: false, &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
+
+        case record
+        when Array
+          super
+        else
+          replace_on_target(record, true, replace: true, inversing: true)
         end
-        replace_on_target(record, index, skip_callbacks, &block)
       end
 
       def scope
@@ -297,6 +306,8 @@ module ActiveRecord
 
       def find_from_target?
         loaded? ||
+          owner.strict_loading? ||
+          reflection.strict_loading? ||
           owner.new_record? ||
           target.any? { |record| record.new_record? || record.changed? }
       end
@@ -329,14 +340,7 @@ module ActiveRecord
             end
           end
 
-          persisted + memory
-        end
-
-        def build_record(attributes)
-          previous = klass.current_scope(true) if block_given?
-          super
-        ensure
-          klass.current_scope = previous if previous
+          persisted + memory.reject(&:persisted?)
         end
 
         def _create_record(attributes, raise = false, &block)
@@ -419,7 +423,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
 
@@ -442,7 +446,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
@@ -453,6 +461,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?

data/lib/active_record/associations/collection_proxy.rb

@@ -101,7 +101,7 @@ module ActiveRecord
       # converting them into an array and iterating through them using
       # Array#select.
       #
-      #   person.pets.select { |pet| pet.name =~ /oo/ }
+      #   person.pets.select { |pet| /oo/.match?(pet.name) }
       #   # => [
       #   #      #<Pet id: 2, name: "Spook", person_id: 1>,
       #   #      #<Pet id: 3, name: "Choo-Choo", person_id: 1>
@@ -374,7 +374,7 @@ module ActiveRecord
       #   person.pets
       #   # => [#<Pet id: 1, name: "Gorby", group: "cats", person_id: 1>]
       #
-      #   other_pets = [Pet.new(name: 'Puff', group: 'celebrities']
+      #   other_pets = [Pet.new(name: 'Puff', group: 'celebrities')]
       #
       #   person.pets.replace(other_pets)
       #
@@ -921,7 +921,7 @@ module ActiveRecord
         !!@association.include?(record)
       end
 
-      def proxy_association
+      def proxy_association # :nodoc:
         @association
       end
 
@@ -1087,17 +1087,24 @@ module ActiveRecord
       end
 
       def reset_scope # :nodoc:
-        @offsets = {}
+        @offsets = @take = nil
         @scope = nil
         self
       end
 
+      def inspect # :nodoc:
+        load_target if find_from_target?
+        super
+      end
+
       delegate_methods = [
         QueryMethods,
         SpawnMethods,
       ].flat_map { |klass|
         klass.public_instance_methods(false)
-      } - self.public_instance_methods(false) - [:select] + [:scoping, :values]
+      } - self.public_instance_methods(false) - [:select] + [
+        :scoping, :values, :insert, :insert_all, :insert!, :insert_all!, :upsert, :upsert_all
+      ]
 
       delegate(*delegate_methods, to: :scope)
 

data/lib/active_record/associations/foreign_association.rb

@@ -16,5 +16,18 @@ module ActiveRecord::Associations
         attrs[reflection.type] = nil if reflection.type.present?
       end
     end
+
+    private
+      # Sets the owner attributes on the given record
+      def set_owner_attributes(record)
+        return if options[:through]
+
+        key = owner._read_attribute(reflection.join_foreign_key)
+        record._write_attribute(reflection.join_primary_key, key)
+
+        if reflection.type
+          record._write_attribute(reflection.type, owner.class.polymorphic_name)
+        end
+      end
   end
 end

data/lib/active_record/associations/has_many_association.rb

@@ -26,6 +26,28 @@ module ActiveRecord
           # No point in executing the counter update since we're going to destroy the parent anyway
           load_target.each { |t| t.destroyed_by_association = reflection }
           destroy_all
+        when :destroy_async
+          load_target.each do |t|
+            t.destroyed_by_association = reflection
+          end
+
+          unless target.empty?
+            association_class = target.first.class
+            primary_key_column = association_class.primary_key.to_sym
+
+            ids = target.collect do |assoc|
+              assoc.public_send(primary_key_column)
+            end
+
+            enqueue_destroy_association(
+              owner_model_name: owner.class.to_s,
+              owner_id: owner.id,
+              association_class: reflection.klass.to_s,
+              association_ids: ids,
+              association_primary_key_column: primary_key_column,
+              ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+            )
+          end
         else
           delete_all
         end
@@ -52,7 +74,7 @@ module ActiveRecord
         # the loaded flag is set to true as well.
         def count_records
           count = if reflection.has_cached_counter?
-            owner._read_attribute(reflection.counter_cache_column).to_i
+            owner.read_attribute(reflection.counter_cache_column).to_i
           else
             scope.count(:all)
           end
@@ -75,7 +97,7 @@ module ActiveRecord
           if reflection.counter_must_be_updated_by_has_many?
             counter = reflection.counter_cache_column
             owner.increment(counter, difference)
-            owner.send(:clear_attribute_change, counter) # eww
+            owner.send(:"clear_#{counter}_change")
           end
         end
 

data/lib/active_record/associations/has_many_through_association.rb

@@ -8,7 +8,7 @@ module ActiveRecord
 
       def initialize(owner, reflection)
         super
-        @through_records = {}
+        @through_records = {}.compare_by_identity
       end
 
       def concat(*records)
@@ -54,7 +54,7 @@ module ActiveRecord
         # However, after insert_record has been called, the cache is cleared in
         # order to allow multiple instances of the same record in an association.
         def build_through_record(record)
-          @through_records[record.object_id] ||= begin
+          @through_records[record] ||= begin
             ensure_mutable
 
             attributes = through_scope_attributes
@@ -65,7 +65,10 @@ module ActiveRecord
           end
         end
 
+        attr_reader :through_scope
+
         def through_scope_attributes
+          scope = through_scope || self.scope
           scope.where_values_hash(through_association.reflection.name.to_s).
             except!(through_association.reflection.foreign_key,
                     through_association.reflection.klass.inheritance_column)
@@ -77,12 +80,13 @@ module ActiveRecord
             association.save!
           end
         ensure
-          @through_records.delete(record.object_id)
+          @through_records.delete(record)
         end
 
         def build_record(attributes)
           ensure_not_nested
 
+          @through_scope = scope
           record = super
 
           inverse = source_reflection.inverse_of
@@ -95,6 +99,8 @@ module ActiveRecord
           end
 
           record
+        ensure
+          @through_scope = nil
         end
 
         def remove_records(existing_records, records, method)
@@ -202,7 +208,7 @@ module ActiveRecord
               end
             end
 
-            @through_records.delete(record.object_id)
+            @through_records.delete(record)
           end
         end
 

data/lib/active_record/associations/has_one_association.rb

@@ -32,6 +32,18 @@ module ActiveRecord
             target.destroyed_by_association = reflection
             target.destroy
             throw(:abort) unless target.destroyed?
+          when :destroy_async
+            primary_key_column = target.class.primary_key.to_sym
+            id = target.public_send(primary_key_column)
+
+            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)
+            )
           when :nullify
             target.update_columns(nullified_owner_attributes) if target.persisted?
           end
@@ -81,7 +93,9 @@ module ActiveRecord
             target.delete
           when :destroy
             target.destroyed_by_association = reflection
-            target.destroy
+            if target.persisted?
+              target.destroy
+            end
           else
             nullify_owner_attributes(target)
             remove_inverse_instance(target)

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -14,7 +14,6 @@ module ActiveRecord
           super(reflection.klass, children)
 
           @reflection = reflection
-          @tables     = nil
         end
 
         def match?(other)
@@ -24,32 +23,47 @@ module ActiveRecord
 
         def join_constraints(foreign_table, foreign_klass, join_type, alias_tracker)
           joins = []
+          chain = []
+
+          reflection.chain.each do |reflection|
+            table, terminated = yield reflection
+            @table ||= table
+
+            if terminated
+              foreign_table, foreign_klass = table, reflection.klass
+              break
+            end
+
+            chain << [reflection, table]
+          end
 
           # The chain starts with the target table, but we want to end with it here (makes
           # more sense in this context), so we reverse
-          reflection.chain.reverse_each.with_index(1) do |reflection, i|
-            table = tables[-i]
+          chain.reverse_each do |reflection, table|
             klass = reflection.klass
 
-            join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
+            scope = reflection.join_scope(table, foreign_table, foreign_klass)
+
+            unless scope.references_values.empty?
+              associations = scope.eager_load_values | scope.includes_values
 
-            unless join_scope.references_values.empty?
-              join_dependency = join_scope.construct_join_dependency(
-                join_scope.eager_load_values | join_scope.includes_values, Arel::Nodes::OuterJoin
-              )
-              join_scope.joins!(join_dependency)
+              unless associations.empty?
+                scope.joins! scope.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+              end
             end
 
-            arel = join_scope.arel(alias_tracker.aliases)
+            arel = scope.arel(alias_tracker.aliases)
             nodes = arel.constraints.first
 
-            others = nodes.children.extract! do |node|
-              !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+            if nodes.is_a?(Arel::Nodes::And)
+              others = nodes.children.extract! do |node|
+                !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+              end
             end
 
-            joins << table.create_join(table, table.create_on(nodes), join_type)
+            joins << join_type.new(table, Arel::Nodes::On.new(nodes))
 
-            unless others.empty?
+            if others && !others.empty?
               joins.concat arel.join_sources
               append_constraints(joins.last, others)
             end
@@ -61,24 +75,26 @@ module ActiveRecord
           joins
         end
 
-        def tables=(tables)
-          @tables = tables
-          @table  = tables.first
-        end
-
         def readonly?
           return @readonly if defined?(@readonly)
 
           @readonly = reflection.scope && reflection.scope_for(base_klass.unscoped).readonly_value
         end
 
+        def strict_loading?
+          return @strict_loading if defined?(@strict_loading)
+
+          @strict_loading = reflection.scope && reflection.scope_for(base_klass.unscoped).strict_loading_value
+        end
+
         private
           def append_constraints(join, constraints)
             if join.is_a?(Arel::Nodes::StringJoin)
-              join_string = table.create_and(constraints.unshift(join.left))
+              join_string = Arel::Nodes::And.new(constraints.unshift join.left)
               join.left = Arel.sql(base_klass.connection.visitor.compile(join_string))
             else
-              join.right.expr.children.concat(constraints)
+              right = join.right
+              right.expr = Arel::Nodes::And.new(constraints.unshift right.expr)
             end
           end
       end

data/lib/active_record/associations/join_dependency/join_part.rb

@@ -17,7 +17,7 @@ module ActiveRecord
         # association.
         attr_reader :base_klass, :children
 
-        delegate :table_name, :column_names, :primary_key, to: :base_klass
+        delegate :table_name, :column_names, :primary_key, :attribute_types, to: :base_klass
 
         def initialize(base_klass, children)
           @base_klass = base_klass