activerecord 5.0.7.2 → 6.1.1

data/lib/active_record/associations/foreign_association.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Associations
   module ForeignAssociation # :nodoc:
     def foreign_key_present?
@@ -7,5 +9,25 @@ module ActiveRecord::Associations
         false
       end
     end
+
+    def nullified_owner_attributes
+      Hash.new.tap do |attrs|
+        attrs[reflection.foreign_key] = nil
+        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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Has Many Association
   module Associations
+    # = Active Record Has Many Association
     # This is the proxy that handles a has many association.
     #
     # If the association has a <tt>:through</tt> option further specialization
@@ -16,25 +18,38 @@ module ActiveRecord
         when :restrict_with_error
           unless empty?
             record = owner.class.human_attribute_name(reflection.name).downcase
-            message = owner.errors.generate_message(:base, :'restrict_dependent_destroy.many', record: record, raise: true) rescue nil
-            if message
-              ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
-                The error key `:'restrict_dependent_destroy.many'` has been deprecated and will be removed in Rails 5.1.
-                Please use `:'restrict_dependent_destroy.has_many'` instead.
-              MESSAGE
-            end
-            owner.errors.add(:base, message || :'restrict_dependent_destroy.has_many', record: record)
+            owner.errors.add(:base, :'restrict_dependent_destroy.has_many', record: record)
             throw(:abort)
           end
 
-        else
-          if options[:dependent] == :destroy
-            # 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
-          else
-            delete_all
+        when :destroy
+          # 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
       end
 
@@ -43,16 +58,7 @@ module ActiveRecord
         super
       end
 
-      def empty?
-        if reflection.has_cached_counter?
-          size.zero?
-        else
-          super
-        end
-      end
-
       private
-
         # Returns the number of records in this collection.
         #
         # If the association has a counter cache it gets that value. Otherwise
@@ -68,15 +74,15 @@ 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
+            owner.read_attribute(reflection.counter_cache_column).to_i
           else
-            scope.count
+            scope.count(:all)
           end
 
           # If there's nothing in the database and @target has no new records
           # we are certain the current target is an empty array. This is a
           # documented side-effect of the method that may avoid an extra SELECT.
-          @target ||= [] and loaded! if count == 0
+          loaded! if count == 0
 
           [association_scope.limit_value, count].compact.min
         end
@@ -91,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
 
@@ -99,13 +105,14 @@ module ActiveRecord
           if method == :delete_all
             scope.delete_all
           else
-            scope.update_all(reflection.foreign_key => nil)
+            scope.update_all(nullified_owner_attributes)
           end
         end
 
         def delete_or_nullify_all_records(method)
-          count = delete_count(method, self.scope)
+          count = delete_count(method, scope)
           update_counter(-count)
+          count
         end
 
         # Deletes the records according to the <tt>:dependent</tt> option.
@@ -137,6 +144,14 @@ module ActiveRecord
           end
           saved_successfully
         end
+
+        def difference(a, b)
+          a - b
+        end
+
+        def intersection(a, b)
+          a & b
+        end
     end
   end
 end

data/lib/active_record/associations/has_many_through_association.rb

@@ -1,14 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Has Many Through Association
   module Associations
+    # = Active Record Has Many Through Association
     class HasManyThroughAssociation < HasManyAssociation #:nodoc:
       include ThroughAssociation
 
       def initialize(owner, reflection)
         super
-
-        @through_records     = {}
-        @through_association = nil
+        @through_records = {}.compare_by_identity
       end
 
       def concat(*records)
@@ -21,24 +21,10 @@ module ActiveRecord
         super
       end
 
-      def concat_records(records)
-        ensure_not_nested
-
-        records = super(records, true)
-
-        if owner.new_record? && records
-          records.flatten.each do |record|
-            build_through_record(record)
-          end
-        end
-
-        records
-      end
-
       def insert_record(record, validate = true, raise = false)
         ensure_not_nested
 
-        if record.new_record? || record.changed?
+        if record.new_record? || record.has_changes_to_save?
           return unless super
         end
 
@@ -48,9 +34,18 @@ module ActiveRecord
       end
 
       private
+        def concat_records(records)
+          ensure_not_nested
+
+          records = super(records, true)
+
+          if owner.new_record? && records
+            records.flatten.each do |record|
+              build_through_record(record)
+            end
+          end
 
-        def through_association
-          @through_association ||= owner.association(through_reflection.name)
+          records
         end
 
         # The through record (built with build_record) is temporarily cached
@@ -59,40 +54,40 @@ 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
 
-            through_record = through_association.build(*options_for_through_record)
-            through_record.send("#{source_reflection.name}=", record)
-
-            if options[:source_type]
-              through_record.send("#{source_reflection.foreign_type}=", options[:source_type])
-            end
+            attributes = through_scope_attributes
+            attributes[source_reflection.name] = record
+            attributes[source_reflection.foreign_type] = options[:source_type] if options[:source_type]
 
-            through_record
+            through_association.build(attributes)
           end
         end
 
-        def options_for_through_record
-          [through_scope_attributes]
-        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)
         end
 
         def save_through_record(record)
-          build_through_record(record).save!
+          association = build_through_record(record)
+          if association.changed?
+            association.save!
+          end
         ensure
-          @through_records.delete(record.object_id)
+          @through_records.delete(record)
         end
 
         def build_record(attributes)
           ensure_not_nested
 
-          record = super(attributes)
+          @through_scope = scope
+          record = super
 
           inverse = source_reflection.inverse_of
           if inverse
@@ -104,6 +99,13 @@ module ActiveRecord
           end
 
           record
+        ensure
+          @through_scope = nil
+        end
+
+        def remove_records(existing_records, records, method)
+          super
+          delete_through_records(records)
         end
 
         def target_reflection_has_associated_record?
@@ -130,21 +132,15 @@ module ActiveRecord
 
           scope = through_association.scope
           scope.where! construct_join_attributes(*records)
+          scope = scope.where(through_scope_attributes)
 
           case method
           when :destroy
             if scope.klass.primary_key
-              count = scope.destroy_all.length
+              count = scope.destroy_all.count(&:destroyed?)
             else
               scope.each(&:_run_destroy_callbacks)
-
-              arel = scope.arel
-
-              stmt = Arel::DeleteManager.new
-              stmt.from scope.klass.arel_table
-              stmt.wheres = arel.constraints
-
-              count = scope.klass.connection.delete(stmt, 'SQL', scope.bound_attributes)
+              count = scope.delete_all
             end
           when :nullify
             count = scope.update_all(source_reflection.foreign_key => nil)
@@ -164,6 +160,30 @@ module ActiveRecord
           else
             update_counter(-count)
           end
+
+          count
+        end
+
+        def difference(a, b)
+          distribution = distribution(b)
+
+          a.reject { |record| mark_occurrence(distribution, record) }
+        end
+
+        def intersection(a, b)
+          distribution = distribution(b)
+
+          a.select { |record| mark_occurrence(distribution, record) }
+        end
+
+        def mark_occurrence(distribution, record)
+          distribution[record] > 0 && distribution[record] -= 1
+        end
+
+        def distribution(array)
+          array.each_with_object(Hash.new(0)) do |record, distribution|
+            distribution[record] += 1
+          end
         end
 
         def through_records_for(record)
@@ -188,13 +208,13 @@ module ActiveRecord
               end
             end
 
-            @through_records.delete(record.object_id)
+            @through_records.delete(record)
           end
         end
 
         def find_target
           return [] unless target_reflection_has_associated_record?
-          get_records
+          super
         end
 
         # NOTE - not sure that we can actually cope with inverses here

data/lib/active_record/associations/has_one_association.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Has One Association
   module Associations
+    # = Active Record Has One Association
     class HasOneAssociation < SingularAssociation #:nodoc:
       include ForeignAssociation
 
@@ -12,14 +14,7 @@ module ActiveRecord
         when :restrict_with_error
           if load_target
             record = owner.class.human_attribute_name(reflection.name).downcase
-            message = owner.errors.generate_message(:base, :'restrict_dependent_destroy.one', record: record, raise: true) rescue nil
-            if message
-              ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
-                The error key `:'restrict_dependent_destroy.one'` has been deprecated and will be removed in Rails 5.1.
-                Please use `:'restrict_dependent_destroy.has_one'` instead.
-              MESSAGE
-            end
-            owner.errors.add(:base, message || :'restrict_dependent_destroy.has_one', record: record)
+            owner.errors.add(:base, :'restrict_dependent_destroy.has_one', record: record)
             throw(:abort)
           end
 
@@ -28,49 +23,61 @@ module ActiveRecord
         end
       end
 
-      def replace(record, save = true)
-        raise_on_type_mismatch!(record) if record
-        load_target
+      def delete(method = options[:dependent])
+        if load_target
+          case method
+          when :delete
+            target.delete
+          when :destroy
+            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
+        end
+      end
 
-        return self.target if !(target || record)
+      private
+        def replace(record, save = true)
+          raise_on_type_mismatch!(record) if record
+
+          return target unless load_target || record
 
-        assigning_another_record = target != record
-        if assigning_another_record || record.changed?
-          save &&= owner.persisted?
+          assigning_another_record = target != record
+          if assigning_another_record || record.has_changes_to_save?
+            save &&= owner.persisted?
 
-          transaction_if(save) do
-            remove_target!(options[:dependent]) if target && !target.destroyed? && assigning_another_record
+            transaction_if(save) do
+              remove_target!(options[:dependent]) if target && !target.destroyed? && assigning_another_record
 
-            if record
-              set_owner_attributes(record)
-              set_inverse_instance(record)
+              if record
+                set_owner_attributes(record)
+                set_inverse_instance(record)
 
-              if save && !record.save
-                nullify_owner_attributes(record)
-                set_owner_attributes(target) if target
-                raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+                if save && !record.save
+                  nullify_owner_attributes(record)
+                  set_owner_attributes(target) if target
+                  raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+                end
               end
             end
           end
-        end
 
-        self.target = record
-      end
-
-      def delete(method = options[:dependent])
-        if load_target
-          case method
-            when :delete
-              target.delete
-            when :destroy
-              target.destroy
-            when :nullify
-              target.update_columns(reflection.foreign_key => nil) if target.persisted?
-          end
+          self.target = record
         end
-      end
-
-      private
 
         # The reason that the save param for replace is false, if for create (not just build),
         # is because the setting of the foreign keys is actually handled by the scoping when
@@ -82,18 +89,22 @@ module ActiveRecord
 
         def remove_target!(method)
           case method
-            when :delete
-              target.delete
-            when :destroy
+          when :delete
+            target.delete
+          when :destroy
+            target.destroyed_by_association = reflection
+            if target.persisted?
               target.destroy
-            else
-              nullify_owner_attributes(target)
+            end
+          else
+            nullify_owner_attributes(target)
+            remove_inverse_instance(target)
 
-              if target.persisted? && owner.persisted? && !target.save
-                set_owner_attributes(target)
-                raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " +
-                                      "The record failed to save after its foreign key was set to nil."
-              end
+            if target.persisted? && owner.persisted? && !target.save
+              set_owner_attributes(target)
+              raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " \
+                                    "The record failed to save after its foreign key was set to nil."
+            end
           end
         end
 
@@ -108,6 +119,14 @@ module ActiveRecord
             yield
           end
         end
+
+        def _create_record(attributes, raise_error = false, &block)
+          unless owner.persisted?
+            raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
+          end
+
+          super
+        end
     end
   end
 end