activerecord 4.2.11.1 → 6.0.3

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

@@ -1,11 +1,13 @@
-module ActiveRecord::Associations::Builder
+# frozen_string_literal: true
+
+module ActiveRecord::Associations::Builder # :nodoc:
   class BelongsTo < SingularAssociation #:nodoc:
-    def macro
+    def self.macro
       :belongs_to
     end
 
-    def valid_options
-      super + [:foreign_type, :polymorphic, :touch, :counter_cache]
+    def self.valid_options(options)
+      super + [:polymorphic, :touch, :counter_cache, :optional, :default]
     end
 
     def self.valid_dependent_options
@@ -16,70 +18,46 @@ module ActiveRecord::Associations::Builder
       super
       add_counter_cache_callbacks(model, reflection) if reflection.options[:counter_cache]
       add_touch_callbacks(model, reflection)         if reflection.options[:touch]
-    end
-
-    def self.define_accessors(mixin, reflection)
-      super
-      add_counter_cache_methods mixin
-    end
-
-    private
-
-    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_create_counter_called ||= false)
-            @_after_create_counter_called = false
-          elsif attribute_changed?(foreign_key) && !new_record? && reflection.constructable?
-            model           = reflection.klass
-            foreign_key_was = attribute_was foreign_key
-            foreign_key     = attribute foreign_key
-
-            if foreign_key && model.respond_to?(:increment_counter)
-              model.increment_counter(cache_column, foreign_key)
-            end
-            if foreign_key_was && model.respond_to?(:decrement_counter)
-              model.decrement_counter(cache_column, foreign_key_was)
-            end
-          end
-        end
-      end
+      add_default_callbacks(model, reflection)       if reflection.options[:default]
     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
       klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
     end
 
-    def self.touch_record(o, foreign_key, name, touch) # :nodoc:
-      old_foreign_id = o.changed_attributes[foreign_key]
+    def self.touch_record(o, changes, foreign_key, name, touch, touch_method) # :nodoc:
+      old_foreign_id = changes[foreign_key] && changes[foreign_key].first
 
       if old_foreign_id
         association = o.association(name)
         reflection = association.reflection
         if reflection.polymorphic?
-          klass = o.public_send("#{reflection.foreign_type}_was").constantize
+          foreign_type = reflection.foreign_type
+          klass = changes[foreign_type] && changes[foreign_type].first || o.public_send(foreign_type)
+          klass = klass.constantize
         else
           klass = association.klass
         end
-        old_record = klass.find_by(klass.primary_key => old_foreign_id)
+        primary_key = reflection.association_primary_key(klass)
+        old_record = klass.find_by(primary_key => old_foreign_id)
 
         if old_record
           if touch != true
-            old_record.touch touch
+            old_record.send(touch_method, touch)
           else
-            old_record.touch
+            old_record.send(touch_method)
           end
         end
       end
@@ -87,30 +65,66 @@ module ActiveRecord::Associations::Builder
       record = o.send name
       if record && record.persisted?
         if touch != true
-          record.touch touch
+          record.send(touch_method, touch)
         else
-          record.touch
+          record.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 { |record|
-        BelongsTo.touch_record(record, foreign_key, n, touch)
-      }
+      callback = lambda { |changes_method| lambda { |record|
+        BelongsTo.touch_record(record, record.send(changes_method), foreign_key, name, touch, belongs_to_touch_method)
+      }}
+
+      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_save    callback, if: :changed?
-      model.after_touch   callback
-      model.after_destroy callback
+      model.after_touch callback.(:changes_to_save)
+    end
+
+    def self.add_default_callbacks(model, reflection)
+      model.before_validation lambda { |o|
+        o.association(reflection.name).default(&reflection.options[:default])
+      }
     end
 
     def self.add_destroy_callbacks(model, reflection)
-      name = reflection.name
-      model.after_destroy lambda { |o| o.association(name).handle_dependency }
+      model.after_destroy lambda { |o| o.association(reflection.name).handle_dependency }
     end
+
+    def self.define_validations(model, reflection)
+      if reflection.options.key?(:required)
+        reflection.options[:optional] = !reflection.options.delete(:required)
+      end
+
+      if reflection.options[:optional].nil?
+        required = model.belongs_to_required_by_default
+      else
+        required = !reflection.options[:optional]
+      end
+
+      super
+
+      if required
+        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

@@ -1,28 +1,16 @@
-# This class is inherited by the has_many and has_many_and_belongs_to_many association classes
+# frozen_string_literal: true
 
-require 'active_record/associations'
+require "active_record/associations"
 
-module ActiveRecord::Associations::Builder
+module ActiveRecord::Associations::Builder # :nodoc:
   class CollectionAssociation < Association #:nodoc:
-
     CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
 
-    def valid_options
+    def self.valid_options(options)
       super + [:table_name, :before_add,
                :after_add, :before_remove, :after_remove, :extend]
     end
 
-    attr_reader :block_extension
-
-    def initialize(model, name, scope, options)
-      super
-      @mod = nil
-      if block_given?
-        @mod = Module.new(&Proc.new)
-        @scope = wrap_scope @scope, @mod
-      end
-    end
-
     def self.define_callbacks(model, reflection)
       super
       name    = reflection.name
@@ -32,10 +20,11 @@ module ActiveRecord::Associations::Builder
       }
     end
 
-    def define_extensions(model)
-      if @mod
-        extension_module_name = "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
-        model.parent.const_set(extension_module_name, @mod)
+    def self.define_extensions(model, name, &block)
+      if block_given?
+        extension_module_name = "#{name.to_s.camelize}AssociationExtension"
+        extension = Module.new(&block)
+        model.const_set(extension_module_name, extension)
       end
     end
 
@@ -78,18 +67,6 @@ module ActiveRecord::Associations::Builder
       CODE
     end
 
-    private
-
-    def 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

@@ -1,38 +1,7 @@
-module ActiveRecord::Associations::Builder
-  class HasAndBelongsToMany # :nodoc:
-    class JoinTableResolver
-      KnownTable = Struct.new :join_table
-
-      class KnownClass
-        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
-        end
-      end
-    end
+# frozen_string_literal: true
 
+module ActiveRecord::Associations::Builder # :nodoc:
+  class HasAndBelongsToMany # :nodoc:
     attr_reader :lhs_model, :association_name, :options
 
     def initialize(association_name, lhs_model, options)
@@ -42,10 +11,8 @@ module ActiveRecord::Associations::Builder
     end
 
     def through_model
-      habtm = JoinTableResolver.build lhs_model, association_name, options
-
       join_model = Class.new(ActiveRecord::Base) {
-        class << self;
+        class << self
           attr_accessor :left_model
           attr_accessor :name
           attr_accessor :table_name_resolver
@@ -54,7 +21,9 @@ module ActiveRecord::Associations::Builder
         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)
@@ -62,13 +31,13 @@ module ActiveRecord::Associations::Builder
         end
 
         def self.add_left_association(name, options)
-          belongs_to name, options
+          belongs_to name, required: false, **options
           self.left_reflection = _reflect_on_association(name)
         end
 
         def self.add_right_association(name, options)
           rhs_name = name.to_s.singularize.to_sym
-          belongs_to rhs_name, options
+          belongs_to rhs_name, required: false, **options
           self.right_reflection = _reflect_on_association(rhs_name)
         end
 
@@ -76,10 +45,14 @@ module ActiveRecord::Associations::Builder
           left_model.retrieve_connection
         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
@@ -89,40 +62,51 @@ module ActiveRecord::Associations::Builder
 
     def middle_reflection(join_model)
       middle_name = [lhs_model.name.downcase.pluralize,
-                     association_name].join('_').gsub(/::/, '_').to_sym
+                     association_name.to_s].sort.join("_").gsub("::", "_").to_sym
       middle_options = middle_options join_model
-      hm_builder = HasMany.create_builder(lhs_model,
-                                          middle_name,
-                                          nil,
-                                          middle_options)
-      hm_builder.build lhs_model
+
+      HasMany.create_reflection(lhs_model,
+                                middle_name,
+                                nil,
+                                middle_options)
     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 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]
+      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
-      middle_options
-    end
 
-    def belongs_to_options(options)
-      rhs_options = {}
+      def belongs_to_options(options)
+        rhs_options = {}
 
-      if options.key? :class_name
-        rhs_options[:foreign_key] = options[:class_name].to_s.foreign_key
-        rhs_options[:class_name] = options[:class_name]
-      end
+        if options.key? :class_name
+          rhs_options[:foreign_key] = options[:class_name].to_s.foreign_key
+          rhs_options[:class_name] = options[:class_name]
+        end
 
-      if options.key? :association_foreign_key
-        rhs_options[:foreign_key] = options[:association_foreign_key]
-      end
+        if options.key? :association_foreign_key
+          rhs_options[:foreign_key] = options[:association_foreign_key]
+        end
 
-      rhs_options
-    end
+        rhs_options
+      end
   end
 end

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

@@ -1,15 +1,19 @@
-module ActiveRecord::Associations::Builder
+# frozen_string_literal: true
+
+module ActiveRecord::Associations::Builder # :nodoc:
   class HasMany < CollectionAssociation #:nodoc:
-    def macro
+    def self.macro
       :has_many
     end
 
-    def valid_options
-      super + [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :counter_cache, :join_table, :foreign_type]
+    def self.valid_options(options)
+      super + [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :counter_cache, :join_table, :foreign_type, :index_errors]
     end
 
     def self.valid_dependent_options
       [:destroy, :delete_all, :nullify, :restrict_with_error, :restrict_with_exception]
     end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options
   end
 end

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

@@ -1,11 +1,13 @@
-module ActiveRecord::Associations::Builder
+# frozen_string_literal: true
+
+module ActiveRecord::Associations::Builder # :nodoc:
   class HasOne < SingularAssociation #:nodoc:
-    def macro
+    def self.macro
       :has_one
     end
 
-    def valid_options
-      valid = super + [:as, :foreign_type]
+    def self.valid_options(options)
+      valid = super + [:as, :touch]
       valid += [:through, :source, :source_type] if options[:through]
       valid
     end
@@ -14,10 +16,49 @@ module ActiveRecord::Associations::Builder
       [:destroy, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
     end
 
-    private
+    def self.define_callbacks(model, reflection)
+      super
+      add_touch_callbacks(model, reflection) if reflection.options[:touch]
+    end
 
     def self.add_destroy_callbacks(model, reflection)
       super unless reflection.options[:through]
     end
+
+    def self.define_validations(model, reflection)
+      super
+      if reflection.options[:required]
+        model.validates_presence_of reflection.name, message: :required
+      end
+    end
+
+    def self.touch_record(o, name, touch)
+      record = o.send name
+
+      return unless record && record.persisted?
+
+      if touch != true
+        record.touch(touch)
+      else
+        record.touch
+      end
+    end
+
+    def self.add_touch_callbacks(model, reflection)
+      name  = reflection.name
+      touch = reflection.options[:touch]
+
+      callback = lambda { |record|
+        HasOne.touch_record(record, name, touch)
+      }
+
+      model.after_create callback, if: :saved_changes?
+      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

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

@@ -1,14 +1,25 @@
+# frozen_string_literal: true
+
 # This class is inherited by the has_one and belongs_to association classes
 
-module ActiveRecord::Associations::Builder
+module ActiveRecord::Associations::Builder # :nodoc:
   class SingularAssociation < Association #:nodoc:
-    def valid_options
-      super + [:dependent, :primary_key, :inverse_of, :required]
+    def self.valid_options(options)
+      super + [:foreign_type, :dependent, :primary_key, :inverse_of, :required]
     end
 
     def self.define_accessors(model, reflection)
       super
-      define_constructors(model.generated_association_methods, reflection.name) if reflection.constructable?
+      mixin = model.generated_association_methods
+      name = reflection.name
+
+      define_constructors(mixin, name) if reflection.constructable?
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def reload_#{name}
+          association(:#{name}).force_reload_reader
+        end
+      CODE
     end
 
     # Defines the (build|create)_association methods for belongs_to or has_one association
@@ -28,11 +39,6 @@ module ActiveRecord::Associations::Builder
       CODE
     end
 
-    def self.define_validations(model, reflection)
-      super
-      if reflection.options[:required]
-        model.validates_presence_of reflection.name
-      end
-    end
+    private_class_method :valid_options, :define_accessors, :define_constructors
   end
 end