activerecord 4.2.0 → 5.0.0

data/lib/active_record/associations/belongs_to_association.rb

@@ -10,7 +10,7 @@ module ActiveRecord
       def replace(record)
         if record
           raise_on_type_mismatch!(record)
-          update_counters(record)
+          update_counters_on_replace(record)
           replace_keys(record)
           set_inverse_instance(record)
           @updated = true
@@ -32,52 +32,48 @@ module ActiveRecord
       end
 
       def decrement_counters # :nodoc:
-        with_cache_name { |name| decrement_counter name }
+        update_counters(-1)
       end
 
       def increment_counters # :nodoc:
-        with_cache_name { |name| increment_counter name }
+        update_counters(1)
       end
 
       private
 
-        def find_target?
-          !loaded? && foreign_key_present? && klass
-        end
-
-        def with_cache_name
-          counter_cache_name = reflection.counter_cache_column
-          return unless counter_cache_name && owner.persisted?
-          yield counter_cache_name
+        def update_counters(by)
+          if require_counter_update? && foreign_key_present?
+            if target && !stale_target?
+              target.increment!(reflection.counter_cache_column, by)
+            else
+              klass.update_counters(target_id, reflection.counter_cache_column => by)
+            end
+          end
         end
 
-        def update_counters(record)
-          with_cache_name do |name|
-            return unless different_target? record
-            record.class.increment_counter(name, record.id)
-            decrement_counter name
-          end
+        def find_target?
+          !loaded? && foreign_key_present? && klass
         end
 
-        def decrement_counter(counter_cache_name)
-          if foreign_key_present?
-            klass.decrement_counter(counter_cache_name, target_id)
-          end
+        def require_counter_update?
+          reflection.counter_cache_column && owner.persisted?
         end
 
-        def increment_counter(counter_cache_name)
-          if foreign_key_present?
-            klass.increment_counter(counter_cache_name, target_id)
+        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)
+            decrement_counters
           end
         end
 
         # Checks whether record is different to the current target, without loading it
         def different_target?(record)
-          record.id != owner[reflection.foreign_key]
+          record.id != owner._read_attribute(reflection.foreign_key)
         end
 
         def replace_keys(record)
-          owner[reflection.foreign_key] = record[reflection.association_primary_key(record.class)]
+          owner[reflection.foreign_key] = record._read_attribute(reflection.association_primary_key(record.class))
         end
 
         def remove_keys
@@ -85,7 +81,7 @@ module ActiveRecord
         end
 
         def foreign_key_present?
-          owner[reflection.foreign_key]
+          owner._read_attribute(reflection.foreign_key)
         end
 
         # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
@@ -99,12 +95,13 @@ module ActiveRecord
           if options[:primary_key]
             owner.send(reflection.name).try(:id)
           else
-            owner[reflection.foreign_key]
+            owner._read_attribute(reflection.foreign_key)
           end
         end
 
         def stale_state
-          owner[reflection.foreign_key] && owner[reflection.foreign_key].to_s
+          result = owner._read_attribute(reflection.foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
+          result && result.to_s
         end
     end
   end

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

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/module/attribute_accessors'
-
 # This is the parent Association class which defines the variables
 # used by all associations.
 #
@@ -11,19 +9,14 @@ require 'active_support/core_ext/module/attribute_accessors'
 #    - CollectionAssociation
 #      - HasManyAssociation
 
-module ActiveRecord::Associations::Builder
+module ActiveRecord::Associations::Builder # :nodoc:
   class Association #:nodoc:
     class << self
       attr_accessor :extensions
-      # TODO: This class accessor is needed to make activerecord-deprecated_finders work.
-      # We can move it to a constant in 5.0.
-      attr_accessor :valid_options
     end
     self.extensions = []
 
-    self.valid_options = [:class_name, :class, :foreign_key, :validate]
-
-    attr_reader :name, :scope, :options
+    VALID_OPTIONS = [:class_name, :anonymous_class, :foreign_key, :validate] # :nodoc:
 
     def self.build(model, name, scope, options, &block)
       if model.dangerous_attribute_method?(name)
@@ -32,57 +25,60 @@ module ActiveRecord::Associations::Builder
                              "Please choose a different association name."
       end
 
-      builder = create_builder model, name, scope, options, &block
-      reflection = builder.build(model)
+      extension = define_extensions model, name, &block
+      reflection = create_reflection model, name, scope, options, extension
       define_accessors model, reflection
       define_callbacks model, reflection
       define_validations model, reflection
-      builder.define_extensions model
       reflection
     end
 
-    def self.create_builder(model, name, scope, options, &block)
+    def self.create_reflection(model, name, scope, options, extension = nil)
       raise ArgumentError, "association names must be a Symbol" unless name.kind_of?(Symbol)
 
-      new(model, name, scope, options, &block)
-    end
-
-    def initialize(model, name, scope, options)
-      # TODO: Move this to create_builder as soon we drop support to activerecord-deprecated_finders.
       if scope.is_a?(Hash)
         options = scope
         scope   = nil
       end
 
-      # TODO: Remove this model argument as soon we drop support to activerecord-deprecated_finders.
-      @name    = name
-      @scope   = scope
-      @options = options
+      validate_options(options)
 
-      validate_options
+      scope = build_scope(scope, extension)
+
+      ActiveRecord::Reflection.create(macro, name, scope, options, model)
+    end
+
+    def self.build_scope(scope, extension)
+      new_scope = scope
 
       if scope && scope.arity == 0
-        @scope = proc { instance_exec(&scope) }
+        new_scope = proc { instance_exec(&scope) }
+      end
+
+      if extension
+        new_scope = wrap_scope new_scope, extension
       end
+
+      new_scope
     end
 
-    def build(model)
-      ActiveRecord::Reflection.create(macro, name, scope, options, model)
+    def self.wrap_scope(scope, extension)
+      scope
     end
 
-    def macro
+    def self.macro
       raise NotImplementedError
     end
 
-    def valid_options
-      Association.valid_options + Association.extensions.flat_map(&:valid_options)
+    def self.valid_options(options)
+      VALID_OPTIONS + Association.extensions.flat_map(&:valid_options)
     end
 
-    def validate_options
-      options.assert_valid_keys(valid_options)
+    def self.validate_options(options)
+      options.assert_valid_keys(valid_options(options))
     end
 
-    def define_extensions(model)
+    def self.define_extensions(model, name)
     end
 
     def self.define_callbacks(model, reflection)
@@ -133,8 +129,6 @@ module ActiveRecord::Associations::Builder
       raise NotImplementedError
     end
 
-    private
-
     def self.check_dependent_options(dependent)
       unless valid_dependent_options.include? dependent
         raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{dependent}"

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

@@ -1,11 +1,11 @@
-module ActiveRecord::Associations::Builder
+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]
     end
 
     def self.valid_dependent_options
@@ -23,8 +23,6 @@ module ActiveRecord::Associations::Builder
       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
 
@@ -35,16 +33,26 @@ module ActiveRecord::Associations::Builder
 
           if (@_after_create_counter_called ||= false)
             @_after_create_counter_called = false
-          elsif attribute_changed?(foreign_key) && !new_record? && reflection.constructable?
-            model           = reflection.klass
+          elsif (@_after_replace_counter_called ||= false)
+            @_after_replace_counter_called = false
+          elsif attribute_changed?(foreign_key) && !new_record?
+            if reflection.polymorphic?
+              model     = attribute(reflection.foreign_type).try(:constantize)
+              model_was = attribute_was(reflection.foreign_type).try(:constantize)
+            else
+              model     = reflection.klass
+              model_was = reflection.klass
+            end
+
             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)
+
+            if foreign_key_was && model_was.respond_to?(:decrement_counter)
+              model_was.decrement_counter(cache_column, foreign_key_was)
             end
           end
         end
@@ -62,7 +70,7 @@ module ActiveRecord::Associations::Builder
       klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
     end
 
-    def self.touch_record(o, foreign_key, name, touch) # :nodoc:
+    def self.touch_record(o, foreign_key, name, touch, touch_method) # :nodoc:
       old_foreign_id = o.changed_attributes[foreign_key]
 
       if old_foreign_id
@@ -77,9 +85,9 @@ module ActiveRecord::Associations::Builder
 
         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,9 +95,9 @@ 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
@@ -100,7 +108,7 @@ module ActiveRecord::Associations::Builder
       touch       = reflection.options[:touch]
 
       callback = lambda { |record|
-        BelongsTo.touch_record(record, foreign_key, n, touch)
+        BelongsTo.touch_record(record, foreign_key, n, touch, belongs_to_touch_method)
       }
 
       model.after_save    callback, if: :changed?
@@ -109,8 +117,25 @@ module ActiveRecord::Associations::Builder
     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
   end
 end

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

@@ -2,27 +2,16 @@
 
 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 +21,11 @@ module ActiveRecord::Associations::Builder
       }
     end
 
-    def define_extensions(model)
-      if @mod
+    def self.define_extensions(model, name)
+      if block_given?
         extension_module_name = "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
-        model.parent.const_set(extension_module_name, @mod)
+        extension = Module.new(&Proc.new)
+        model.parent.const_set(extension_module_name, extension)
       end
     end
 
@@ -78,11 +68,13 @@ module ActiveRecord::Associations::Builder
       CODE
     end
 
-    private
-
-    def wrap_scope(scope, mod)
+    def self.wrap_scope(scope, mod)
       if scope
-        proc { |owner| instance_exec(owner, &scope).extending(mod) }
+        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

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

@@ -1,9 +1,9 @@
-module ActiveRecord::Associations::Builder
+module ActiveRecord::Associations::Builder # :nodoc:
   class HasAndBelongsToMany # :nodoc:
-    class JoinTableResolver
+    class JoinTableResolver # :nodoc:
       KnownTable = Struct.new :join_table
 
-      class KnownClass
+      class KnownClass # :nodoc:
         def initialize(lhs_class, rhs_class_name)
           @lhs_class      = lhs_class
           @rhs_class_name = rhs_class_name
@@ -46,7 +46,7 @@ module ActiveRecord::Associations::Builder
 
       join_model = Class.new(ActiveRecord::Base) {
         class << self;
-          attr_accessor :class_resolver
+          attr_accessor :left_model
           attr_accessor :name
           attr_accessor :table_name_resolver
           attr_accessor :left_reflection
@@ -58,40 +58,47 @@ module ActiveRecord::Associations::Builder
         end
 
         def self.compute_type(class_name)
-          class_resolver.compute_type class_name
+          left_model.compute_type class_name
         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
 
+        def self.retrieve_connection
+          left_model.retrieve_connection
+        end
+
+        def self.primary_key
+          false
+        end
       }
 
       join_model.name                = "HABTM_#{association_name.to_s.camelize}"
       join_model.table_name_resolver = habtm
-      join_model.class_resolver      = lhs_model
+      join_model.left_model          = lhs_model
 
-      join_model.add_left_association :left_side, class: lhs_model
+      join_model.add_left_association :left_side, anonymous_class: lhs_model
       join_model.add_right_association association_name, belongs_to_options(options)
       join_model
     end
 
     def middle_reflection(join_model)
       middle_name = [lhs_model.name.downcase.pluralize,
-                     association_name].join('_').gsub(/::/, '_').to_sym
+                     association_name].join('_'.freeze).gsub('::'.freeze, '_'.freeze).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

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

@@ -1,11 +1,11 @@
-module ActiveRecord::Associations::Builder
+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

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

@@ -1,11 +1,11 @@
-module ActiveRecord::Associations::Builder
+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]
       valid += [:through, :source, :source_type] if options[:through]
       valid
     end
@@ -14,10 +14,15 @@ module ActiveRecord::Associations::Builder
       [:destroy, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
     end
 
-    private
-
     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
   end
 end

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

@@ -1,9 +1,9 @@
 # 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)
@@ -27,12 +27,5 @@ module ActiveRecord::Associations::Builder
         end
       CODE
     end
-
-    def self.define_validations(model, reflection)
-      super
-      if reflection.options[:required]
-        model.validates_presence_of reflection.name
-      end
-    end
   end
 end