Merge branch 'master' into habtm

* master:
  we can define callbacks without a builder instance
  push methods that don't depend on the instance to the class
  get the name from the reflection
  cache the name and options on the stack
  decouple belongs_to callback definition from the builder instance.
  add_before_destroy_callbacks doesn't depend on the instance, so push it to the class.
  valid_options doesn't depend on the instance, so push it to the class
  use the information on the reflection to determine whether callbacks should be added
  Running all isolated test for actionview
  association builder is no longer needed for counter cache, so remove it
  push constructable? on to the reflection
  Adds the Rails maintenance policy to the Guides
  name is on the reflection, so just use the reflection
  decouple define_callback from the instance
  Added activemodel as a explicit dependency
  unify `Fixes` notes in AR changelog. [ci skip].
  improving `reload` doc wording. #12418 [ci skip]
  Update AR reload doc for the case of manually set primary key attribute [ci skip]

1 files changed, 18 insertions, 23 deletions

diff --git a/activerecord/lib/active_record/associations/builder/belongs_to.rb b/activerecord/lib/active_record/associations/builder/belongs_to.rb
index 4e88b50ec5..9d55ec850e 100644
--- a/activerecord/lib/active_record/associations/builder/belongs_to.rb
+++ b/activerecord/lib/active_record/associations/builder/belongs_to.rb
@@ -8,21 +8,17 @@ module ActiveRecord::Associations::Builder
       super + [:foreign_type, :polymorphic, :touch]
     end
 
-    def constructable?
-      !options[:polymorphic]
-    end
-
-    def valid_dependent_options
+    def self.valid_dependent_options
       [:destroy, :delete]
     end
 
-    def define_callbacks(model, reflection)
+    def self.define_callbacks(model, reflection)
       super
-      add_counter_cache_callbacks(model, reflection) if options[:counter_cache]
-      add_touch_callbacks(model, reflection)         if options[:touch]
+      add_counter_cache_callbacks(model, reflection) if reflection.options[:counter_cache]
+      add_touch_callbacks(model, reflection)         if reflection.options[:touch]
     end
 
-    def define_accessors(mixin)
+    def define_accessors(mixin, reflection)
       super
       add_counter_cache_methods mixin
     end
@@ -33,18 +29,18 @@ module ActiveRecord::Associations::Builder
       return if mixin.method_defined? :belongs_to_counter_cache_after_create
 
       mixin.class_eval do
-        def belongs_to_counter_cache_after_create(association, reflection)
-          if record = send(association.name)
+        def belongs_to_counter_cache_after_create(reflection)
+          if record = send(reflection.name)
             cache_column = reflection.counter_cache_column
             record.class.increment_counter(cache_column, record.id)
             @_after_create_counter_called = true
           end
         end
 
-        def belongs_to_counter_cache_before_destroy(association, reflection)
+        def belongs_to_counter_cache_before_destroy(reflection)
           foreign_key = reflection.foreign_key.to_sym
           unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == foreign_key
-            record = send association.name
+            record = send reflection.name
             if record && !self.destroyed?
               cache_column = reflection.counter_cache_column
               record.class.decrement_counter(cache_column, record.id)
@@ -52,13 +48,13 @@ module ActiveRecord::Associations::Builder
           end
         end
 
-        def belongs_to_counter_cache_after_update(association, reflection)
+        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? && association.constructable?
+          elsif attribute_changed?(foreign_key) && !new_record? && reflection.constructable?
             model           = reflection.klass
             foreign_key_was = attribute_was foreign_key
             foreign_key     = attribute foreign_key
@@ -74,20 +70,19 @@ module ActiveRecord::Associations::Builder
       end
     end
 
-    def add_counter_cache_callbacks(model, reflection)
+    def self.add_counter_cache_callbacks(model, reflection)
       cache_column = reflection.counter_cache_column
-      association = self
 
       model.after_create lambda { |record|
-        record.belongs_to_counter_cache_after_create(association, reflection)
+        record.belongs_to_counter_cache_after_create(reflection)
       }
 
       model.before_destroy lambda { |record|
-        record.belongs_to_counter_cache_before_destroy(association, reflection)
+        record.belongs_to_counter_cache_before_destroy(reflection)
       }
 
       model.after_update lambda { |record|
-        record.belongs_to_counter_cache_after_update(association, reflection)
+        record.belongs_to_counter_cache_after_update(reflection)
       }
 
       klass = reflection.class_name.safe_constantize
@@ -120,10 +115,10 @@ module ActiveRecord::Associations::Builder
       end
     end
 
-    def add_touch_callbacks(model, reflection)
+    def self.add_touch_callbacks(model, reflection)
       foreign_key = reflection.foreign_key
-      n           = name
-      touch       = options[:touch]
+      n           = reflection.name
+      touch       = reflection.options[:touch]
 
       callback = lambda { |record|
         BelongsTo.touch_record(record, foreign_key, n, touch)