1 files changed, 34 insertions, 55 deletions
diff --git a/activerecord/lib/active_record/associations/builder/belongs_to.rb b/activerecord/lib/active_record/associations/builder/belongs_to.rb
index 4183c222de..2f2600b7fb 100644
--- a/activerecord/lib/active_record/associations/builder/belongs_to.rb
+++ b/activerecord/lib/active_record/associations/builder/belongs_to.rb
@@ -1,10 +1,12 @@
-require 'active_support/core_ext/object/inclusion'
-
 module ActiveRecord::Associations::Builder
   class BelongsTo < SingularAssociation #:nodoc:
-    self.macro = :belongs_to
+    def macro
+      :belongs_to
+    end
 
-    self.valid_options += [:foreign_type, :polymorphic, :touch]
+    def valid_options
+      super + [:foreign_type, :polymorphic, :touch]
+    end
 
     def constructable?
       !options[:polymorphic]
@@ -14,74 +16,51 @@ module ActiveRecord::Associations::Builder
       reflection = super
       add_counter_cache_callbacks(reflection) if options[:counter_cache]
       add_touch_callbacks(reflection)         if options[:touch]
-      configure_dependency
       reflection
     end
 
-    private
+    def add_counter_cache_callbacks(reflection)
+      cache_column = reflection.counter_cache_column
 
-      def add_counter_cache_callbacks(reflection)
-        cache_column = reflection.counter_cache_column
-        name         = self.name
-
-        method_name = "belongs_to_counter_cache_after_create_for_#{name}"
-        mixin.redefine_method(method_name) do
-          record = send(name)
-          record.class.increment_counter(cache_column, record.id) unless record.nil?
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def belongs_to_counter_cache_after_create_for_#{name}
+          record = #{name}
+          record.class.increment_counter(:#{cache_column}, record.id) unless record.nil?
         end
-        model.after_create(method_name)
 
-        method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
-        mixin.redefine_method(method_name) do
+        def belongs_to_counter_cache_before_destroy_for_#{name}
           unless marked_for_destruction?
-            record = send(name)
-            record.class.decrement_counter(cache_column, record.id) unless record.nil?
+            record = #{name}
+            record.class.decrement_counter(:#{cache_column}, record.id) unless record.nil?
           end
         end
-        model.before_destroy(method_name)
+      CODE
 
-        model.send(:module_eval,
-          "#{reflection.class_name}.send(:attr_readonly,\"#{cache_column}\".intern) if defined?(#{reflection.class_name}) && #{reflection.class_name}.respond_to?(:attr_readonly)", __FILE__, __LINE__
-        )
-      end
+      model.after_create   "belongs_to_counter_cache_after_create_for_#{name}"
+      model.before_destroy "belongs_to_counter_cache_before_destroy_for_#{name}"
 
-      def add_touch_callbacks(reflection)
-        name        = self.name
-        method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
-        touch       = options[:touch]
+      klass = reflection.class_name.safe_constantize
+      klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
+    end
 
-        mixin.redefine_method(method_name) do
-          record = send(name)
+    def add_touch_callbacks(reflection)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def belongs_to_touch_after_save_or_destroy_for_#{name}
+          record = #{name}
 
           unless record.nil?
-            if touch == true
-              record.touch
-            else
-              record.touch(touch)
-            end
+            record.touch #{options[:touch].inspect if options[:touch] != true}
           end
         end
+      CODE
 
-        model.after_save(method_name)
-        model.after_touch(method_name)
-        model.after_destroy(method_name)
-      end
-
-      def configure_dependency
-        if options[:dependent]
-          unless options[:dependent].in?([:destroy, :delete])
-            raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{options[:dependent].inspect})"
-          end
+      model.after_save    "belongs_to_touch_after_save_or_destroy_for_#{name}"
+      model.after_touch   "belongs_to_touch_after_save_or_destroy_for_#{name}"
+      model.after_destroy "belongs_to_touch_after_save_or_destroy_for_#{name}"
+    end
 
-          method_name = "belongs_to_dependent_#{options[:dependent]}_for_#{name}"
-          model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
-            def #{method_name}
-              association = #{name}
-              association.#{options[:dependent]} if association
-            end
-          eoruby
-          model.after_destroy method_name
-        end
-      end
+    def valid_dependent_options
+      [:destroy, :delete]
+    end
   end
 end