Merge pull request rails#12177 from wangjohn/creating_application_model_template

Creating application model template

Author: spastorino

README.md

@@ -11,7 +11,8 @@ application into three layers, each with a specific responsibility.
 The _Model layer_ represents your domain model (such as Account, Product,
 Person, Post, etc.) and encapsulates the business logic that is specific to
 your application. In Rails, database-backed model classes are derived from
-`ActiveRecord::Base`. Active Record allows you to present the data from
+`ActiveRecord::Base` through an application specific subclass called
+`ApplicationRecord`. Active Record allows you to present the data from
 database rows as objects and embellish these data objects with business logic
 methods. Although most Rails models are backed by a database, models can also
 be ordinary Ruby classes, or Ruby classes that implement a set of interfaces
@@ -23,7 +24,8 @@ providing a suitable response. Usually this means returning HTML, but Rails cont
 can also generate XML, JSON, PDFs, mobile-specific views, and more. Controllers load and
 manipulate models, and render view templates in order to generate the appropriate HTTP response.
 In Rails, incoming requests are routed by Action Dispatch to an appropriate controller, and
-controller classes are derived from `ActionController::Base`. Action Dispatch and Action Controller
+controller classes are derived from `ActionController::Base` through an application specific 
+subclass called `ApplicationController`. Action Dispatch and Action Controller
 are bundled together in Action Pack. You can read more about Action Pack in its
 [README](actionpack/README.rdoc).
 

activerecord/README.rdoc

@@ -2,10 +2,11 @@
 
 Active Record connects classes to relational database tables to establish an
 almost zero-configuration persistence layer for applications. The library
-provides a base class that, when subclassed, sets up a mapping between the new
-class and an existing table in the database. In the context of an application,
-these classes are commonly referred to as *models*. Models can also be
-connected to other models; this is done by defining *associations*.
+provides a base class, and subclassing an application specific version of
+this base class sets up a mapping between the new class and an existing
+table in the database. In the context of an application, these classes are
+commonly referred to as *models*. Models can also be connected to other
+models; this is done by defining *associations*.
 
 Active Record relies heavily on naming in that it uses class and association
 names to establish mappings between respective database tables and foreign key
@@ -17,7 +18,7 @@ A short rundown of some of the major features:
 
 * Automated mapping between classes and tables, attributes and columns.
 
-   class Product < ActiveRecord::Base
+   class Product < ApplicationRecord
    end
 
    The Product class is automatically mapped to the table named "products",
@@ -37,7 +38,7 @@ A short rundown of some of the major features:
 
 * Associations between objects defined by simple class methods.
 
-   class Firm < ActiveRecord::Base
+   class Firm < ApplicationRecord
      has_many   :clients
      has_one    :account
      belongs_to :conglomerate
@@ -48,7 +49,7 @@ A short rundown of some of the major features:
 
 * Aggregations of value objects.
 
-   class Account < ActiveRecord::Base
+   class Account < ApplicationRecord
      composed_of :balance, class_name: 'Money',
                  mapping: %w(balance amount)
      composed_of :address,
@@ -60,7 +61,7 @@ A short rundown of some of the major features:
 
 * Validation rules that can differ for new or existing objects.
 
-    class Account < ActiveRecord::Base
+    class Account < ApplicationRecord
       validates :subdomain, :name, :email_address, :password, presence: true
       validates :subdomain, uniqueness: true
       validates :terms_of_service, acceptance: true, on: :create
@@ -72,7 +73,7 @@ A short rundown of some of the major features:
 
 * Callbacks available for the entire life cycle (instantiation, saving, destroying, validating, etc.).
 
-   class Person < ActiveRecord::Base
+   class Person < ApplicationRecord
      before_destroy :invalidate_payment_plan
      # the `invalidate_payment_plan` method gets called just before Person#destroy
    end
@@ -82,7 +83,7 @@ A short rundown of some of the major features:
 
 * Inheritance hierarchies.
 
-   class Company < ActiveRecord::Base; end
+   class Company < ApplicationRecord; end
    class Firm < Company; end
    class Client < Company; end
    class PriorityClient < Client; end

activerecord/lib/active_record.rb

@@ -31,6 +31,7 @@
 module ActiveRecord
   extend ActiveSupport::Autoload
 
+  autoload :ApplicationConfiguration
   autoload :Base
   autoload :Callbacks
   autoload :Core

activerecord/lib/active_record/aggregations.rb

@@ -15,7 +15,7 @@ def clear_aggregation_cache #:nodoc:
     # existing object) and how it can be turned back into attributes (when the entity is saved to
     # the database).
     #
-    #   class Customer < ActiveRecord::Base
+    #   class Customer < ApplicationRecord
     #     composed_of :balance, class_name: "Money", mapping: %w(balance amount)
     #     composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
     #   end
@@ -136,7 +136,7 @@ def clear_aggregation_cache #:nodoc:
     # or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to meet
     # these requirements:
     #
-    #   class NetworkResource < ActiveRecord::Base
+    #   class NetworkResource < ApplicationRecord
     #     composed_of :cidr,
     #                 class_name: 'NetAddr::CIDR',
     #                 mapping: [ %w(network_address network), %w(cidr_range bits) ],

activerecord/lib/active_record/application_configuration.rb

@@ -0,0 +1,75 @@
+module ActiveRecord
+  module ApplicationConfiguration
+    extend ActiveSupport::Concern
+
+    # The <tt>ApplicationConfiguration</tt> module allows you to control different
+    # configurations that have been set on a particular namespace or model. The
+    # <tt>ApplicationRecord</tt> class for a particular model can be accessed and used
+    # for finding configurations.
+    #
+    # To access this class, you can use the <tt>application_record</tt> method on
+    # any subclass of <tt>ActiveRecord::Base</tt>. For example:
+    #
+    #   class MyModel < ApplicationRecord
+    #   end
+    #
+    #   ActiveRecord::Base.application_record  # => ApplicationRecord
+    #   MyModel.application_record             # => ApplicationRecord
+    #
+    # Moreover, you can use namespacing of modules with the <tt>application_record</tt>
+    # method.
+    #
+    #   module MyNamespace
+    #     class ApplicationRecord < ::ApplicationRecord
+    #     end
+    #
+    #     class MyModel < ApplicationRecord
+    #     end
+    #   end
+    #
+    #   ActiveRecord::Base.application_record    # => ApplicationRecord
+    #   MyNamespace::MyModel.application_record  # => MyNamespace::ApplicationRecord
+    #
+    # You may additionally pass in a class to <tt>application_record</tt>, and
+    # it will look for the configuration of that class. For example:
+    #
+    #   ActiveRecord::Base.application_record(MyNamespace::MyModel) 
+    #       # => MyNamespace::ApplicationRecord
+    #
+    # If the class that is passed into <tt>application_record</tt> does not have
+    # a configuration associated with it, then the method will return the value
+    # that would have been returned without any argument. 
+    #
+    #   ActiveRecord::Base.application_reocrd('something_with_no_config')
+    #       # => ApplicationRecord
+    #
+    module ClassMethods
+      def configs_from(mod)
+        app_record = self
+        define_singleton_method(:application_record) { |klass = nil| app_record }
+
+        mod.define_singleton_method(:application_record) { |klass = nil| app_record }
+      end
+
+      def application_record(klass = nil)
+        return base_app_record unless klass
+
+        klass = klass.class unless klass.respond_to?(:parents)
+
+        if klass.respond_to?(:application_record)
+          klass.application_record
+        elsif app_record = klass.parents.detect { |p| p.respond_to?(:application_record) }
+          app_record
+        else
+          base_app_record
+        end
+      end
+
+      private
+
+        def base_app_record
+          @base_app_record ||= defined?(ApplicationRecord) ? ApplicationRecord : ActiveRecord::Base
+        end
+    end
+  end
+end