activerecord 5.2.8.1 → 6.1.6.1

data/lib/active_record/associations/belongs_to_association.rb

@@ -9,28 +9,24 @@ module ActiveRecord
 
         case options[:dependent]
         when :destroy
-          target.destroy
-          raise ActiveRecord::Rollback unless target.destroyed?
+          raise ActiveRecord::Rollback unless target.destroy
+        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
-          target.send(options[:dependent])
+          target.public_send(options[:dependent])
         end
       end
 
-      def replace(record)
-        if record
-          raise_on_type_mismatch!(record)
-          update_counters_on_replace(record)
-          set_inverse_instance(record)
-          @updated = true
-        else
-          decrement_counters
-        end
-
-        replace_keys(record)
-
-        self.target = record
-      end
-
       def inversed_from(record)
         replace_keys(record)
         super
@@ -49,30 +45,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, touch: reflection.options[:touch])
             else
-              klass.update_counters(target_id, reflection.counter_cache_column => by, touch: reflection.options[:touch])
+              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
@@ -81,44 +107,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, touch: reflection.options[:touch])
-            decrement_counters
-          end
-        end
-
-        # Checks whether record is different to the current target, without loading it
-        def different_target?(record)
-          record._read_attribute(primary_key(record)) != 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 ? record._read_attribute(primary_key(record)) : nil
+          if force || owner[reflection.foreign_key] != target_key
+            owner[reflection.foreign_key] = target_key
+          end
         end
 
-        def primary_key(record)
-          reflection.association_primary_key(record.class)
+        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

@@ -6,7 +6,7 @@ module ActiveRecord
     class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
       def klass
         type = owner[reflection.foreign_type]
-        type.presence && type.constantize
+        type.presence && owner.class.polymorphic_class_for(type)
       end
 
       def target_changed?
@@ -14,13 +14,14 @@ module ActiveRecord
       end
 
       private
-        def replace_keys(record)
+        def replace_keys(record, force: false)
           super
-          owner[reflection.foreign_type] = record ? record.class.polymorphic_name : nil
-        end
 
-        def different_target?(record)
-          super || record.class != klass
+          target_type = record ? record.class.polymorphic_name : nil
+
+          if force || owner[reflection.foreign_type] != target_type
+            owner[reflection.foreign_type] = target_type
+          end
         end
 
         def inverse_reflection_for(record)

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

@@ -18,7 +18,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
     self.extensions = []
 
-    VALID_OPTIONS = [:class_name, :anonymous_class, :foreign_key, :validate] # :nodoc:
+    VALID_OPTIONS = [
+      :class_name, :anonymous_class, :primary_key, :foreign_key, :dependent, :validate, :inverse_of, :strict_loading
+    ].freeze # :nodoc:
 
     def self.build(model, name, scope, options, &block)
       if model.dangerous_attribute_method?(name)
@@ -27,40 +29,32 @@ module ActiveRecord::Associations::Builder # :nodoc:
                              "Please choose a different association name."
       end
 
-      extension = define_extensions model, name, &block
-      reflection = create_reflection model, name, scope, options, extension
+      reflection = create_reflection(model, name, scope, options, &block)
       define_accessors model, reflection
       define_callbacks model, reflection
       define_validations model, reflection
       reflection
     end
 
-    def self.create_reflection(model, name, scope, options, extension = nil)
+    def self.create_reflection(model, name, scope, options, &block)
       raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
 
       validate_options(options)
 
-      scope = build_scope(scope, extension)
+      extension = define_extensions(model, name, &block)
+      options[:extend] = [*options[:extend], extension] if extension
+
+      scope = build_scope(scope)
 
       ActiveRecord::Reflection.create(macro, name, scope, options, model)
     end
 
-    def self.build_scope(scope, extension)
-      new_scope = scope
-
+    def self.build_scope(scope)
       if scope && scope.arity == 0
-        new_scope = proc { instance_exec(&scope) }
-      end
-
-      if extension
-        new_scope = wrap_scope new_scope, extension
+        proc { instance_exec(&scope) }
+      else
+        scope
       end
-
-      new_scope
-    end
-
-    def self.wrap_scope(scope, extension)
-      scope
     end
 
     def self.macro
@@ -80,8 +74,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def self.define_callbacks(model, reflection)
       if dependent = reflection.options[:dependent]
-        check_dependent_options(dependent)
+        check_dependent_options(dependent, model)
         add_destroy_callbacks(model, reflection)
+        add_after_commit_jobs_callback(model, dependent)
       end
 
       Association.extensions.each do |extension|
@@ -126,7 +121,11 @@ module ActiveRecord::Associations::Builder # :nodoc:
       raise NotImplementedError
     end
 
-    def self.check_dependent_options(dependent)
+    def self.check_dependent_options(dependent, model)
+      if dependent == :destroy_async && !model.destroy_association_async_job
+        err_message = "ActiveJob is required to use destroy_async on associations"
+        raise ActiveRecord::ActiveJobRequiredError, err_message
+      end
       unless valid_dependent_options.include? dependent
         raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{dependent}"
       end
@@ -134,7 +133,31 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def self.add_destroy_callbacks(model, reflection)
       name = reflection.name
-      model.before_destroy lambda { |o| o.association(name).handle_dependency }
+      model.before_destroy(->(o) { o.association(name).handle_dependency })
     end
+
+    def self.add_after_commit_jobs_callback(model, dependent)
+      if dependent == :destroy_async
+        mixin = model.generated_association_methods
+
+        unless mixin.method_defined?(:_after_commit_jobs)
+          model.after_commit(-> do
+            _after_commit_jobs.each do |job_class, job_arguments|
+              job_class.perform_later(**job_arguments)
+            end
+          end)
+
+          mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def _after_commit_jobs
+              @_after_commit_jobs ||= []
+            end
+          CODE
+        end
+      end
+    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, :add_after_commit_jobs_callback
   end
 end

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

@@ -7,11 +7,14 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      super + [:polymorphic, :touch, :counter_cache, :optional, :default]
+      valid = super + [:polymorphic, :counter_cache, :optional, :default]
+      valid += [:foreign_type] if options[:polymorphic]
+      valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
+      valid
     end
 
     def self.valid_dependent_options
-      [:destroy, :delete]
+      [:destroy, :delete, :destroy_async]
     end
 
     def self.define_callbacks(model, reflection)
@@ -21,58 +24,16 @@ module ActiveRecord::Associations::Builder # :nodoc:
       add_default_callbacks(model, reflection)       if reflection.options[:default]
     end
 
-    def self.define_accessors(mixin, reflection)
-      super
-      add_counter_cache_methods mixin
-    end
-
-    def self.add_counter_cache_methods(mixin)
-      return if mixin.method_defined? :belongs_to_counter_cache_after_update
-
-      mixin.class_eval do
-        def belongs_to_counter_cache_after_update(reflection)
-          foreign_key  = reflection.foreign_key
-          cache_column = reflection.counter_cache_column
-
-          if (@_after_replace_counter_called ||= false)
-            @_after_replace_counter_called = false
-          elsif association(reflection.name).target_changed?
-            if reflection.polymorphic?
-              model     = attribute_in_database(reflection.foreign_type).try(:constantize)
-              model_was = attribute_before_last_save(reflection.foreign_type).try(:constantize)
-            else
-              model     = reflection.klass
-              model_was = reflection.klass
-            end
-
-            foreign_key_was = attribute_before_last_save foreign_key
-            foreign_key     = attribute_in_database foreign_key
-
-            if foreign_key && model.respond_to?(:increment_counter)
-              foreign_key = counter_cache_target(reflection, model, foreign_key)
-              model.increment_counter(cache_column, foreign_key)
-            end
-
-            if foreign_key_was && model_was.respond_to?(:decrement_counter)
-              foreign_key_was = counter_cache_target(reflection, model_was, foreign_key_was)
-              model_was.decrement_counter(cache_column, foreign_key_was)
-            end
-          end
-        end
-
-        private
-          def counter_cache_target(reflection, model, foreign_key)
-            primary_key = reflection.association_primary_key(model)
-            model.unscoped.where!(primary_key => foreign_key)
-          end
-      end
-    end
-
     def self.add_counter_cache_callbacks(model, reflection)
       cache_column = reflection.counter_cache_column
 
       model.after_update lambda { |record|
-        record.belongs_to_counter_cache_after_update(reflection)
+        association = association(reflection.name)
+
+        if association.target_changed?
+          association.increment_counters
+          association.decrement_counters_before_last_save
+        end
       }
 
       klass = reflection.class_name.safe_constantize
@@ -97,38 +58,44 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
         if old_record
           if touch != true
-            old_record.send(touch_method, touch)
+            old_record.public_send(touch_method, touch)
           else
-            old_record.send(touch_method)
+            old_record.public_send(touch_method)
           end
         end
       end
 
-      record = o.send name
+      record = o.public_send name
       if record && record.persisted?
         if touch != true
-          record.send(touch_method, touch)
+          record.public_send(touch_method, touch)
         else
-          record.send(touch_method)
+          record.public_send(touch_method)
         end
       end
     end
 
     def self.add_touch_callbacks(model, reflection)
       foreign_key = reflection.foreign_key
-      n           = reflection.name
+      name        = reflection.name
       touch       = reflection.options[:touch]
 
       callback = lambda { |changes_method| lambda { |record|
-        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, n, touch, belongs_to_touch_method)
+        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, name, touch, belongs_to_touch_method)
       }}
 
-      unless reflection.counter_cache_column
+      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?
+        }
+        model.after_update update_callback, if: :saved_changes?
+      else
         model.after_create callback.(:saved_changes), if: :saved_changes?
+        model.after_update callback.(:saved_changes), if: :saved_changes?
         model.after_destroy callback.(:changes_to_save)
       end
 
-      model.after_update callback.(:saved_changes), if: :saved_changes?
       model.after_touch callback.(:changes_to_save)
     end
 
@@ -159,5 +126,8 @@ module ActiveRecord::Associations::Builder # :nodoc:
         model.validates_presence_of reflection.name, message: :required
       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
   end
 end

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

@@ -7,8 +7,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
     CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
 
     def self.valid_options(options)
-      super + [:table_name, :before_add,
-               :after_add, :before_remove, :after_remove, :extend]
+      super + [:before_add, :after_add, :before_remove, :after_remove, :extend]
     end
 
     def self.define_callbacks(model, reflection)
@@ -22,17 +21,19 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def self.define_extensions(model, name, &block)
       if block_given?
-        extension_module_name = "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
+        extension_module_name = "#{name.to_s.camelize}AssociationExtension"
         extension = Module.new(&block)
-        model.parent.const_set(extension_module_name, extension)
+        model.const_set(extension_module_name, extension)
       end
     end
 
     def self.define_callback(model, callback_name, name, options)
       full_callback_name = "#{callback_name}_for_#{name}"
 
-      # TODO : why do i need method_defined? I think its because of the inheritance chain
-      model.class_attribute full_callback_name unless model.method_defined?(full_callback_name)
+      unless model.method_defined?(full_callback_name)
+        model.class_attribute(full_callback_name, instance_accessor: false, instance_predicate: false)
+      end
+
       callbacks = Array(options[callback_name.to_sym]).map do |callback|
         case callback
         when Symbol
@@ -67,16 +68,6 @@ module ActiveRecord::Associations::Builder # :nodoc:
       CODE
     end
 
-    def self.wrap_scope(scope, mod)
-      if scope
-        if scope.arity > 0
-          proc { |owner| instance_exec(owner, &scope).extending(mod) }
-        else
-          proc { instance_exec(&scope).extending(mod) }
-        end
-      else
-        proc { extending(mod) }
-      end
-    end
+    private_class_method :valid_options, :define_callback, :define_extensions, :define_readers, :define_writers
   end
 end

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

@@ -2,39 +2,6 @@
 
 module ActiveRecord::Associations::Builder # :nodoc:
   class HasAndBelongsToMany # :nodoc:
-    class JoinTableResolver # :nodoc:
-      KnownTable = Struct.new :join_table
-
-      class KnownClass # :nodoc:
-        def initialize(lhs_class, rhs_class_name)
-          @lhs_class      = lhs_class
-          @rhs_class_name = rhs_class_name
-          @join_table     = nil
-        end
-
-        def join_table
-          @join_table ||= [@lhs_class.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
-        end
-
-        private
-
-          def klass
-            @lhs_class.send(:compute_type, @rhs_class_name)
-          end
-      end
-
-      def self.build(lhs_class, name, options)
-        if options[:join_table]
-          KnownTable.new options[:join_table].to_s
-        else
-          class_name = options.fetch(:class_name) {
-            name.to_s.camelize.singularize
-          }
-          KnownClass.new lhs_class, class_name.to_s
-        end
-      end
-    end
-
     attr_reader :lhs_model, :association_name, :options
 
     def initialize(association_name, lhs_model, options)
@@ -44,8 +11,6 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def through_model
-      habtm = JoinTableResolver.build lhs_model, association_name, options
-
       join_model = Class.new(ActiveRecord::Base) {
         class << self
           attr_accessor :left_model
@@ -56,7 +21,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
         end
 
         def self.table_name
-          table_name_resolver.join_table
+          # Table name needs to be resolved lazily
+          # because RHS class might not have been loaded
+          @table_name ||= table_name_resolver.call
         end
 
         def self.compute_type(class_name)
@@ -79,14 +46,13 @@ module ActiveRecord::Associations::Builder # :nodoc:
         end
 
         private
-
           def self.suppress_composite_primary_key(pk)
             pk unless pk.is_a?(Array)
           end
       }
 
       join_model.name                = "HABTM_#{association_name.to_s.camelize}"
-      join_model.table_name_resolver = habtm
+      join_model.table_name_resolver = -> { table_name }
       join_model.left_model          = lhs_model
 
       join_model.add_left_association :left_side, anonymous_class: lhs_model
@@ -96,7 +62,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def middle_reflection(join_model)
       middle_name = [lhs_model.name.downcase.pluralize,
-                     association_name].join("_".freeze).gsub("::".freeze, "_".freeze).to_sym
+                     association_name.to_s].sort.join("_").gsub("::", "_").to_sym
       middle_options = middle_options join_model
 
       HasMany.create_reflection(lhs_model,
@@ -106,17 +72,27 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     private
-
       def middle_options(join_model)
         middle_options = {}
         middle_options[:class_name] = "#{lhs_model.name}::#{join_model.name}"
-        middle_options[:source] = join_model.left_reflection.name
         if options.key? :foreign_key
           middle_options[:foreign_key] = options[:foreign_key]
         end
         middle_options
       end
 
+      def table_name
+        if options[:join_table]
+          options[:join_table].to_s
+        else
+          class_name = options.fetch(:class_name) {
+            association_name.to_s.camelize.singularize
+          }
+          klass = lhs_model.send(:compute_type, class_name.to_s)
+          [lhs_model.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
+        end
+      end
+
       def belongs_to_options(options)
         rhs_options = {}
 

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

@@ -7,11 +7,17 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      super + [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :counter_cache, :join_table, :foreign_type, :index_errors]
+      valid = super + [:counter_cache, :join_table, :index_errors, :ensuring_owner_was]
+      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
     end
 
     def self.valid_dependent_options
-      [:destroy, :delete_all, :nullify, :restrict_with_error, :restrict_with_exception]
+      [:destroy, :delete_all, :nullify, :restrict_with_error, :restrict_with_exception, :destroy_async]
     end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options
   end
 end

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

@@ -7,13 +7,20 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      valid = super + [:as]
+      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)
+      super
+      add_touch_callbacks(model, reflection) if reflection.options[:touch]
     end
 
     def self.add_destroy_callbacks(model, reflection)
@@ -26,5 +33,29 @@ module ActiveRecord::Associations::Builder # :nodoc:
         model.validates_presence_of reflection.name, message: :required
       end
     end
+
+    def self.touch_record(record, name, touch)
+      instance = record.send(name)
+
+      if instance&.persisted?
+        touch != true ?
+          instance.touch(touch) : instance.touch
+      end
+    end
+
+    def self.add_touch_callbacks(model, reflection)
+      name  = reflection.name
+      touch = reflection.options[: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
+    end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options, :add_destroy_callbacks,
+      :define_callbacks, :define_validations, :add_touch_callbacks
   end
 end