activerecord 3.2.19 → 5.0.0

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2011 David Heinemeier Hansson
+Copyright (c) 2004-2016 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -17,4 +17,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

@@ -1,4 +1,4 @@
-= Active Record -- Object-relational mapping put on rails
+= Active Record -- Object-relational mapping in Rails
 
 Active Record connects classes to relational database tables to establish an
 almost zero-configuration persistence layer for applications. The library
@@ -20,19 +20,19 @@ A short rundown of some of the major features:
    class Product < ActiveRecord::Base
    end
 
-   The Product class is automatically mapped to the table named "products",
-   which might look like this:
+  {Learn more}[link:classes/ActiveRecord/Base.html]
+
+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 int NOT NULL auto_increment,
      name varchar(255),
      PRIMARY KEY  (id)
    );
 
-   This would also define the following accessors: `Product#name` and
-   `Product#name=(new_name)`
-
-  {Learn more}[link:classes/ActiveRecord/Base.html]
+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.
@@ -49,10 +49,10 @@ A short rundown of some of the major features:
 * Aggregations of value objects.
 
    class Account < ActiveRecord::Base
-     composed_of :balance, :class_name => "Money",
-                 :mapping => %w(balance amount)
+     composed_of :balance, class_name: 'Money',
+                 mapping: %w(balance amount)
      composed_of :address,
-                 :mapping => [%w(address_street street), %w(address_city city)]
+                 mapping: [%w(address_street street), %w(address_city city)]
    end
 
   {Learn more}[link:classes/ActiveRecord/Aggregations/ClassMethods.html]
@@ -61,10 +61,10 @@ A short rundown of some of the major features:
 * Validation rules that can differ for new or existing objects.
 
     class Account < ActiveRecord::Base
-      validates_presence_of     :subdomain, :name, :email_address, :password
-      validates_uniqueness_of   :subdomain
-      validates_acceptance_of   :terms_of_service, :on => :create
-      validates_confirmation_of :password, :email_address, :on => :create
+      validates :subdomain, :name, :email_address, :password, presence: true
+      validates :subdomain, uniqueness: true
+      validates :terms_of_service, acceptance: true, on: :create
+      validates :password, :email_address, confirmation: true, on: :create
     end
 
   {Learn more}[link:classes/ActiveRecord/Validations.html]
@@ -80,17 +80,6 @@ A short rundown of some of the major features:
   {Learn more}[link:classes/ActiveRecord/Callbacks.html]
 
 
-* Observers that react to changes in a model.
-
-   class CommentObserver < ActiveRecord::Observer
-     def after_create(comment) # is called just after Comment#save
-       CommentMailer.new_comment_email("david@loudthinking.com", comment).deliver
-     end
-   end
-
-  {Learn more}[link:classes/ActiveRecord/Observer.html]
-
-
 * Inheritance hierarchies.
 
    class Company < ActiveRecord::Base; end
@@ -124,32 +113,32 @@ A short rundown of some of the major features:
 * Database abstraction through simple adapters.
 
     # connect to SQLite3
-    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => "dbfile.sqlite3")
+    ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: 'dbfile.sqlite3')
 
     # connect to MySQL with authentication
     ActiveRecord::Base.establish_connection(
-      :adapter  => "mysql2",
-      :host     => "localhost",
-      :username => "me",
-      :password => "secret",
-      :database => "activerecord"
+      adapter:  'mysql2',
+      host:     'localhost',
+      username: 'me',
+      password: 'secret',
+      database: 'activerecord'
     )
 
   {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].
 
 
-* Logging support for Log4r[http://log4r.sourceforge.net] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc].
+* Logging support for Log4r[https://github.com/colbygk/log4r] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc].
 
-    ActiveRecord::Base.logger = Logger.new(STDOUT)
-    ActiveRecord::Base.logger = Log4r::Logger.new("Application Log")
+    ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT)
+    ActiveRecord::Base.logger = Log4r::Logger.new('Application Log')
 
 
 * 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
@@ -159,7 +148,7 @@ A short rundown of some of the major features:
           t.integer :position
         end
 
-        SystemSetting.create :name => "notice", :label => "Use notice?", :value => 1
+        SystemSetting.create name: 'notice', label: 'Use notice?', value: 1
       end
 
       def down
@@ -186,7 +175,7 @@ by relying on a number of conventions that make it easy for Active Record to inf
 complex relations and structures from a minimal amount of explicit direction.
 
 Convention over Configuration:
-* No XML-files!
+* No XML files!
 * Lots of reflection and run-time extension
 * Magic is not inherently a bad word
 
@@ -199,24 +188,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
+Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/3-2-stable/activerecord
+* https://github.com/rails/rails/tree/master/activerecord
 
 
 == License
 
-Active Record is released under the MIT license.
+Active Record is released under the MIT license:
+
+* http://www.opensource.org/licenses/MIT
 
 
 == Support
 
-API documentation is at
+API documentation is at:
 
 * http://api.rubyonrails.org
 
-Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:
+Bug reports can be filed for the Ruby on Rails project 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,16 +1,15 @@
-require File.expand_path('../../../load_paths', __FILE__)
 require "active_record"
 require 'benchmark/ips'
 
 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)
 
 class User < ActiveRecord::Base
-  connection.create_table :users, :force => true do |t|
+  connection.create_table :users, force: true do |t|
     t.string :name, :email
     t.timestamps
   end
@@ -19,7 +18,7 @@ class User < ActiveRecord::Base
 end
 
 class Exhibit < ActiveRecord::Base
-  connection.create_table :exhibits, :force => true do |t|
+  connection.create_table :exhibits, force: true do |t|
     t.belongs_to :user
     t.string :name
     t.text :notes
@@ -39,10 +38,12 @@ 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
+
 puts 'Generating data...'
 
 module ActiveRecord
@@ -75,30 +76,32 @@ notes = ActiveRecord::Faker::LOREM.join ' '
 today = Date.today
 
 puts "Inserting #{RECORDS} users and exhibits..."
-RECORDS.times do
+RECORDS.times do |record|
   user = User.create(
-    :created_at => today,
-    :name       => ActiveRecord::Faker.name,
-    :email      => ActiveRecord::Faker.email
+    created_at: today,
+    name: ActiveRecord::Faker.name,
+    email: ActiveRecord::Faker.email
   )
 
   Exhibit.create(
-    :created_at => today,
-    :name       => ActiveRecord::Faker.name,
-    :user       => user,
-    :notes      => notes
+    created_at: today,
+    name: ActiveRecord::Faker.name,
+    user: user,
+    notes: notes
   )
+  progress_bar(record)
 end
+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,
-    :created_at => Date.today
+    name: ActiveRecord::Faker.name,
+    notes: notes,
+    created_at: Date.today
   }
 
   x.report("Model#id") do
@@ -117,10 +120,18 @@ Benchmark.ips(TIME) do |x|
     Exhibit.first.look
   end
 
+  x.report 'Model.take' do 
+    Exhibit.take
+  end
+  
   x.report("Model.all limit(100)") do
     Exhibit.look Exhibit.limit(100)
   end
 
+  x.report("Model.all take(100)") do
+    Exhibit.look Exhibit.take(100)
+  end
+
   x.report "Model.all limit(100) with relationship" do
     Exhibit.feel Exhibit.limit(100).includes(:user)
   end
@@ -143,7 +154,7 @@ Benchmark.ips(TIME) do |x|
   end
 
   x.report 'Resource#update' do
-    Exhibit.first.update_attributes(:name => 'bob')
+    Exhibit.first.update(name: 'bob')
   end
 
   x.report 'Resource#destroy' do
@@ -167,6 +178,6 @@ Benchmark.ips(TIME) do |x|
   end
 
   x.report "AR.execute(query)" do
-    ActiveRecord::Base.connection.execute("Select * from exhibits where id = #{(rand * 1000 + 1).to_i}")
+    ActiveRecord::Base.connection.execute("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}")
   end
 end

data/examples/simple.rb

@@ -1,14 +1,13 @@
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
 require 'active_record'
 
 class Person < ActiveRecord::Base
-  establish_connection :adapter => 'sqlite3', :database => 'foobar.db'
-  connection.create_table table_name, :force => true do |t|
+  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/aggregations.rb

@@ -1,23 +1,40 @@
 module ActiveRecord
-  # = Active Record Aggregations
-  module Aggregations # :nodoc:
+  # See ActiveRecord::Aggregations::ClassMethods for documentation
+  module Aggregations
     extend ActiveSupport::Concern
 
-    def clear_aggregation_cache #:nodoc:
-      @aggregation_cache.clear if persisted?
+    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]
+    def reload(*) # :nodoc:
+      clear_aggregation_cache
+      super
+    end
+
+    private
+
+      def clear_aggregation_cache # :nodoc:
+        @aggregation_cache.clear if persisted?
+      end
+
+      def init_internals # :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
+    # 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) ]
+    #     composed_of :balance, class_name: "Money", mapping: %w(amount currency)
+    #     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:
@@ -71,7 +88,7 @@ module ActiveRecord
     # 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 any other attribute, though:
+    # 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
@@ -86,6 +103,7 @@ module ActiveRecord
     #   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"
@@ -101,13 +119,13 @@ module ActiveRecord
     # 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. This
-    # is exemplified by the Money#exchange_to method that returns a new value object instead of changing
+    # 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 ActiveSupport::FrozenObjectError.
+    # 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
@@ -116,31 +134,31 @@ module ActiveRecord
     #
     # 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
+    # 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
+    # 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://netaddr.rubyforge.org). 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
+    # 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) }
+    #                 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)
+    #   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 ]
@@ -155,11 +173,11 @@ module ActiveRecord
     #
     # == Finding records by a value object
     #
-    # Once a +composed_of+ relationship is specified for a model, records can be loaded from the database
+    # 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")).all
+    #   Customer.where(balance: Money.new(20, "USD"))
     #
     module ClassMethods
       # Adds reader and writer methods for manipulating a value object:
@@ -168,7 +186,7 @@ module ActiveRecord
       # 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
+      #   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
@@ -187,20 +205,21 @@ module ActiveRecord
       # * <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>.
+      #   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 :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 :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) }
+      #               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)
@@ -216,14 +235,15 @@ module ActiveRecord
         reader_method(name, class_name, mapping, allow_nil, constructor)
         writer_method(name, class_name, mapping, allow_nil, converter)
 
-        create_reflection(:composed_of, part_id, options, self)
+        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? {|pair| !read_attribute(pair.first).nil? })
-              attrs = mapping.collect {|pair| read_attribute(pair.first)}
+            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)
@@ -235,17 +255,22 @@ module ActiveRecord
 
         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
+
+            if part.is_a?(Hash)
+              raise ArgumentError unless part.size == part.keys.max
+              part = klass.new(*part.sort.map(&:last))
+            end
+
             if part.nil? && allow_nil
-              mapping.each { |pair| self[pair.first] = nil }
+              mapping.each { |key, _| self[key] = nil }
               @aggregation_cache[name] = nil
             else
-              unless part.is_a?(class_name.constantize) || converter.nil?
-                part = converter.respond_to?(:call) ?
-                  converter.call(part) :
-                  class_name.constantize.send(converter, part)
-              end
-
-              mapping.each { |pair| self[pair.first] = part.send(pair.last) }
+              mapping.each { |key, value| self[key] = part.send(value) }
               @aggregation_cache[name] = part.freeze
             end
           end

data/lib/active_record/association_relation.rb

@@ -0,0 +1,35 @@
+module ActiveRecord
+  class AssociationRelation < Relation
+    def initialize(klass, table, predicate_builder, association)
+      super(klass, table, predicate_builder)
+      @association = association
+    end
+
+    def proxy_association
+      @association
+    end
+
+    def ==(other)
+      other == records
+    end
+
+    def build(*args, &block)
+      scoping { @association.build(*args, &block) }
+    end
+    alias new build
+
+    def create(*args, &block)
+      scoping { @association.create(*args, &block) }
+    end
+
+    def create!(*args, &block)
+      scoping { @association.create!(*args, &block) }
+    end
+
+    private
+
+    def exec_queries
+      super.each { |r| @association.set_inverse_instance r }
+    end
+  end
+end