activerecord 4.2.11.2 → 6.0.0

data/MIT-LICENSE

@@ -1,4 +1,6 @@
-Copyright (c) 2004-2014 David Heinemeier Hansson
+Copyright (c) 2004-2019 David Heinemeier Hansson
+
+Arel originally copyright (c) 2007-2016 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -17,4 +19,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -13,6 +13,8 @@ columns. Although these mappings can be defined explicitly, it's recommended
 to follow naming conventions, especially when getting started with the
 library.
 
+You can read more about Active Record in the {Active Record Basics}[https://edgeguides.rubyonrails.org/active_record_basics.html] guide.
+
 A short rundown of some of the major features:
 
 * Automated mapping between classes and tables, attributes and columns.
@@ -26,13 +28,13 @@ The Product class is automatically mapped to the table named "products",
 which might look like this:
 
    CREATE TABLE products (
-     id int(11) NOT NULL auto_increment,
+     id bigint NOT NULL auto_increment,
      name varchar(255),
      PRIMARY KEY  (id)
    );
 
-This would also define the following accessors: `Product#name` and
-`Product#name=(new_name)`.
+This would also define the following accessors: <tt>Product#name</tt> and
+<tt>Product#name=(new_name)</tt>.
 
 
 * Associations between objects defined by simple class methods.
@@ -125,7 +127,7 @@ This would also define the following accessors: `Product#name` and
     )
 
   {Learn more}[link:classes/ActiveRecord/Base.html] and read about the built-in support for
-  MySQL[link:classes/ActiveRecord/ConnectionAdapters/MysqlAdapter.html],
+  MySQL[link:classes/ActiveRecord/ConnectionAdapters/Mysql2Adapter.html],
   PostgreSQL[link:classes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapter.html], and
   SQLite3[link:classes/ActiveRecord/ConnectionAdapters/SQLite3Adapter.html].
 
@@ -138,7 +140,7 @@ This would also define the following accessors: `Product#name` and
 
 * Database agnostic schema management with Migrations.
 
-    class AddSystemSettings < ActiveRecord::Migration
+    class AddSystemSettings < ActiveRecord::Migration[5.0]
       def up
         create_table :system_settings do |t|
           t.string  :name
@@ -162,7 +164,7 @@ This would also define the following accessors: `Product#name` and
 == Philosophy
 
 Active Record is an implementation of the object-relational mapping (ORM)
-pattern[http://www.martinfowler.com/eaaCatalog/activeRecord.html] by the same
+pattern[https://www.martinfowler.com/eaaCatalog/activeRecord.html] by the same
 name described by Martin Fowler:
 
   "An object that wraps a row in a database table or view,
@@ -188,31 +190,30 @@ Admit the Database:
 
 The latest version of Active Record can be installed with RubyGems:
 
-  % [sudo] gem install activerecord
+  $ gem install activerecord
 
 Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/4-2-stable/activerecord
+* https://github.com/rails/rails/tree/master/activerecord
 
 
 == License
 
 Active Record is released under the MIT license:
 
-* http://www.opensource.org/licenses/MIT
+* https://opensource.org/licenses/MIT
 
 
 == Support
 
 API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
-Bug reports can be filed for the Ruby on Rails project here:
+Bug reports for the Ruby on Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
 Feature requests should be discussed on the rails-core mailing list here:
 
 * https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
-

data/examples/performance.rb

@@ -1,11 +1,12 @@
-require File.expand_path('../../../load_paths', __FILE__)
+# frozen_string_literal: true
+
 require "active_record"
-require 'benchmark/ips'
+require "benchmark/ips"
 
-TIME    = (ENV['BENCHMARK_TIME'] || 20).to_i
-RECORDS = (ENV['BENCHMARK_RECORDS'] || TIME*1000).to_i
+TIME    = (ENV["BENCHMARK_TIME"] || 20).to_i
+RECORDS = (ENV["BENCHMARK_RECORDS"] || TIME * 1000).to_i
 
-conn = { adapter: 'sqlite3', database: ':memory:' }
+conn = { adapter: "sqlite3", database: ":memory:" }
 
 ActiveRecord::Base.establish_connection(conn)
 
@@ -39,30 +40,30 @@ class Exhibit < ActiveRecord::Base
     where("notes IS NOT NULL")
   end
 
-  def self.look(exhibits) exhibits.each { |e| e.look } end
-  def self.feel(exhibits) exhibits.each { |e| e.feel } end
+  def self.look(exhibits) exhibits.each(&:look) end
+  def self.feel(exhibits) exhibits.each(&:feel) end
 end
 
-def progress_bar(int); print "." if (int%100).zero? ; end
+def progress_bar(int); print "." if (int % 100).zero? ; end
 
-puts 'Generating data...'
+puts "Generating data..."
 
 module ActiveRecord
   class Faker
-    LOREM = %Q{Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse non aliquet diam. Curabitur vel urna metus, quis malesuada elit.
+    LOREM = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse non aliquet diam. Curabitur vel urna metus, quis malesuada elit.
      Integer consequat tincidunt felis. Etiam non erat dolor. Vivamus imperdiet nibh sit amet diam eleifend id posuere diam malesuada. Mauris at accumsan sem.
      Donec id lorem neque. Fusce erat lorem, ornare eu congue vitae, malesuada quis neque. Maecenas vel urna a velit pretium fermentum. Donec tortor enim,
      tempor venenatis egestas a, tempor sed ipsum. Ut arcu justo, faucibus non imperdiet ac, interdum at diam. Pellentesque ipsum enim, venenatis ut iaculis vitae,
      varius vitae sem. Sed rutrum quam ac elit euismod bibendum. Donec ultricies ultricies magna, at lacinia libero mollis aliquam. Sed ac arcu in tortor elementum
      tincidunt vel interdum sem. Curabitur eget erat arcu. Praesent eget eros leo. Nam magna enim, sollicitudin vehicula scelerisque in, vulputate ut libero.
-     Praesent varius tincidunt commodo}.split
+     Praesent varius tincidunt commodo".split
 
     def self.name
-      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join ' '
+      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join " "
     end
 
     def self.email
-      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join('@') + ".com"
+      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join("@") + ".com"
     end
   end
 end
@@ -73,7 +74,7 @@ end
 
 # Using the same paragraph for all exhibits because it is very slow
 # to generate unique paragraphs for all exhibits.
-notes = ActiveRecord::Faker::LOREM.join ' '
+notes = ActiveRecord::Faker::LOREM.join " "
 today = Date.today
 
 puts "Inserting #{RECORDS} users and exhibits..."
@@ -96,9 +97,9 @@ puts "Done!\n"
 
 Benchmark.ips(TIME) do |x|
   ar_obj       = Exhibit.find(1)
-  attrs        = { name: 'sam' }
-  attrs_first  = { name: 'sam' }
-  attrs_second = { name: 'tom' }
+  attrs        = { name: "sam" }
+  attrs_first  = { name: "sam" }
+  attrs_second = { name: "tom" }
   exhibit      = {
     name: ActiveRecord::Faker.name,
     notes: notes,
@@ -109,22 +110,22 @@ Benchmark.ips(TIME) do |x|
     ar_obj.id
   end
 
-  x.report 'Model.new (instantiation)' do
+  x.report "Model.new (instantiation)" do
     Exhibit.new
   end
 
-  x.report 'Model.new (setting attributes)' do
+  x.report "Model.new (setting attributes)" do
     Exhibit.new(attrs)
   end
 
-  x.report 'Model.first' do
+  x.report "Model.first" do
     Exhibit.first.look
   end
 
-  x.report 'Model.take' do 
+  x.report "Model.take" do
     Exhibit.take
   end
-  
+
   x.report("Model.all limit(100)") do
     Exhibit.look Exhibit.limit(100)
   end
@@ -141,41 +142,41 @@ Benchmark.ips(TIME) do |x|
     Exhibit.look Exhibit.limit(10000)
   end
 
-  x.report 'Model.named_scope' do
+  x.report "Model.named_scope" do
     Exhibit.limit(10).with_name.with_notes
   end
 
-  x.report 'Model.create' do
+  x.report "Model.create" do
     Exhibit.create(exhibit)
   end
 
-  x.report 'Resource#attributes=' do
+  x.report "Resource#attributes=" do
     e = Exhibit.new(attrs_first)
     e.attributes = attrs_second
   end
 
-  x.report 'Resource#update' do
-    Exhibit.first.update(name: 'bob')
+  x.report "Resource#update" do
+    Exhibit.first.update(name: "bob")
   end
 
-  x.report 'Resource#destroy' do
+  x.report "Resource#destroy" do
     Exhibit.first.destroy
   end
 
-  x.report 'Model.transaction' do
+  x.report "Model.transaction" do
     Exhibit.transaction { Exhibit.new }
   end
 
-  x.report 'Model.find(id)' do
+  x.report "Model.find(id)" do
     User.find(1)
   end
 
-  x.report 'Model.find_by_sql' do
+  x.report "Model.find_by_sql" do
     Exhibit.find_by_sql("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}").first
   end
 
   x.report "Model.log" do
-    Exhibit.connection.send(:log, "hello", "world") {}
+    Exhibit.connection.send(:log, "hello", "world") { }
   end
 
   x.report "AR.execute(query)" do

data/examples/simple.rb

@@ -1,14 +1,15 @@
-require File.expand_path('../../../load_paths', __FILE__)
-require 'active_record'
+# frozen_string_literal: true
+
+require "active_record"
 
 class Person < ActiveRecord::Base
-  establish_connection adapter: 'sqlite3', database: 'foobar.db'
+  establish_connection adapter: "sqlite3", database: "foobar.db"
   connection.create_table table_name, force: true do |t|
     t.string :name
   end
 end
 
-bob = Person.create!(name: 'bob')
+bob = Person.create!(name: "bob")
 puts Person.all.inspect
 bob.destroy
 puts Person.all.inspect

data/lib/active_record.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2004-2014 David Heinemeier Hansson
+# Copyright (c) 2004-2019 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -21,18 +23,18 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-require 'active_support'
-require 'active_support/rails'
-require 'active_model'
-require 'arel'
+require "active_support"
+require "active_support/rails"
+require "active_model"
+require "arel"
+require "yaml"
 
-require 'active_record/version'
-require 'active_record/attribute_set'
+require "active_record/version"
+require "active_model/attribute_set"
 
 module ActiveRecord
   extend ActiveSupport::Autoload
 
-  autoload :Attribute
   autoload :Base
   autoload :Callbacks
   autoload :Core
@@ -40,19 +42,21 @@ module ActiveRecord
   autoload :CounterCache
   autoload :DynamicMatchers
   autoload :Enum
+  autoload :InternalMetadata
   autoload :Explain
   autoload :Inheritance
   autoload :Integration
   autoload :Migration
-  autoload :Migrator, 'active_record/migration'
+  autoload :Migrator, "active_record/migration"
   autoload :ModelSchema
   autoload :NestedAttributes
   autoload :NoTouching
+  autoload :TouchLater
   autoload :Persistence
   autoload :QueryCache
   autoload :Querying
   autoload :ReadonlyAttributes
-  autoload :RecordInvalid, 'active_record/validations'
+  autoload :RecordInvalid, "active_record/validations"
   autoload :Reflection
   autoload :RuntimeRegistry
   autoload :Sanitization
@@ -63,15 +67,18 @@ module ActiveRecord
   autoload :Serialization
   autoload :StatementCache
   autoload :Store
+  autoload :Suppressor
   autoload :Timestamp
   autoload :Transactions
   autoload :Translation
   autoload :Validations
+  autoload :SecureToken
+  autoload :DatabaseSelector, "active_record/middleware/database_selector"
 
   eager_autoload do
-    autoload :ActiveRecordError, 'active_record/errors'
-    autoload :ConnectionNotEstablished, 'active_record/errors'
-    autoload :ConnectionAdapters, 'active_record/connection_adapters/abstract_adapter'
+    autoload :ActiveRecordError, "active_record/errors"
+    autoload :ConnectionNotEstablished, "active_record/errors"
+    autoload :ConnectionAdapters, "active_record/connection_adapters/abstract_adapter"
 
     autoload :Aggregations
     autoload :Associations
@@ -85,7 +92,7 @@ module ActiveRecord
     autoload :AssociationRelation
     autoload :NullRelation
 
-    autoload_under 'relation' do
+    autoload_under "relation" do
       autoload :QueryMethods
       autoload :FinderMethods
       autoload :Calculations
@@ -96,11 +103,13 @@ module ActiveRecord
     end
 
     autoload :Result
+    autoload :TableMetadata
+    autoload :Type
   end
 
   module Coders
-    autoload :YAMLColumn, 'active_record/coders/yaml_column'
-    autoload :JSON, 'active_record/coders/json'
+    autoload :YAMLColumn, "active_record/coders/yaml_column"
+    autoload :JSON, "active_record/coders/json"
   end
 
   module AttributeMethods
@@ -132,7 +141,6 @@ module ActiveRecord
 
     eager_autoload do
       autoload :AbstractAdapter
-      autoload :ConnectionManagement, "active_record/connection_adapters/abstract/connection_pool"
     end
   end
 
@@ -145,17 +153,24 @@ module ActiveRecord
     end
   end
 
+  module Middleware
+    extend ActiveSupport::Autoload
+
+    autoload :DatabaseSelector, "active_record/middleware/database_selector"
+  end
+
   module Tasks
     extend ActiveSupport::Autoload
 
     autoload :DatabaseTasks
-    autoload :SQLiteDatabaseTasks, 'active_record/tasks/sqlite_database_tasks'
-    autoload :MySQLDatabaseTasks,  'active_record/tasks/mysql_database_tasks'
+    autoload :SQLiteDatabaseTasks, "active_record/tasks/sqlite_database_tasks"
+    autoload :MySQLDatabaseTasks,  "active_record/tasks/mysql_database_tasks"
     autoload :PostgreSQLDatabaseTasks,
-      'active_record/tasks/postgresql_database_tasks'
+      "active_record/tasks/postgresql_database_tasks"
   end
 
-  autoload :TestFixtures, 'active_record/fixtures'
+  autoload :TestDatabases, "active_record/test_databases"
+  autoload :TestFixtures, "active_record/fixtures"
 
   def self.eager_load!
     super
@@ -172,5 +187,9 @@ ActiveSupport.on_load(:active_record) do
 end
 
 ActiveSupport.on_load(:i18n) do
-  I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'
+  I18n.load_path << File.expand_path("active_record/locale/en.yml", __dir__)
 end
+
+YAML.load_tags["!ruby/object:ActiveRecord::AttributeSet"] = "ActiveModel::AttributeSet"
+YAML.load_tags["!ruby/object:ActiveRecord::Attribute::FromDatabase"] = "ActiveModel::Attribute::FromDatabase"
+YAML.load_tags["!ruby/object:ActiveRecord::LazyAttributeHash"] = "ActiveModel::LazyAttributeHash"

data/lib/active_record/aggregations.rb

@@ -1,269 +1,285 @@
-module ActiveRecord
-  # = Active Record Aggregations
-  module Aggregations # :nodoc:
-    extend ActiveSupport::Concern
+# frozen_string_literal: true
 
-    def clear_aggregation_cache #:nodoc:
-      @aggregation_cache.clear if persisted?
+module ActiveRecord
+  # See ActiveRecord::Aggregations::ClassMethods for documentation
+  module Aggregations
+    def initialize_dup(*) # :nodoc:
+      @aggregation_cache = {}
+      super
     end
 
-    # Active Record implements aggregation through a macro-like class method called +composed_of+
-    # for representing attributes  as value objects. It expresses relationships like "Account [is]
-    # composed of Money [among other things]" or "Person [is] composed of [an] address". Each call
-    # to the macro adds a description of how the value objects are created from the attributes of
-    # the entity object (when the entity is initialized either as a new object or from finding an
-    # existing object) and how it can be turned back into attributes (when the entity is saved to
-    # the database).
-    #
-    #   class Customer < ActiveRecord::Base
-    #     composed_of :balance, class_name: "Money", mapping: %w(balance amount)
-    #     composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
-    #   end
-    #
-    # The customer class now has the following methods to manipulate the value objects:
-    # * <tt>Customer#balance, Customer#balance=(money)</tt>
-    # * <tt>Customer#address, Customer#address=(address)</tt>
-    #
-    # These methods will operate with value objects like the ones described below:
-    #
-    #  class Money
-    #    include Comparable
-    #    attr_reader :amount, :currency
-    #    EXCHANGE_RATES = { "USD_TO_DKK" => 6 }
-    #
-    #    def initialize(amount, currency = "USD")
-    #      @amount, @currency = amount, currency
-    #    end
-    #
-    #    def exchange_to(other_currency)
-    #      exchanged_amount = (amount * EXCHANGE_RATES["#{currency}_TO_#{other_currency}"]).floor
-    #      Money.new(exchanged_amount, other_currency)
-    #    end
-    #
-    #    def ==(other_money)
-    #      amount == other_money.amount && currency == other_money.currency
-    #    end
-    #
-    #    def <=>(other_money)
-    #      if currency == other_money.currency
-    #        amount <=> other_money.amount
-    #      else
-    #        amount <=> other_money.exchange_to(currency).amount
-    #      end
-    #    end
-    #  end
-    #
-    #  class Address
-    #    attr_reader :street, :city
-    #    def initialize(street, city)
-    #      @street, @city = street, city
-    #    end
-    #
-    #    def close_to?(other_address)
-    #      city == other_address.city
-    #    end
-    #
-    #    def ==(other_address)
-    #      city == other_address.city && street == other_address.street
-    #    end
-    #  end
-    #
-    # Now it's possible to access attributes from the database through the value objects instead. If
-    # you choose to name the composition the same as the attribute's name, it will be the only way to
-    # access that attribute. That's the case with our +balance+ attribute. You interact with the value
-    # objects just like you would with any other attribute:
-    #
-    #   customer.balance = Money.new(20)     # sets the Money value object and the attribute
-    #   customer.balance                     # => Money value object
-    #   customer.balance.exchange_to("DKK")  # => Money.new(120, "DKK")
-    #   customer.balance > Money.new(10)     # => true
-    #   customer.balance == Money.new(20)    # => true
-    #   customer.balance < Money.new(5)      # => false
-    #
-    # Value objects can also be composed of multiple attributes, such as the case of Address. The order
-    # of the mappings will determine the order of the parameters.
-    #
-    #   customer.address_street = "Hyancintvej"
-    #   customer.address_city   = "Copenhagen"
-    #   customer.address        # => Address.new("Hyancintvej", "Copenhagen")
-    #
-    #   customer.address_street = "Vesterbrogade"
-    #   customer.address        # => Address.new("Hyancintvej", "Copenhagen")
-    #   customer.clear_aggregation_cache
-    #   customer.address        # => Address.new("Vesterbrogade", "Copenhagen")
-    #
-    #   customer.address = Address.new("May Street", "Chicago")
-    #   customer.address_street # => "May Street"
-    #   customer.address_city   # => "Chicago"
-    #
-    # == Writing value objects
-    #
-    # Value objects are immutable and interchangeable objects that represent a given value, such as
-    # a Money object representing $5. Two Money objects both representing $5 should be equal (through
-    # methods such as <tt>==</tt> and <tt><=></tt> from Comparable if ranking makes sense). This is
-    # unlike entity objects where equality is determined by identity. An entity class such as Customer can
-    # easily have two different objects that both have an address on Hyancintvej. Entity identity is
-    # determined by object or relational unique identifiers (such as primary keys). Normal
-    # ActiveRecord::Base classes are entity objects.
-    #
-    # It's also important to treat the value objects as immutable. Don't allow the Money object to have
-    # its amount changed after creation. Create a new Money object with the new value instead. The
-    # Money#exchange_to method is an example of this. It returns a new value object instead of changing
-    # its own values. Active Record won't persist value objects that have been changed through means
-    # other than the writer method.
-    #
-    # The immutable requirement is enforced by Active Record by freezing any object assigned as a value
-    # object. Attempting to change it afterwards will result in a RuntimeError.
-    #
-    # Read more about value objects on http://c2.com/cgi/wiki?ValueObject and on the dangers of not
-    # keeping value objects immutable on http://c2.com/cgi/wiki?ValueObjectsShouldBeImmutable
-    #
-    # == Custom constructors and converters
-    #
-    # By default value objects are initialized by calling the <tt>new</tt> constructor of the value
-    # class passing each of the mapped attributes, in the order specified by the <tt>:mapping</tt>
-    # option, as arguments. If the value class doesn't support this convention then +composed_of+ allows
-    # a custom constructor to be specified.
-    #
-    # When a new value is assigned to the value object, the default assumption is that the new value
-    # is an instance of the value class. Specifying a custom converter allows the new value to be automatically
-    # converted to an instance of value class if necessary.
-    #
-    # For example, the NetworkResource model has +network_address+ and +cidr_range+ attributes that should be
-    # aggregated using the NetAddr::CIDR value class (http://www.ruby-doc.org/gems/docs/n/netaddr-1.5.0/NetAddr/CIDR.html).
-    # The constructor for the value class is called +create+ and it expects a CIDR address string as a parameter.
-    # New values can be assigned to the value object using either another NetAddr::CIDR object, a string
-    # or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to meet
-    # these requirements:
-    #
-    #   class NetworkResource < ActiveRecord::Base
-    #     composed_of :cidr,
-    #                 class_name: 'NetAddr::CIDR',
-    #                 mapping: [ %w(network_address network), %w(cidr_range bits) ],
-    #                 allow_nil: true,
-    #                 constructor: Proc.new { |network_address, cidr_range| NetAddr::CIDR.create("#{network_address}/#{cidr_range}") },
-    #                 converter: Proc.new { |value| NetAddr::CIDR.create(value.is_a?(Array) ? value.join('/') : value) }
-    #   end
-    #
-    #   # This calls the :constructor
-    #   network_resource = NetworkResource.new(network_address: '192.168.0.1', cidr_range: 24)
-    #
-    #   # These assignments will both use the :converter
-    #   network_resource.cidr = [ '192.168.2.1', 8 ]
-    #   network_resource.cidr = '192.168.0.1/24'
-    #
-    #   # This assignment won't use the :converter as the value is already an instance of the value class
-    #   network_resource.cidr = NetAddr::CIDR.create('192.168.2.1/8')
-    #
-    #   # Saving and then reloading will use the :constructor on reload
-    #   network_resource.save
-    #   network_resource.reload
-    #
-    # == Finding records by a value object
-    #
-    # Once a +composed_of+ relationship is specified for a model, records can be loaded from the database
-    # by specifying an instance of the value object in the conditions hash. The following example
-    # finds all customers with +balance_amount+ equal to 20 and +balance_currency+ equal to "USD":
-    #
-    #   Customer.where(balance: Money.new(20, "USD"))
-    #
-    module ClassMethods
-      # Adds reader and writer methods for manipulating a value object:
-      # <tt>composed_of :address</tt> adds <tt>address</tt> and <tt>address=(new_address)</tt> methods.
-      #
-      # Options are:
-      # * <tt>:class_name</tt> - Specifies the class name of the association. Use it only if that name
-      #   can't be inferred from the part id. So <tt>composed_of :address</tt> will by default be linked
-      #   to the Address class, but if the real class name is CompanyAddress, you'll have to specify it
-      #   with this option.
-      # * <tt>:mapping</tt> - Specifies the mapping of entity attributes to attributes of the value
-      #   object. Each mapping is represented as an array where the first item is the name of the
-      #   entity attribute and the second item is the name of the attribute in the value object. The
-      #   order in which mappings are defined determines the order in which attributes are sent to the
-      #   value class constructor.
-      # * <tt>:allow_nil</tt> - Specifies that the value object will not be instantiated when all mapped
-      #   attributes are +nil+. Setting the value object to +nil+ has the effect of writing +nil+ to all
-      #   mapped attributes.
-      #   This defaults to +false+.
-      # * <tt>:constructor</tt> - A symbol specifying the name of the constructor method or a Proc that
-      #   is called to initialize the value object. The constructor is passed all of the mapped attributes,
-      #   in the order that they are defined in the <tt>:mapping option</tt>, as arguments and uses them
-      #   to instantiate a <tt>:class_name</tt> object.
-      #   The default is <tt>:new</tt>.
-      # * <tt>:converter</tt> - A symbol specifying the name of a class method of <tt>:class_name</tt>
-      #   or a Proc that is called when a new value is assigned to the value object. The converter is
-      #   passed the single value that is used in the assignment and is only called if the new value is
-      #   not an instance of <tt>:class_name</tt>. If <tt>:allow_nil</tt> is set to true, the converter
-      #   can return nil to skip the assignment.
-      #
-      # Option examples:
-      #   composed_of :temperature, mapping: %w(reading celsius)
-      #   composed_of :balance, class_name: "Money", mapping: %w(balance amount),
-      #                         converter: Proc.new { |balance| balance.to_money }
-      #   composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
-      #   composed_of :gps_location
-      #   composed_of :gps_location, allow_nil: true
-      #   composed_of :ip_address,
-      #               class_name: 'IPAddr',
-      #               mapping: %w(ip to_i),
-      #               constructor: Proc.new { |ip| IPAddr.new(ip, Socket::AF_INET) },
-      #               converter: Proc.new { |ip| ip.is_a?(Integer) ? IPAddr.new(ip, Socket::AF_INET) : IPAddr.new(ip.to_s) }
-      #
-      def composed_of(part_id, options = {})
-        options.assert_valid_keys(:class_name, :mapping, :allow_nil, :constructor, :converter)
+    def reload(*) # :nodoc:
+      clear_aggregation_cache
+      super
+    end
 
-        name        = part_id.id2name
-        class_name  = options[:class_name]  || name.camelize
-        mapping     = options[:mapping]     || [ name, name ]
-        mapping     = [ mapping ] unless mapping.first.is_a?(Array)
-        allow_nil   = options[:allow_nil]   || false
-        constructor = options[:constructor] || :new
-        converter   = options[:converter]
+    private
 
-        reader_method(name, class_name, mapping, allow_nil, constructor)
-        writer_method(name, class_name, mapping, allow_nil, converter)
+      def clear_aggregation_cache
+        @aggregation_cache.clear if persisted?
+      end
 
-        reflection = ActiveRecord::Reflection.create(:composed_of, part_id, nil, options, self)
-        Reflection.add_aggregate_reflection self, part_id, reflection
+      def init_internals
+        @aggregation_cache = {}
+        super
       end
 
-      private
-        def reader_method(name, class_name, mapping, allow_nil, constructor)
-          define_method(name) do
-            if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? {|key, _| !_read_attribute(key).nil? })
-              attrs = mapping.collect {|key, _| _read_attribute(key)}
-              object = constructor.respond_to?(:call) ?
-                constructor.call(*attrs) :
-                class_name.constantize.send(constructor, *attrs)
-              @aggregation_cache[name] = object
-            end
-            @aggregation_cache[name]
+      # Active Record implements aggregation through a macro-like class method called #composed_of
+      # for representing attributes as value objects. It expresses relationships like "Account [is]
+      # composed of Money [among other things]" or "Person [is] composed of [an] address". Each call
+      # to the macro adds a description of how the value objects are created from the attributes of
+      # the entity object (when the entity is initialized either as a new object or from finding an
+      # existing object) and how it can be turned back into attributes (when the entity is saved to
+      # the database).
+      #
+      #   class Customer < ActiveRecord::Base
+      #     composed_of :balance, class_name: "Money", mapping: %w(balance amount)
+      #     composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
+      #   end
+      #
+      # The customer class now has the following methods to manipulate the value objects:
+      # * <tt>Customer#balance, Customer#balance=(money)</tt>
+      # * <tt>Customer#address, Customer#address=(address)</tt>
+      #
+      # These methods will operate with value objects like the ones described below:
+      #
+      #  class Money
+      #    include Comparable
+      #    attr_reader :amount, :currency
+      #    EXCHANGE_RATES = { "USD_TO_DKK" => 6 }
+      #
+      #    def initialize(amount, currency = "USD")
+      #      @amount, @currency = amount, currency
+      #    end
+      #
+      #    def exchange_to(other_currency)
+      #      exchanged_amount = (amount * EXCHANGE_RATES["#{currency}_TO_#{other_currency}"]).floor
+      #      Money.new(exchanged_amount, other_currency)
+      #    end
+      #
+      #    def ==(other_money)
+      #      amount == other_money.amount && currency == other_money.currency
+      #    end
+      #
+      #    def <=>(other_money)
+      #      if currency == other_money.currency
+      #        amount <=> other_money.amount
+      #      else
+      #        amount <=> other_money.exchange_to(currency).amount
+      #      end
+      #    end
+      #  end
+      #
+      #  class Address
+      #    attr_reader :street, :city
+      #    def initialize(street, city)
+      #      @street, @city = street, city
+      #    end
+      #
+      #    def close_to?(other_address)
+      #      city == other_address.city
+      #    end
+      #
+      #    def ==(other_address)
+      #      city == other_address.city && street == other_address.street
+      #    end
+      #  end
+      #
+      # Now it's possible to access attributes from the database through the value objects instead. If
+      # you choose to name the composition the same as the attribute's name, it will be the only way to
+      # access that attribute. That's the case with our +balance+ attribute. You interact with the value
+      # objects just like you would with any other attribute:
+      #
+      #   customer.balance = Money.new(20)     # sets the Money value object and the attribute
+      #   customer.balance                     # => Money value object
+      #   customer.balance.exchange_to("DKK")  # => Money.new(120, "DKK")
+      #   customer.balance > Money.new(10)     # => true
+      #   customer.balance == Money.new(20)    # => true
+      #   customer.balance < Money.new(5)      # => false
+      #
+      # Value objects can also be composed of multiple attributes, such as the case of Address. The order
+      # of the mappings will determine the order of the parameters.
+      #
+      #   customer.address_street = "Hyancintvej"
+      #   customer.address_city   = "Copenhagen"
+      #   customer.address        # => Address.new("Hyancintvej", "Copenhagen")
+      #
+      #   customer.address = Address.new("May Street", "Chicago")
+      #   customer.address_street # => "May Street"
+      #   customer.address_city   # => "Chicago"
+      #
+      # == Writing value objects
+      #
+      # Value objects are immutable and interchangeable objects that represent a given value, such as
+      # a Money object representing $5. Two Money objects both representing $5 should be equal (through
+      # methods such as <tt>==</tt> and <tt><=></tt> from Comparable if ranking makes sense). This is
+      # unlike entity objects where equality is determined by identity. An entity class such as Customer can
+      # easily have two different objects that both have an address on Hyancintvej. Entity identity is
+      # determined by object or relational unique identifiers (such as primary keys). Normal
+      # ActiveRecord::Base classes are entity objects.
+      #
+      # It's also important to treat the value objects as immutable. Don't allow the Money object to have
+      # its amount changed after creation. Create a new Money object with the new value instead. The
+      # <tt>Money#exchange_to</tt> method is an example of this. It returns a new value object instead of changing
+      # its own values. Active Record won't persist value objects that have been changed through means
+      # other than the writer method.
+      #
+      # The immutable requirement is enforced by Active Record by freezing any object assigned as a value
+      # object. Attempting to change it afterwards will result in a +RuntimeError+.
+      #
+      # Read more about value objects on http://c2.com/cgi/wiki?ValueObject and on the dangers of not
+      # keeping value objects immutable on http://c2.com/cgi/wiki?ValueObjectsShouldBeImmutable
+      #
+      # == Custom constructors and converters
+      #
+      # By default value objects are initialized by calling the <tt>new</tt> constructor of the value
+      # class passing each of the mapped attributes, in the order specified by the <tt>:mapping</tt>
+      # option, as arguments. If the value class doesn't support this convention then #composed_of allows
+      # a custom constructor to be specified.
+      #
+      # When a new value is assigned to the value object, the default assumption is that the new value
+      # is an instance of the value class. Specifying a custom converter allows the new value to be automatically
+      # converted to an instance of value class if necessary.
+      #
+      # For example, the +NetworkResource+ model has +network_address+ and +cidr_range+ attributes that should be
+      # aggregated using the +NetAddr::CIDR+ value class (http://www.rubydoc.info/gems/netaddr/1.5.0/NetAddr/CIDR).
+      # The constructor for the value class is called +create+ and it expects a CIDR address string as a parameter.
+      # New values can be assigned to the value object using either another +NetAddr::CIDR+ object, a string
+      # or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to meet
+      # these requirements:
+      #
+      #   class NetworkResource < ActiveRecord::Base
+      #     composed_of :cidr,
+      #                 class_name: 'NetAddr::CIDR',
+      #                 mapping: [ %w(network_address network), %w(cidr_range bits) ],
+      #                 allow_nil: true,
+      #                 constructor: Proc.new { |network_address, cidr_range| NetAddr::CIDR.create("#{network_address}/#{cidr_range}") },
+      #                 converter: Proc.new { |value| NetAddr::CIDR.create(value.is_a?(Array) ? value.join('/') : value) }
+      #   end
+      #
+      #   # This calls the :constructor
+      #   network_resource = NetworkResource.new(network_address: '192.168.0.1', cidr_range: 24)
+      #
+      #   # These assignments will both use the :converter
+      #   network_resource.cidr = [ '192.168.2.1', 8 ]
+      #   network_resource.cidr = '192.168.0.1/24'
+      #
+      #   # This assignment won't use the :converter as the value is already an instance of the value class
+      #   network_resource.cidr = NetAddr::CIDR.create('192.168.2.1/8')
+      #
+      #   # Saving and then reloading will use the :constructor on reload
+      #   network_resource.save
+      #   network_resource.reload
+      #
+      # == Finding records by a value object
+      #
+      # Once a #composed_of relationship is specified for a model, records can be loaded from the database
+      # by specifying an instance of the value object in the conditions hash. The following example
+      # finds all customers with +address_street+ equal to "May Street" and +address_city+ equal to "Chicago":
+      #
+      #   Customer.where(address: Address.new("May Street", "Chicago"))
+      #
+      module ClassMethods
+        # Adds reader and writer methods for manipulating a value object:
+        # <tt>composed_of :address</tt> adds <tt>address</tt> and <tt>address=(new_address)</tt> methods.
+        #
+        # Options are:
+        # * <tt>:class_name</tt> - Specifies the class name of the association. Use it only if that name
+        #   can't be inferred from the part id. So <tt>composed_of :address</tt> will by default be linked
+        #   to the Address class, but if the real class name is +CompanyAddress+, you'll have to specify it
+        #   with this option.
+        # * <tt>:mapping</tt> - Specifies the mapping of entity attributes to attributes of the value
+        #   object. Each mapping is represented as an array where the first item is the name of the
+        #   entity attribute and the second item is the name of the attribute in the value object. The
+        #   order in which mappings are defined determines the order in which attributes are sent to the
+        #   value class constructor.
+        # * <tt>:allow_nil</tt> - Specifies that the value object will not be instantiated when all mapped
+        #   attributes are +nil+. Setting the value object to +nil+ has the effect of writing +nil+ to all
+        #   mapped attributes.
+        #   This defaults to +false+.
+        # * <tt>:constructor</tt> - A symbol specifying the name of the constructor method or a Proc that
+        #   is called to initialize the value object. The constructor is passed all of the mapped attributes,
+        #   in the order that they are defined in the <tt>:mapping option</tt>, as arguments and uses them
+        #   to instantiate a <tt>:class_name</tt> object.
+        #   The default is <tt>:new</tt>.
+        # * <tt>:converter</tt> - A symbol specifying the name of a class method of <tt>:class_name</tt>
+        #   or a Proc that is called when a new value is assigned to the value object. The converter is
+        #   passed the single value that is used in the assignment and is only called if the new value is
+        #   not an instance of <tt>:class_name</tt>. If <tt>:allow_nil</tt> is set to true, the converter
+        #   can return +nil+ to skip the assignment.
+        #
+        # Option examples:
+        #   composed_of :temperature, mapping: %w(reading celsius)
+        #   composed_of :balance, class_name: "Money", mapping: %w(balance amount)
+        #   composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
+        #   composed_of :gps_location
+        #   composed_of :gps_location, allow_nil: true
+        #   composed_of :ip_address,
+        #               class_name: 'IPAddr',
+        #               mapping: %w(ip to_i),
+        #               constructor: Proc.new { |ip| IPAddr.new(ip, Socket::AF_INET) },
+        #               converter: Proc.new { |ip| ip.is_a?(Integer) ? IPAddr.new(ip, Socket::AF_INET) : IPAddr.new(ip.to_s) }
+        #
+        def composed_of(part_id, options = {})
+          options.assert_valid_keys(:class_name, :mapping, :allow_nil, :constructor, :converter)
+
+          unless self < Aggregations
+            include Aggregations
           end
-        end
 
-        def writer_method(name, class_name, mapping, allow_nil, converter)
-          define_method("#{name}=") do |part|
-            klass = class_name.constantize
+          name        = part_id.id2name
+          class_name  = options[:class_name]  || name.camelize
+          mapping     = options[:mapping]     || [ name, name ]
+          mapping     = [ mapping ] unless mapping.first.is_a?(Array)
+          allow_nil   = options[:allow_nil]   || false
+          constructor = options[:constructor] || :new
+          converter   = options[:converter]
 
-            unless part.is_a?(klass) || converter.nil? || part.nil?
-              part = converter.respond_to?(:call) ? converter.call(part) : klass.send(converter, part)
-            end
+          reader_method(name, class_name, mapping, allow_nil, constructor)
+          writer_method(name, class_name, mapping, allow_nil, converter)
 
-            hash_from_multiparameter_assignment = part.is_a?(Hash) &&
-              part.each_key.all? { |k| k.is_a?(Integer) }
-            if hash_from_multiparameter_assignment
-              part = klass.new(*part.values)
+          reflection = ActiveRecord::Reflection.create(:composed_of, part_id, nil, options, self)
+          Reflection.add_aggregate_reflection self, part_id, reflection
+        end
+
+        private
+          def reader_method(name, class_name, mapping, allow_nil, constructor)
+            define_method(name) do
+              if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? { |key, _| !_read_attribute(key).nil? })
+                attrs = mapping.collect { |key, _| _read_attribute(key) }
+                object = constructor.respond_to?(:call) ?
+                  constructor.call(*attrs) :
+                  class_name.constantize.send(constructor, *attrs)
+                @aggregation_cache[name] = object
+              end
+              @aggregation_cache[name]
             end
+          end
 
-            if part.nil? && allow_nil
-              mapping.each { |key, _| self[key] = nil }
-              @aggregation_cache[name] = nil
-            else
-              mapping.each { |key, value| self[key] = part.send(value) }
-              @aggregation_cache[name] = part.freeze
+          def writer_method(name, class_name, mapping, allow_nil, converter)
+            define_method("#{name}=") do |part|
+              klass = class_name.constantize
+
+              unless part.is_a?(klass) || converter.nil? || part.nil?
+                part = converter.respond_to?(:call) ? converter.call(part) : klass.send(converter, part)
+              end
+
+              hash_from_multiparameter_assignment = part.is_a?(Hash) &&
+                part.each_key.all? { |k| k.is_a?(Integer) }
+              if hash_from_multiparameter_assignment
+                raise ArgumentError unless part.size == part.each_key.max
+                part = klass.new(*part.sort.map(&:last))
+              end
+
+              if part.nil? && allow_nil
+                mapping.each { |key, _| self[key] = nil }
+                @aggregation_cache[name] = nil
+              else
+                mapping.each { |key, value| self[key] = part.send(value) }
+                @aggregation_cache[name] = part.freeze
+              end
             end
           end
-        end
-    end
+      end
   end
 end