Use DependencyModule for included hooks in ActiveRecord

activerecord/lib/active_record/aggregations.rb

 module ActiveRecord
   module Aggregations # :nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::DependencyModule
 
     def clear_aggregation_cache #:nodoc:
       self.class.reflect_on_all_aggregations.to_a.each do |assoc|

activerecord/lib/active_record/association_preload.rb

 module ActiveRecord
   # See ActiveRecord::AssociationPreload::ClassMethods for documentation.
   module AssociationPreload #:nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::DependencyModule
 
     # Implements the details of eager loading of ActiveRecord associations.
     # Application developers should not use this module directly.

activerecord/lib/active_record/associations.rb

@@ -77,6 +77,8 @@ def initialize(reflection)
 
   # See ActiveRecord::Associations::ClassMethods for documentation.
   module Associations # :nodoc:
+    extend ActiveSupport::DependencyModule
+
     # These classes will be loaded when associations are created.
     # So there is no need to eager load them.
     autoload :AssociationCollection, 'active_record/associations/association_collection'
@@ -89,10 +91,6 @@ module Associations # :nodoc:
     autoload :HasOneAssociation, 'active_record/associations/has_one_association'
     autoload :HasOneThroughAssociation, 'active_record/associations/has_one_through_association'
 
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
     # Clears out the association cache
     def clear_association_cache #:nodoc:
       self.class.reflect_on_all_associations.to_a.each do |assoc|

activerecord/lib/active_record/attribute_methods.rb

 module ActiveRecord
   module AttributeMethods #:nodoc:
+    extend ActiveSupport::DependencyModule
+
     DEFAULT_SUFFIXES = %w(= ? _before_type_cast)
     ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
 
-    def self.included(base)
-      base.extend ClassMethods
-      base.attribute_method_suffix(*DEFAULT_SUFFIXES)
-      base.cattr_accessor :attribute_types_cached_by_default, :instance_writer => false
-      base.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
-      base.cattr_accessor :time_zone_aware_attributes, :instance_writer => false
-      base.time_zone_aware_attributes = false
-      base.class_inheritable_accessor :skip_time_zone_conversion_for_attributes, :instance_writer => false
-      base.skip_time_zone_conversion_for_attributes = []
+    included do
+      attribute_method_suffix(*DEFAULT_SUFFIXES)
+
+      cattr_accessor :attribute_types_cached_by_default, :instance_writer => false
+      self.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
+
+      cattr_accessor :time_zone_aware_attributes, :instance_writer => false
+      self.time_zone_aware_attributes = false
+
+      class_inheritable_accessor :skip_time_zone_conversion_for_attributes, :instance_writer => false
+      self.skip_time_zone_conversion_for_attributes = []
     end
 
     # Declare and check for suffixed attribute methods.

activerecord/lib/active_record/autosave_association.rb

@@ -125,16 +125,15 @@ module ActiveRecord
   #   post.author.name = ''
   #   post.save(false) # => true
   module AutosaveAssociation
+    extend ActiveSupport::DependencyModule
+
     ASSOCIATION_TYPES = %w{ has_one belongs_to has_many has_and_belongs_to_many }
 
-    def self.included(base)
-      base.class_eval do
-        base.extend(ClassMethods)
-        alias_method_chain :reload, :autosave_associations
+    included do
+      alias_method_chain :reload, :autosave_associations
 
-        ASSOCIATION_TYPES.each do |type|
-          base.send("valid_keys_for_#{type}_association") << :autosave
-        end
+      ASSOCIATION_TYPES.each do |type|
+        send("valid_keys_for_#{type}_association") << :autosave
       end
     end
 

activerecord/lib/active_record/batches.rb

 module ActiveRecord
   module Batches # :nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::DependencyModule
 
     # When processing large numbers of records, it's often a good idea to do
     # so in batches to prevent memory ballooning.

activerecord/lib/active_record/calculations.rb

 module ActiveRecord
   module Calculations #:nodoc:
+    extend ActiveSupport::DependencyModule
+
     CALCULATIONS_OPTIONS = [:conditions, :joins, :order, :select, :group, :having, :distinct, :limit, :offset, :include, :from]
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
 
     module ClassMethods
       # Count operates using three different approaches.

activerecord/lib/active_record/callbacks.rb

@@ -211,21 +211,23 @@ module ActiveRecord
   # needs to be aware of it because an ordinary +save+ will raise such exception
   # instead of quietly returning +false+.
   module Callbacks
+    extend ActiveSupport::DependencyModule
+
     CALLBACKS = %w(
       after_find after_initialize before_save after_save before_create after_create before_update after_update before_validation
       after_validation before_validation_on_create after_validation_on_create before_validation_on_update
       after_validation_on_update before_destroy after_destroy
     )
 
-    def self.included(base) #:nodoc:
-      base.extend Observable
+    included do
+      extend Observable
 
       [:create_or_update, :valid?, :create, :update, :destroy].each do |method|
-        base.send :alias_method_chain, method, :callbacks
+        alias_method_chain method, :callbacks
       end
 
-      base.send :include, ActiveSupport::Callbacks
-      base.define_callbacks *CALLBACKS
+      include ActiveSupport::Callbacks
+      define_callbacks *CALLBACKS
     end
 
     # Is called when the object was instantiated by one of the finders, like <tt>Base.find</tt>.

activerecord/lib/active_record/dirty.rb

@@ -34,20 +34,21 @@ module ActiveRecord
   #   person.name << 'by'
   #   person.name_change    # => ['uncle bob', 'uncle bobby']
   module Dirty
+    extend ActiveSupport::DependencyModule
+
     DIRTY_SUFFIXES = ['_changed?', '_change', '_will_change!', '_was']
 
-    def self.included(base)
-      base.attribute_method_suffix *DIRTY_SUFFIXES
-      base.alias_method_chain :write_attribute, :dirty
-      base.alias_method_chain :save,            :dirty
-      base.alias_method_chain :save!,           :dirty
-      base.alias_method_chain :update,          :dirty
-      base.alias_method_chain :reload,          :dirty
+    included do
+      attribute_method_suffix *DIRTY_SUFFIXES
 
-      base.superclass_delegating_accessor :partial_updates
-      base.partial_updates = true
+      alias_method_chain :write_attribute, :dirty
+      alias_method_chain :save,            :dirty
+      alias_method_chain :save!,           :dirty
+      alias_method_chain :update,          :dirty
+      alias_method_chain :reload,          :dirty
 
-      base.send(:extend, ClassMethods)
+      superclass_delegating_accessor :partial_updates
+      self.partial_updates = true
     end
 
     # Do any attributes have unsaved changes?

activerecord/lib/active_record/fixtures.rb

@@ -805,27 +805,25 @@ def find
 
 module ActiveRecord
   module TestFixtures
-    def self.included(base)
-      base.class_eval do
-        setup :setup_fixtures
-        teardown :teardown_fixtures
-
-        superclass_delegating_accessor :fixture_path
-        superclass_delegating_accessor :fixture_table_names
-        superclass_delegating_accessor :fixture_class_names
-        superclass_delegating_accessor :use_transactional_fixtures
-        superclass_delegating_accessor :use_instantiated_fixtures   # true, false, or :no_instances
-        superclass_delegating_accessor :pre_loaded_fixtures
-
-        self.fixture_table_names = []
-        self.use_transactional_fixtures = false
-        self.use_instantiated_fixtures = true
-        self.pre_loaded_fixtures = false
-
-        self.fixture_class_names = {}
-      end
+    extend ActiveSupport::DependencyModule
+
+    included do
+      setup :setup_fixtures
+      teardown :teardown_fixtures
+
+      superclass_delegating_accessor :fixture_path
+      superclass_delegating_accessor :fixture_table_names
+      superclass_delegating_accessor :fixture_class_names
+      superclass_delegating_accessor :use_transactional_fixtures
+      superclass_delegating_accessor :use_instantiated_fixtures   # true, false, or :no_instances
+      superclass_delegating_accessor :pre_loaded_fixtures
+
+      self.fixture_table_names = []
+      self.use_transactional_fixtures = false
+      self.use_instantiated_fixtures = true
+      self.pre_loaded_fixtures = false
 
-      base.extend ClassMethods
+      self.fixture_class_names = {}
     end
 
     module ClassMethods

activerecord/lib/active_record/locking/optimistic.rb

@@ -42,17 +42,17 @@ module Locking
     # To override the name of the lock_version column, invoke the <tt>set_locking_column</tt> method.
     # This method uses the same syntax as <tt>set_table_name</tt>
     module Optimistic
-      def self.included(base) #:nodoc:
-        base.extend ClassMethods
+      extend ActiveSupport::DependencyModule
 
-        base.cattr_accessor :lock_optimistically, :instance_writer => false
-        base.lock_optimistically = true
+      included do
+        cattr_accessor :lock_optimistically, :instance_writer => false
+        self.lock_optimistically = true
 
-        base.alias_method_chain :update, :lock
-        base.alias_method_chain :destroy, :lock
-        base.alias_method_chain :attributes_from_column_definition, :lock
+        alias_method_chain :update, :lock
+        alias_method_chain :destroy, :lock
+        alias_method_chain :attributes_from_column_definition, :lock
 
-        class << base
+        class << self
           alias_method :locking_column=, :set_locking_column
         end
       end

activerecord/lib/active_record/named_scope.rb

 module ActiveRecord
   module NamedScope
+    extend ActiveSupport::DependencyModule
+
     # All subclasses of ActiveRecord::Base have one named scope:
     # * <tt>scoped</tt> - which allows for the creation of anonymous \scopes, on the fly: <tt>Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions)</tt>
     #
@@ -7,11 +9,8 @@ module NamedScope
     # intermediate values (scopes) around as first-class objects is convenient.
     #
     # You can define a scope that applies to all finders using ActiveRecord::Base.default_scope.
-    def self.included(base)
-      base.class_eval do
-        extend ClassMethods
-        named_scope :scoped, lambda { |scope| scope }
-      end
+    included do
+      named_scope :scoped, lambda { |scope| scope }
     end
 
     module ClassMethods

activerecord/lib/active_record/nested_attributes.rb

 module ActiveRecord
   module NestedAttributes #:nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.class_inheritable_accessor :reject_new_nested_attributes_procs, :instance_writer => false
-      base.reject_new_nested_attributes_procs = {}
+    extend ActiveSupport::DependencyModule
+
+    included do
+      class_inheritable_accessor :reject_new_nested_attributes_procs, :instance_writer => false
+      self.reject_new_nested_attributes_procs = {}
     end
 
     # == Nested Attributes

activerecord/lib/active_record/observer.rb

@@ -3,9 +3,7 @@
 
 module ActiveRecord
   module Observing # :nodoc:
-    def self.included(base)
-      base.extend ClassMethods
-    end
+    extend ActiveSupport::DependencyModule
 
     module ClassMethods
       # Activates the observers assigned. Examples:

activerecord/lib/active_record/reflection.rb

 module ActiveRecord
   module Reflection # :nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::DependencyModule
 
     # Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations.
     # This information can, for example, be used in a form builder that took an Active Record object and created input

activerecord/lib/active_record/serializers/json_serializer.rb

@@ -2,9 +2,10 @@
 
 module ActiveRecord #:nodoc:
   module Serialization
-    def self.included(base)
-      base.cattr_accessor :include_root_in_json, :instance_writer => false
-      base.extend ClassMethods
+    extend ActiveSupport::DependencyModule
+
+    included do
+      cattr_accessor :include_root_in_json, :instance_writer => false
     end
 
     # Returns a JSON string representing the model. Some configuration is

activerecord/lib/active_record/timestamp.rb

@@ -8,12 +8,14 @@ module ActiveRecord
   # Timestamps are in the local timezone by default but you can use UTC by setting
   #   <tt>ActiveRecord::Base.default_timezone = :utc</tt>
   module Timestamp
-    def self.included(base) #:nodoc:
-      base.alias_method_chain :create, :timestamps
-      base.alias_method_chain :update, :timestamps
+    extend ActiveSupport::DependencyModule
 
-      base.class_inheritable_accessor :record_timestamps, :instance_writer => false
-      base.record_timestamps = true
+    included do
+      alias_method_chain :create, :timestamps
+      alias_method_chain :update, :timestamps
+
+      class_inheritable_accessor :record_timestamps, :instance_writer => false
+      self.record_timestamps = true
     end
     
     # Saves the record with the updated_at/on attributes set to the current time.

activerecord/lib/active_record/transactions.rb

@@ -3,16 +3,14 @@
 module ActiveRecord
   # See ActiveRecord::Transactions::ClassMethods for documentation.
   module Transactions
+    extend ActiveSupport::DependencyModule
+
     class TransactionError < ActiveRecordError # :nodoc:
     end
 
-    def self.included(base)
-      base.extend(ClassMethods)
-
-      base.class_eval do
-        [:destroy, :save, :save!].each do |method|
-          alias_method_chain method, :transactions
-        end
+    included do
+      [:destroy, :save, :save!].each do |method|
+        alias_method_chain method, :transactions
       end
     end
 

activerecord/lib/active_record/validations.rb

@@ -301,17 +301,16 @@ def to_xml(options={})
   #
   # An Errors object is automatically created for every Active Record.
   module Validations
+    extend ActiveSupport::DependencyModule
+
     VALIDATIONS = %w( validate validate_on_create validate_on_update )
 
-    def self.included(base) # :nodoc:
-      base.extend ClassMethods
-      base.class_eval do
-        alias_method_chain :save, :validation
-        alias_method_chain :save!, :validation
-      end
+    included do
+      alias_method_chain :save, :validation
+      alias_method_chain :save!, :validation
 
-      base.send :include, ActiveSupport::Callbacks
-      base.define_callbacks *VALIDATIONS
+      include ActiveSupport::Callbacks
+      define_callbacks *VALIDATIONS
     end
 
     # Active Record classes can implement validations in several ways. The highest level, easiest to read,

activerecord/test/cases/associations/eager_load_nested_include_test.rb

@@ -6,13 +6,12 @@
 require 'models/categorization'
 
 module Remembered
-  def self.included(base)
-    base.extend ClassMethods
-    base.class_eval do
-      after_create :remember
-    protected
-      def remember; self.class.remembered << self; end
-    end
+  extend ActiveSupport::DependencyModule
+
+  included do
+    after_create :remember
+  protected
+    def remember; self.class.remembered << self; end
   end
 
   module ClassMethods

activerecord/test/cases/repair_helper.rb

 module ActiveRecord
   module Testing
     module RepairHelper
-      def self.included(base)
-        base.class_eval do
-          extend ClassMethods
-        end
-      end
+      extend ActiveSupport::DependencyModule
 
       module Toolbox
         def self.record_validations(*model_classes)