Simplify AR configuration code.

Get rid of ActiveModel::Configuration, make better use of
ActiveSupport::Concern + class_attribute, etc.

21 files changed, 343 insertions, 260 deletions

diff --git a/activerecord/lib/active_record/attribute_methods/dirty.rb b/activerecord/lib/active_record/attribute_methods/dirty.rb
index 11c63591e3..f8a40ad520 100644
--- a/activerecord/lib/active_record/attribute_methods/dirty.rb
+++ b/activerecord/lib/active_record/attribute_methods/dirty.rb
@@ -1,12 +1,18 @@
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/module/attribute_accessors'
 
 module ActiveRecord
+  ActiveSupport.on_load(:active_record_config) do
+    mattr_accessor :partial_updates, instance_accessor: false
+    self.partial_updates = true
+  end
+
   module AttributeMethods
     module Dirty
       extend ActiveSupport::Concern
+
       include ActiveModel::Dirty
-      include AttributeMethods::Write
 
       included do
         if self < ::ActiveRecord::Timestamp
@@ -14,7 +20,6 @@ module ActiveRecord
         end
 
         config_attribute :partial_updates
-        self.partial_updates = true
       end
 
       # Attempts to +save+ the record and clears changed attributes if successful.
diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb
index dcc3d79de9..a7af086e43 100644
--- a/activerecord/lib/active_record/attribute_methods/read.rb
+++ b/activerecord/lib/active_record/attribute_methods/read.rb
@@ -1,13 +1,17 @@
 module ActiveRecord
+  ActiveSupport.on_load(:active_record_config) do
+    mattr_accessor :attribute_types_cached_by_default, instance_accessor: false
+  end
+
   module AttributeMethods
     module Read
       extend ActiveSupport::Concern
 
       ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
+      ActiveRecord::Model.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
 
       included do
-        config_attribute :attribute_types_cached_by_default, :global => true
-        self.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
+        config_attribute :attribute_types_cached_by_default
       end
 
       module ClassMethods
diff --git a/activerecord/lib/active_record/attribute_methods/serialization.rb b/activerecord/lib/active_record/attribute_methods/serialization.rb
index 706fbf0546..4af4d28b74 100644
--- a/activerecord/lib/active_record/attribute_methods/serialization.rb
+++ b/activerecord/lib/active_record/attribute_methods/serialization.rb
@@ -6,7 +6,7 @@ module ActiveRecord
       included do
         # Returns a hash of all the attributes that have been specified for serialization as
         # keys and their class restriction as values.
-        config_attribute :serialized_attributes
+        class_attribute :serialized_attributes
         self.serialized_attributes = {}
       end
 
diff --git a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
index 58a5d82e14..e300c9721f 100644
--- a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
+++ b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
@@ -2,6 +2,14 @@ require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/object/inclusion'
 
 module ActiveRecord
+  ActiveSupport.on_load(:active_record_config) do
+    mattr_accessor :time_zone_aware_attributes, instance_accessor: false
+    self.time_zone_aware_attributes = false
+
+    mattr_accessor :skip_time_zone_conversion_for_attributes, instance_accessor: false
+    self.skip_time_zone_conversion_for_attributes = []
+  end
+
   module AttributeMethods
     module TimeZoneConversion
       class Type # :nodoc:
@@ -22,11 +30,8 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       included do
-        config_attribute :time_zone_aware_attributes, :global => true
-        self.time_zone_aware_attributes = false
-
+        config_attribute :time_zone_aware_attributes, global: true
         config_attribute :skip_time_zone_conversion_for_attributes
-        self.skip_time_zone_conversion_for_attributes = []
       end
 
       module ClassMethods
diff --git a/activerecord/lib/active_record/callbacks.rb b/activerecord/lib/active_record/callbacks.rb
index a050fabf35..cc11567506 100644
--- a/activerecord/lib/active_record/callbacks.rb
+++ b/activerecord/lib/active_record/callbacks.rb
@@ -231,30 +231,6 @@ module ActiveRecord
   # Returns true or false depending on whether the proc is contained in the before_save callback chain on a Topic model.
   #
   module Callbacks
-    # We can't define callbacks directly on ActiveRecord::Model because
-    # it is a module. So we queue up the definitions and execute them
-    # when ActiveRecord::Model is included.
-    module Register #:nodoc:
-      def self.extended(base)
-        base.config_attribute :_callbacks_register
-        base._callbacks_register = []
-      end
-
-      def self.setup(base)
-        base._callbacks_register.each do |item|
-          base.send(*item)
-        end
-      end
-
-      def define_callbacks(*args)
-        self._callbacks_register << [:define_callbacks, *args]
-      end
-
-      def define_model_callbacks(*args)
-        self._callbacks_register << [:define_model_callbacks, *args]
-      end
-    end
-
     extend ActiveSupport::Concern
 
     CALLBACKS = [
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
index 61ff603006..347d794fa3 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -448,11 +448,11 @@ module ActiveRecord
       end
 
       def new_connection
-        ActiveRecord::Base.send(spec.adapter_method, spec.config)
+        ActiveRecord::Model.send(spec.adapter_method, spec.config)
       end
 
       def current_connection_id #:nodoc:
-        ActiveRecord::Base.connection_id ||= Thread.current.object_id
+        ActiveRecord::Model.connection_id ||= Thread.current.object_id
       end
 
       def checkout_new_connection
@@ -563,10 +563,12 @@ module ActiveRecord
       end
 
       def retrieve_connection_pool(klass)
-        pool = get_pool_for_class klass.name
-        return pool if pool
-        return nil if ActiveRecord::Model == klass
-        retrieve_connection_pool klass.active_record_super
+        if !(klass < Model::Tag)
+          get_pool_for_class('ActiveRecord::Model') # default connection
+        else
+          pool = get_pool_for_class(klass.name)
+          pool || retrieve_connection_pool(klass.superclass)
+        end
       end
 
       private
diff --git a/activerecord/lib/active_record/connection_handling.rb b/activerecord/lib/active_record/connection_handling.rb
index 7b218a5570..bda41df80f 100644
--- a/activerecord/lib/active_record/connection_handling.rb
+++ b/activerecord/lib/active_record/connection_handling.rb
@@ -90,6 +90,10 @@ module ActiveRecord
       connection_handler.remove_connection(klass)
     end
 
+    def clear_cache! # :nodoc:
+      connection.schema_cache.clear!
+    end
+
     delegate :clear_active_connections!, :clear_reloadable_connections!,
       :clear_all_connections!, :to => :connection_handler
   end
diff --git a/activerecord/lib/active_record/core.rb b/activerecord/lib/active_record/core.rb
index dbad561ca2..f5d60d11b6 100644
--- a/activerecord/lib/active_record/core.rb
+++ b/activerecord/lib/active_record/core.rb
@@ -1,80 +1,88 @@
 require 'active_support/concern'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/object/deep_dup'
+require 'active_support/core_ext/module/delegation'
 require 'thread'
 
 module ActiveRecord
-  module Core
-    extend ActiveSupport::Concern
+  ActiveSupport.on_load(:active_record_config) do
+    ##
+    # :singleton-method:
+    #
+    # Accepts a logger conforming to the interface of Log4r which is then
+    # passed on to any new database connections made and which can be
+    # retrieved on both a class and instance level by calling +logger+.
+    mattr_accessor :logger, instance_accessor: false
 
-    included do
-      ##
-      # :singleton-method:
-      #
-      # Accepts a logger conforming to the interface of Log4r which is then
-      # passed on to any new database connections made and which can be
-      # retrieved on both a class and instance level by calling +logger+.
-      config_attribute :logger, :global => true
+    ##
+    # :singleton-method:
+    # Contains the database configuration - as is typically stored in config/database.yml -
+    # as a Hash.
+    #
+    # For example, the following database.yml...
+    #
+    #   development:
+    #     adapter: sqlite3
+    #     database: db/development.sqlite3
+    #
+    #   production:
+    #     adapter: sqlite3
+    #     database: db/production.sqlite3
+    #
+    # ...would result in ActiveRecord::Base.configurations to look like this:
+    #
+    #   {
+    #      'development' => {
+    #         'adapter'  => 'sqlite3',
+    #         'database' => 'db/development.sqlite3'
+    #      },
+    #      'production' => {
+    #         'adapter'  => 'sqlite3',
+    #         'database' => 'db/production.sqlite3'
+    #      }
+    #   }
+    mattr_accessor :configurations, instance_accessor: false
+    self.configurations = {}
 
-      ##
-      # :singleton-method:
-      # Contains the database configuration - as is typically stored in config/database.yml -
-      # as a Hash.
-      #
-      # For example, the following database.yml...
-      #
-      #   development:
-      #     adapter: sqlite3
-      #     database: db/development.sqlite3
-      #
-      #   production:
-      #     adapter: sqlite3
-      #     database: db/production.sqlite3
-      #
-      # ...would result in ActiveRecord::Base.configurations to look like this:
-      #
-      #   {
-      #      'development' => {
-      #         'adapter'  => 'sqlite3',
-      #         'database' => 'db/development.sqlite3'
-      #      },
-      #      'production' => {
-      #         'adapter'  => 'sqlite3',
-      #         'database' => 'db/production.sqlite3'
-      #      }
-      #   }
-      config_attribute :configurations, :global => true
-      self.configurations = {}
+    ##
+    # :singleton-method:
+    # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
+    # dates and times from the database. This is set to :utc by default.
+    mattr_accessor :default_timezone, instance_accessor: false
+    self.default_timezone = :utc
 
-      ##
-      # :singleton-method:
-      # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
-      # dates and times from the database. This is set to :utc by default.
-      config_attribute :default_timezone, :global => true
-      self.default_timezone = :utc
+    ##
+    # :singleton-method:
+    # Specifies the format to use when dumping the database schema with Rails'
+    # Rakefile. If :sql, the schema is dumped as (potentially database-
+    # specific) SQL statements. If :ruby, the schema is dumped as an
+    # ActiveRecord::Schema file which can be loaded into any database that
+    # supports migrations. Use :ruby if you want to have different database
+    # adapters for, e.g., your development and test environments.
+    mattr_accessor :schema_format, instance_accessor: false
+    self.schema_format = :ruby
 
-      ##
-      # :singleton-method:
-      # Specifies the format to use when dumping the database schema with Rails'
-      # Rakefile. If :sql, the schema is dumped as (potentially database-
-      # specific) SQL statements. If :ruby, the schema is dumped as an
-      # ActiveRecord::Schema file which can be loaded into any database that
-      # supports migrations. Use :ruby if you want to have different database
-      # adapters for, e.g., your development and test environments.
-      config_attribute :schema_format, :global => true
-      self.schema_format = :ruby
+    ##
+    # :singleton-method:
+    # Specify whether or not to use timestamps for migration versions
+    mattr_accessor :timestamped_migrations, instance_accessor: false
+    self.timestamped_migrations = true
 
-      ##
-      # :singleton-method:
-      # Specify whether or not to use timestamps for migration versions
-      config_attribute :timestamped_migrations, :global => true
-      self.timestamped_migrations = true
+    mattr_accessor :connection_handler, instance_accessor: false
+    self.connection_handler = ConnectionAdapters::ConnectionHandler.new
+
+    mattr_accessor :dependent_restrict_raises, instance_accessor: false
+    self.dependent_restrict_raises = true
+  end
 
+  module Core
+    extend ActiveSupport::Concern
+
+    included do
       ##
       # :singleton-method:
       # The connection handler
       config_attribute :connection_handler
-      self.connection_handler = ConnectionAdapters::ConnectionHandler.new
 
       ##
       # :singleton-method:
@@ -83,8 +91,11 @@ module ActiveRecord
       # ActiveRecord::DeleteRestrictionError exception will be raised
       # along with a DEPRECATION WARNING. If set to false, an error would
       # be added to the model instead.
-      config_attribute :dependent_restrict_raises, :global => true
-      self.dependent_restrict_raises = true
+      config_attribute :dependent_restrict_raises
+
+      %w(logger configurations default_timezone schema_format timestamped_migrations).each do |name|
+        config_attribute name, global: true
+      end
     end
 
     module ClassMethods
diff --git a/activerecord/lib/active_record/counter_cache.rb b/activerecord/lib/active_record/counter_cache.rb
index b163ef3c12..b27a19f89a 100644
--- a/activerecord/lib/active_record/counter_cache.rb
+++ b/activerecord/lib/active_record/counter_cache.rb
@@ -1,111 +1,115 @@
 module ActiveRecord
   # = Active Record Counter Cache
   module CounterCache
-    # Resets one or more counter caches to their correct value using an SQL
-    # count query. This is useful when adding new counter caches, or if the
-    # counter has been corrupted or modified directly by SQL.
-    #
-    # ==== Parameters
-    #
-    # * +id+ - The id of the object you wish to reset a counter on.
-    # * +counters+ - One or more counter names to reset
-    #
-    # ==== Examples
-    #
-    #   # For Post with id #1 records reset the comments_count
-    #   Post.reset_counters(1, :comments)
-    def reset_counters(id, *counters)
-      object = find(id)
-      counters.each do |association|
-        has_many_association = reflect_on_association(association.to_sym)
+    extend ActiveSupport::Concern
 
-        foreign_key  = has_many_association.foreign_key.to_s
-        child_class  = has_many_association.klass
-        belongs_to   = child_class.reflect_on_all_associations(:belongs_to)
-        reflection   = belongs_to.find { |e| e.foreign_key.to_s == foreign_key }
-        counter_name = reflection.counter_cache_column
+    module ClassMethods
+      # Resets one or more counter caches to their correct value using an SQL
+      # count query. This is useful when adding new counter caches, or if the
+      # counter has been corrupted or modified directly by SQL.
+      #
+      # ==== Parameters
+      #
+      # * +id+ - The id of the object you wish to reset a counter on.
+      # * +counters+ - One or more counter names to reset
+      #
+      # ==== Examples
+      #
+      #   # For Post with id #1 records reset the comments_count
+      #   Post.reset_counters(1, :comments)
+      def reset_counters(id, *counters)
+        object = find(id)
+        counters.each do |association|
+          has_many_association = reflect_on_association(association.to_sym)
 
-        stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
-          arel_table[counter_name] => object.send(association).count
-        })
-        connection.update stmt
-      end
-      return true
-    end
+          foreign_key  = has_many_association.foreign_key.to_s
+          child_class  = has_many_association.klass
+          belongs_to   = child_class.reflect_on_all_associations(:belongs_to)
+          reflection   = belongs_to.find { |e| e.foreign_key.to_s == foreign_key }
+          counter_name = reflection.counter_cache_column
 
-    # A generic "counter updater" implementation, intended primarily to be
-    # used by increment_counter and decrement_counter, but which may also
-    # be useful on its own. It simply does a direct SQL update for the record
-    # with the given ID, altering the given hash of counters by the amount
-    # given by the corresponding value:
-    #
-    # ==== Parameters
-    #
-    # * +id+ - The id of the object you wish to update a counter on or an Array of ids.
-    # * +counters+ - An Array of Hashes containing the names of the fields
-    #   to update as keys and the amount to update the field by as values.
-    #
-    # ==== Examples
-    #
-    #   # For the Post with id of 5, decrement the comment_count by 1, and
-    #   # increment the action_count by 1
-    #   Post.update_counters 5, :comment_count => -1, :action_count => 1
-    #   # Executes the following SQL:
-    #   # UPDATE posts
-    #   #    SET comment_count = COALESCE(comment_count, 0) - 1,
-    #   #        action_count = COALESCE(action_count, 0) + 1
-    #   #  WHERE id = 5
-    #
-    #   # For the Posts with id of 10 and 15, increment the comment_count by 1
-    #   Post.update_counters [10, 15], :comment_count => 1
-    #   # Executes the following SQL:
-    #   # UPDATE posts
-    #   #    SET comment_count = COALESCE(comment_count, 0) + 1
-    #   #  WHERE id IN (10, 15)
-    def update_counters(id, counters)
-      updates = counters.map do |counter_name, value|
-        operator = value < 0 ? '-' : '+'
-        quoted_column = connection.quote_column_name(counter_name)
-        "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{value.abs}"
+          stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
+            arel_table[counter_name] => object.send(association).count
+          })
+          connection.update stmt
+        end
+        return true
       end
 
-      where(primary_key => id).update_all updates.join(', ')
-    end
+      # A generic "counter updater" implementation, intended primarily to be
+      # used by increment_counter and decrement_counter, but which may also
+      # be useful on its own. It simply does a direct SQL update for the record
+      # with the given ID, altering the given hash of counters by the amount
+      # given by the corresponding value:
+      #
+      # ==== Parameters
+      #
+      # * +id+ - The id of the object you wish to update a counter on or an Array of ids.
+      # * +counters+ - An Array of Hashes containing the names of the fields
+      #   to update as keys and the amount to update the field by as values.
+      #
+      # ==== Examples
+      #
+      #   # For the Post with id of 5, decrement the comment_count by 1, and
+      #   # increment the action_count by 1
+      #   Post.update_counters 5, :comment_count => -1, :action_count => 1
+      #   # Executes the following SQL:
+      #   # UPDATE posts
+      #   #    SET comment_count = COALESCE(comment_count, 0) - 1,
+      #   #        action_count = COALESCE(action_count, 0) + 1
+      #   #  WHERE id = 5
+      #
+      #   # For the Posts with id of 10 and 15, increment the comment_count by 1
+      #   Post.update_counters [10, 15], :comment_count => 1
+      #   # Executes the following SQL:
+      #   # UPDATE posts
+      #   #    SET comment_count = COALESCE(comment_count, 0) + 1
+      #   #  WHERE id IN (10, 15)
+      def update_counters(id, counters)
+        updates = counters.map do |counter_name, value|
+          operator = value < 0 ? '-' : '+'
+          quoted_column = connection.quote_column_name(counter_name)
+          "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{value.abs}"
+        end
 
-    # Increment a number field by one, usually representing a count.
-    #
-    # This is used for caching aggregate values, so that they don't need to be computed every time.
-    # For example, a DiscussionBoard may cache post_count and comment_count otherwise every time the board is
-    # shown it would have to run an SQL query to find how many posts and comments there are.
-    #
-    # ==== Parameters
-    #
-    # * +counter_name+ - The name of the field that should be incremented.
-    # * +id+ - The id of the object that should be incremented.
-    #
-    # ==== Examples
-    #
-    #   # Increment the post_count column for the record with an id of 5
-    #   DiscussionBoard.increment_counter(:post_count, 5)
-    def increment_counter(counter_name, id)
-      update_counters(id, counter_name => 1)
-    end
+        where(primary_key => id).update_all updates.join(', ')
+      end
+
+      # Increment a number field by one, usually representing a count.
+      #
+      # This is used for caching aggregate values, so that they don't need to be computed every time.
+      # For example, a DiscussionBoard may cache post_count and comment_count otherwise every time the board is
+      # shown it would have to run an SQL query to find how many posts and comments there are.
+      #
+      # ==== Parameters
+      #
+      # * +counter_name+ - The name of the field that should be incremented.
+      # * +id+ - The id of the object that should be incremented.
+      #
+      # ==== Examples
+      #
+      #   # Increment the post_count column for the record with an id of 5
+      #   DiscussionBoard.increment_counter(:post_count, 5)
+      def increment_counter(counter_name, id)
+        update_counters(id, counter_name => 1)
+      end
 
-    # Decrement a number field by one, usually representing a count.
-    #
-    # This works the same as increment_counter but reduces the column value by 1 instead of increasing it.
-    #
-    # ==== Parameters
-    #
-    # * +counter_name+ - The name of the field that should be decremented.
-    # * +id+ - The id of the object that should be decremented.
-    #
-    # ==== Examples
-    #
-    #   # Decrement the post_count column for the record with an id of 5
-    #   DiscussionBoard.decrement_counter(:post_count, 5)
-    def decrement_counter(counter_name, id)
-      update_counters(id, counter_name => -1)
+      # Decrement a number field by one, usually representing a count.
+      #
+      # This works the same as increment_counter but reduces the column value by 1 instead of increasing it.
+      #
+      # ==== Parameters
+      #
+      # * +counter_name+ - The name of the field that should be decremented.
+      # * +id+ - The id of the object that should be decremented.
+      #
+      # ==== Examples
+      #
+      #   # Decrement the post_count column for the record with an id of 5
+      #   DiscussionBoard.decrement_counter(:post_count, 5)
+      def decrement_counter(counter_name, id)
+        update_counters(id, counter_name => -1)
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/explain.rb b/activerecord/lib/active_record/explain.rb
index b0eda8ef34..7ade385c70 100644
--- a/activerecord/lib/active_record/explain.rb
+++ b/activerecord/lib/active_record/explain.rb
@@ -1,12 +1,13 @@
+require 'active_support/lazy_load_hooks'
 require 'active_support/core_ext/class/attribute'
 
 module ActiveRecord
+  ActiveSupport.on_load(:active_record_config) do
+    mattr_accessor :auto_explain_threshold_in_seconds, instance_accessor: false
+  end
+
   module Explain
-    def self.extended(base)
-      # If a query takes longer than these many seconds we log its query plan
-      # automatically. nil disables this feature.
-      base.config_attribute :auto_explain_threshold_in_seconds, :global => true
-    end
+    delegate :auto_explain_threshold_in_seconds, :auto_explain_threshold_in_seconds=, to: 'ActiveRecord::Model'
 
     # If auto explain is enabled, this method triggers EXPLAIN logging for the
     # queries triggered by the block if it takes more than the threshold as a
diff --git a/activerecord/lib/active_record/inheritance.rb b/activerecord/lib/active_record/inheritance.rb
index 46d253b0a7..770083ac13 100644
--- a/activerecord/lib/active_record/inheritance.rb
+++ b/activerecord/lib/active_record/inheritance.rb
@@ -1,13 +1,17 @@
 require 'active_support/concern'
 
 module ActiveRecord
+  ActiveSupport.on_load(:active_record_config) do
+    # Determine whether to store the full constant name including namespace when using STI
+    mattr_accessor :store_full_sti_class, instance_accessor: false
+    self.store_full_sti_class = true
+  end
+
   module Inheritance
     extend ActiveSupport::Concern
 
     included do
-      # Determine whether to store the full constant name including namespace when using STI
       config_attribute :store_full_sti_class
-      self.store_full_sti_class = true
     end
 
     module ClassMethods
@@ -95,7 +99,7 @@ module ActiveRecord
       # Returns the class descending directly from ActiveRecord::Base or an
       # abstract class, if any, in the inheritance hierarchy.
       def class_of_active_record_descendant(klass)
-        unless klass < Model
+        unless klass < Model::Tag
           raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
         end
 
diff --git a/activerecord/lib/active_record/locking/optimistic.rb b/activerecord/lib/active_record/locking/optimistic.rb
index 05e052b953..4ce42feb74 100644
--- a/activerecord/lib/active_record/locking/optimistic.rb
+++ b/activerecord/lib/active_record/locking/optimistic.rb
@@ -1,4 +1,9 @@
 module ActiveRecord
+  ActiveSupport.on_load(:active_record_config) do
+    mattr_accessor :lock_optimistically, instance_accessor: false
+    self.lock_optimistically = true
+  end
+
   module Locking
     # == What is Optimistic Locking
     #
@@ -51,8 +56,7 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       included do
-        config_attribute :lock_optimistically, :global => true
-        self.lock_optimistically = true
+        config_attribute :lock_optimistically
       end
 
       def locking_enabled? #:nodoc:
diff --git a/activerecord/lib/active_record/model.rb b/activerecord/lib/active_record/model.rb
index 105d1e0e2b..831745856b 100644
--- a/activerecord/lib/active_record/model.rb
+++ b/activerecord/lib/active_record/model.rb
@@ -1,6 +1,34 @@
 require 'active_support/deprecation'
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/attribute_accessors'
 
 module ActiveRecord
+  module Configuration # :nodoc:
+    # This just abstracts out how we define configuration options in AR. Essentially we
+    # have mattr_accessors on the ActiveRecord:Model constant that define global defaults.
+    # Classes that then use AR get class_attributes defined, which means that when they
+    # are assigned the default will be overridden for that class and subclasses. (Except
+    # when options[:global] == true, in which case there is one global value always.)
+    def config_attribute(name, options = {})
+      if options[:global]
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def self.#{name};       ActiveRecord::Model.#{name};       end
+          def #{name};            ActiveRecord::Model.#{name};       end
+          def self.#{name}=(val); ActiveRecord::Model.#{name} = val; end
+        CODE
+      else
+        options[:instance_writer] ||= false
+        class_attribute name, options
+
+        singleton_class.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          remove_method :#{name}
+          def #{name}; ActiveRecord::Model.#{name}; end
+        CODE
+      end
+    end
+  end
+
   # <tt>ActiveRecord::Model</tt> can be included into a class to add Active Record persistence.
   # This is an alternative to inheriting from <tt>ActiveRecord::Base</tt>. Example:
   #
@@ -9,41 +37,34 @@ module ActiveRecord
   #     end
   #
   module Model
-    module ClassMethods #:nodoc:
-      include ActiveSupport::Callbacks::ClassMethods
-      include ActiveModel::Naming
-      include QueryCache::ClassMethods
-      include ActiveSupport::Benchmarkable
-      include ActiveSupport::DescendantsTracker
-
-      include Querying
-      include Translation
-      include DynamicMatchers
-      include CounterCache
-      include Explain
-      include ConnectionHandling
-    end
+    extend ActiveSupport::Concern
+    extend ConnectionHandling
 
-    def self.included(base)
-      return if base.singleton_class < ClassMethods
+    # This allows us to detect an ActiveRecord::Model while it's in the process of being included.
+    module Tag; end
 
+    def self.append_features(base)
       base.class_eval do
-        extend ClassMethods
-        Callbacks::Register.setup(self)
-        initialize_generated_modules unless self == Base
+        include Tag
+        extend Configuration
       end
+
+      super
     end
 
-    extend ActiveModel::Configuration
-    extend ActiveModel::Callbacks
-    extend ActiveModel::MassAssignmentSecurity::ClassMethods
-    extend ActiveModel::AttributeMethods::ClassMethods
-    extend Callbacks::Register
-    extend Explain
-    extend ConnectionHandling
+    included do
+      extend ActiveModel::Naming
+      extend ActiveSupport::Benchmarkable
+      extend ActiveSupport::DescendantsTracker
+
+      extend QueryCache::ClassMethods
+      extend Querying
+      extend Translation
+      extend DynamicMatchers
+      extend Explain
+      extend ConnectionHandling
 
-    def self.extend(*modules)
-      ClassMethods.send(:include, *modules)
+      initialize_generated_modules unless self == Base
     end
 
     include Persistence
@@ -56,13 +77,22 @@ module ActiveRecord
     include AttributeAssignment
     include ActiveModel::Conversion
     include Validations
-    include Locking::Optimistic, Locking::Pessimistic
+    include CounterCache
+    include Locking::Optimistic
+    include Locking::Pessimistic
     include AttributeMethods
-    include Callbacks, ActiveModel::Observing, Timestamp
+    include Callbacks
+    include ActiveModel::Observing
+    include Timestamp
     include Associations
     include ActiveModel::SecurePassword
-    include AutosaveAssociation, NestedAttributes
-    include Aggregations, Transactions, Reflection, Serialization, Store
+    include AutosaveAssociation
+    include NestedAttributes
+    include Aggregations
+    include Transactions
+    include Reflection
+    include Serialization
+    include Store
     include Core
 
     class << self
@@ -103,6 +133,15 @@ module ActiveRecord
     end
   end
 
+  # This hook is where config accessors on Model get defined.
+  #
+  # We don't want to just open the Model module and add stuff to it in other files, because
+  # that would cause Model to load, which causes all sorts of loading order issues.
+  #
+  # We need this hook rather than just using the :active_record one, because users of the
+  # :active_record hook may need to use config options.
+  ActiveSupport.run_load_hooks(:active_record_config, Model)
+
   # Load Base at this point, because the active_record load hook is run in that file.
   Base
 end
diff --git a/activerecord/lib/active_record/model_schema.rb b/activerecord/lib/active_record/model_schema.rb
index 7f38dda11e..e6b76ddc4c 100644
--- a/activerecord/lib/active_record/model_schema.rb
+++ b/activerecord/lib/active_record/model_schema.rb
@@ -1,7 +1,19 @@
 require 'active_support/concern'
-require 'active_support/core_ext/class/attribute_accessors'
 
 module ActiveRecord
+  ActiveSupport.on_load(:active_record_config) do
+    mattr_accessor :primary_key_prefix_type, instance_accessor: false
+
+    mattr_accessor :table_name_prefix, instance_accessor: false
+    self.table_name_prefix = ""
+
+    mattr_accessor :table_name_suffix, instance_accessor: false
+    self.table_name_suffix = ""
+
+    mattr_accessor :pluralize_table_names, instance_accessor: false
+    self.pluralize_table_names = true
+  end
+
   module ModelSchema
     extend ActiveSupport::Concern
 
@@ -13,7 +25,7 @@ module ActiveRecord
       # the Product class will look for "productid" instead of "id" as the primary column. If the
       # latter is specified, the Product class will look for "product_id" instead of "id". Remember
       # that this is a global setting for all Active Records.
-      config_attribute :primary_key_prefix_type, :global => true
+      config_attribute :primary_key_prefix_type, global: true
 
       ##
       # :singleton-method:
@@ -26,14 +38,12 @@ module ActiveRecord
       # a namespace by defining a singleton method in the parent module called table_name_prefix which
       # returns your chosen prefix.
       config_attribute :table_name_prefix
-      self.table_name_prefix = ""
 
       ##
       # :singleton-method:
       # Works like +table_name_prefix+, but appends instead of prepends (set to "_basecamp" gives "projects_basecamp",
       # "people_basecamp"). By default, the suffix is the empty string.
       config_attribute :table_name_suffix
-      self.table_name_suffix = ""
 
       ##
       # :singleton-method:
@@ -41,7 +51,6 @@ module ActiveRecord
       # If true, the default table name for a Product class will be +products+. If false, it would just be +product+.
       # See table_name for the full rules on table/class naming. This is true, by default.
       config_attribute :pluralize_table_names
-      self.pluralize_table_names = true
     end
 
     module ClassMethods
@@ -308,10 +317,6 @@ module ActiveRecord
         @relation             = nil
       end
 
-      def clear_cache! # :nodoc:
-        connection.schema_cache.clear!
-      end
-
       private
 
       # Guesses the table name, but does not decorate it with prefix and suffix information.
diff --git a/activerecord/lib/active_record/nested_attributes.rb b/activerecord/lib/active_record/nested_attributes.rb
index 95a2ddcc11..841681e542 100644
--- a/activerecord/lib/active_record/nested_attributes.rb
+++ b/activerecord/lib/active_record/nested_attributes.rb
@@ -5,6 +5,11 @@ require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/class/attribute'
 
 module ActiveRecord
+  ActiveSupport.on_load(:active_record_config) do
+    mattr_accessor :nested_attributes_options, instance_accessor: false
+    self.nested_attributes_options = {}
+  end
+
   module NestedAttributes #:nodoc:
     class TooManyRecords < ActiveRecordError
     end
@@ -13,7 +18,6 @@ module ActiveRecord
 
     included do
       config_attribute :nested_attributes_options
-      self.nested_attributes_options = {}
     end
 
     # = Active Record Nested Attributes
diff --git a/activerecord/lib/active_record/railtie.rb b/activerecord/lib/active_record/railtie.rb
index fb5f41ced2..6937960e93 100644
--- a/activerecord/lib/active_record/railtie.rb
+++ b/activerecord/lib/active_record/railtie.rb
@@ -101,8 +101,8 @@ module ActiveRecord
 
       ActiveSupport.on_load(:active_record) do
         ActionDispatch::Reloader.send(hook) do
-          ActiveRecord::Base.clear_reloadable_connections!
-          ActiveRecord::Base.clear_cache!
+          ActiveRecord::Model.clear_reloadable_connections!
+          ActiveRecord::Model.clear_cache!
         end
       end
     end
diff --git a/activerecord/lib/active_record/readonly_attributes.rb b/activerecord/lib/active_record/readonly_attributes.rb
index 836b15e2ce..960b78dc38 100644
--- a/activerecord/lib/active_record/readonly_attributes.rb
+++ b/activerecord/lib/active_record/readonly_attributes.rb
@@ -6,7 +6,7 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      config_attribute :_attr_readonly
+      class_attribute :_attr_readonly, instance_writer: false
       self._attr_readonly = []
     end
 
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index c380b5c029..ec13d27323 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -7,8 +7,7 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      extend ActiveModel::Configuration
-      config_attribute :reflections
+      class_attribute :reflections
       self.reflections = {}
     end
 
diff --git a/activerecord/lib/active_record/scoping/default.rb b/activerecord/lib/active_record/scoping/default.rb
index db833fc7f1..af51c803a7 100644
--- a/activerecord/lib/active_record/scoping/default.rb
+++ b/activerecord/lib/active_record/scoping/default.rb
@@ -8,7 +8,7 @@ module ActiveRecord
 
       included do
         # Stores the default scope for the class
-        config_attribute :default_scopes
+        class_attribute :default_scopes, instance_writer: false
         self.default_scopes = []
       end
 
diff --git a/activerecord/lib/active_record/serialization.rb b/activerecord/lib/active_record/serialization.rb
index 41e3b92499..e8dd312a47 100644
--- a/activerecord/lib/active_record/serialization.rb
+++ b/activerecord/lib/active_record/serialization.rb
@@ -1,9 +1,21 @@
 module ActiveRecord #:nodoc:
+  ActiveSupport.on_load(:active_record_config) do
+    mattr_accessor :include_root_in_json, instance_accessor: false
+    self.include_root_in_json = true
+  end
+
   # = Active Record Serialization
   module Serialization
     extend ActiveSupport::Concern
     include ActiveModel::Serializers::JSON
 
+    included do
+      singleton_class.class_eval do
+        remove_method :include_root_in_json
+        delegate :include_root_in_json, to: 'ActiveRecord::Model'
+      end
+    end
+
     def serializable_hash(options = nil)
       options = options.try(:clone) || {}
 
diff --git a/activerecord/lib/active_record/timestamp.rb b/activerecord/lib/active_record/timestamp.rb
index c717fdea47..e5b7a6bfba 100644
--- a/activerecord/lib/active_record/timestamp.rb
+++ b/activerecord/lib/active_record/timestamp.rb
@@ -1,6 +1,11 @@
 require 'active_support/core_ext/class/attribute'
 
 module ActiveRecord
+  ActiveSupport.on_load(:active_record_config) do
+    mattr_accessor :record_timestamps, instance_accessor: false
+    self.record_timestamps = true
+  end
+
   # = Active Record Timestamp
   #
   # Active Record automatically timestamps create and update operations if the
@@ -33,8 +38,7 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      config_attribute :record_timestamps, :instance_writer => true
-      self.record_timestamps = true
+      config_attribute :record_timestamps, instance_writer: true
     end
 
     def initialize_dup(other)