activerecord 3.0.0.rc → 3.0.0.rc2

data/CHANGELOG

@@ -1,3 +1,8 @@
+*Rails 3.0.0 [release candidate 2] (August 23rd, 2010)*
+
+* No material changes (see http://github.com/rails/rails/compare/v3.0.0_RC...v3.0.0_RC2 for gory details)
+
+
 *Rails 3.0.0 [release candidate] (July 26th, 2010)*
 
 * Changed update_attribute to not run callbacks and update the record directly in the database [Neeraj Singh]
@@ -966,7 +971,7 @@ during calendar reform.  #7649, #7724 [fedot, Geoff Buesing]
 * Made increment_counter/decrement_counter play nicely with optimistic locking, and added a more general update_counters method [Jamis Buck]
 
 * Reworked David's query cache to be available as Model.cache {...}. For the duration of the block no select query should be run more then once. Any inserts/deletes/executes will flush the whole cache however [Tobias Lütke]
-  Task.cache { Task.find(1); Task.find(1) } #=> 1 query
+  Task.cache { Task.find(1); Task.find(1) } # => 1 query
 
 * When dealing with SQLite3, use the table_info pragma helper, so that the bindings can do some translation for when sqlite3 breaks incompatibly between point releases. [Jamis Buck]
 

data/README.rdoc

@@ -19,19 +19,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:
-   
+
    CREATE TABLE products (
      id int(11) 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]
 
 
@@ -51,7 +51,7 @@ A short rundown of some of the major features:
    class Account < ActiveRecord::Base
      composed_of :balance, :class_name => "Money",
                  :mapping => %w(balance amount)
-     composed_of :address, 
+     composed_of :address,
                  :mapping => [%w(address_street street), %w(address_city city)]
    end
 
@@ -91,7 +91,7 @@ A short rundown of some of the major features:
   {Learn more}[link:classes/ActiveRecord/Observer.html]
 
 
-* Inheritance hierarchies 
+* Inheritance hierarchies
 
    class Company < ActiveRecord::Base; end
    class Firm < Company; end
@@ -170,7 +170,7 @@ A short rundown of some of the major features:
   {Learn more}[link:classes/ActiveRecord/Migration.html]
 
 
-== Philosophy 
+== Philosophy
 
 Active Record is an implementation of the object-relational mapping (ORM)
 pattern[http://www.martinfowler.com/eaaCatalog/activeRecord.html] by the same
@@ -179,7 +179,7 @@ name described by Martin Fowler:
   "An object that wraps a row in a database table or view,
   encapsulates the database access, and adds domain logic on that data."
 
-Active Record attempts to provide a coherent wrapper as a solution for the inconvenience that is 
+Active Record attempts to provide a coherent wrapper as a solution for the inconvenience that is
 object-relational mapping. The prime directive for this mapping has been to minimize
 the amount of code needed to build a real-world domain model. This is made possible
 by relying on a number of conventions that make it easy for Active Record to infer
@@ -188,7 +188,7 @@ complex relations and structures from a minimal amount of explicit direction.
 Convention over Configuration:
 * No XML-files!
 * Lots of reflection and run-time extension
-* Magic is not inherently a bad word 
+* Magic is not inherently a bad word
 
 Admit the Database:
 * Lets you drop down to SQL for odd cases and performance

data/lib/active_record/aggregations.rb

@@ -9,11 +9,13 @@ module ActiveRecord
       end unless self.new_record?
     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). Example:
+    # 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)
@@ -68,9 +70,10 @@ module ActiveRecord
     #    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 any other attribute, though:
+    # 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:
     #
     #   customer.balance = Money.new(20)     # sets the Money value object and the attribute
     #   customer.balance                     # => Money value object
@@ -79,8 +82,8 @@ module ActiveRecord
     #   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. Example:
+    # 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"
@@ -91,38 +94,43 @@ module ActiveRecord
     #
     # == 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.
+    # 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. This is exemplified by the Money#exchange_to method that
-    # 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.
+    # 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 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.
+    # 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.
     #
-    # 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
+    # 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.
+    # 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.
+    # 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 or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to
-    # meet these requirements:
+    # 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
+    # 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,
@@ -149,9 +157,9 @@ 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 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":
+    # 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.find(:all, :conditions => {:balance => Money.new(20, "USD")})
     #
@@ -160,23 +168,28 @@ module ActiveRecord
       # <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 the attribute in the value object. The order in which mappings are defined determine the order in which
-      #   attributes are sent to the value class constructor.
+      # * <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 the attribute in the value object. The
+      #   order in which mappings are defined determine 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.
+      #   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.
+      # * <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>.
+      # * <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>.
       #
       # Option examples:
       #   composed_of :temperature, :mapping => %w(reading celsius)

data/lib/active_record/association_preload.rb

@@ -9,8 +9,8 @@ module ActiveRecord
     # Implements the details of eager loading of Active Record associations.
     # Application developers should not use this module directly.
     #
-    # ActiveRecord::Base is extended with this module. The source code in
-    # ActiveRecord::Base references methods defined in this module.
+    # <tt>ActiveRecord::Base</tt> is extended with this module. The source code in
+    # <tt>ActiveRecord::Base</tt> references methods defined in this module.
     #
     # Note that 'eager loading' and 'preloading' are actually the same thing.
     # However, there are two different eager loading strategies.
@@ -55,7 +55,7 @@ module ActiveRecord
       # == Parameters
       # +records+ is an array of ActiveRecord::Base. This array needs not be flat,
       # i.e. +records+ itself may also contain arrays of records. In any case,
-      # +preload_associations+ will preload the associations all records by
+      # +preload_associations+ will preload the all associations records by
       # flattening +records+.
       #
       # +associations+ specifies one or more associations that you want to
@@ -110,8 +110,8 @@ module ActiveRecord
       def preload_one_association(records, association, preload_options={})
         class_to_reflection = {}
         # Not all records have the same class, so group then preload
-        # group on the reflection itself so that if various subclass share the same association then we do not split them
-        # unnecessarily
+        # group on the reflection itself so that if various subclass share the same association then
+        # we do not split them unnecessarily
         records.group_by { |record| class_to_reflection[record.class] ||= record.class.reflections[association]}.each do |reflection, _records|
           raise ConfigurationError, "Association named '#{ association }' was not found; perhaps you misspelled it?" unless reflection
 
@@ -149,7 +149,8 @@ module ActiveRecord
         seen_keys = {}
         associated_records.each do |associated_record|
           #this is a has_one or belongs_to: there should only be one record.
-          #Unfortunately we can't (in portable way) ask the database for 'all records where foo_id in (x,y,z), but please
+          #Unfortunately we can't (in portable way) ask the database for
+          #'all records where foo_id in (x,y,z), but please
           # only one row per distinct foo_id' so this where we enforce that
           next if seen_keys[associated_record[key].to_s]
           seen_keys[associated_record[key].to_s] = true
@@ -162,7 +163,7 @@ module ActiveRecord
 
         id_to_record_map.each do |id, records|
           next if seen_keys.include?(id.to_s)
-          records.each {|record| record.send("set_#{reflection_name}_target", nil) }            
+          records.each {|record| record.send("set_#{reflection_name}_target", nil) }
         end
       end
 
@@ -304,7 +305,8 @@ module ActiveRecord
           polymorph_type = options[:foreign_type]
           klasses_and_ids = {}
 
-          # Construct a mapping from klass to a list of ids to load and a mapping of those ids back to their parent_records
+          # Construct a mapping from klass to a list of ids to load and a mapping of those ids back
+          # to their parent_records
           records.each do |record|
             if klass = record.send(polymorph_type)
               klass_id = record.send(primary_key_name)
@@ -370,7 +372,7 @@ module ActiveRecord
         conditions << append_conditions(reflection, preload_options)
 
         find_options = {
-          :select => preload_options[:select] || options[:select] || "#{table_name}.*",
+          :select => preload_options[:select] || options[:select] || Arel::SqlLiteral.new("#{table_name}.*"),
           :include => preload_options[:include] || options[:include],
           :conditions => [conditions, ids],
           :joins => options[:joins],

data/lib/active_record/associations.rb

@@ -35,7 +35,7 @@ module ActiveRecord
       through_reflection      = reflection.through_reflection
       source_reflection_names = reflection.source_reflection_names
       source_associations     = reflection.through_reflection.klass.reflect_on_all_associations.collect { |a| a.name.inspect }
-      super("Could not find the source association(s) #{source_reflection_names.collect(&:inspect).to_sentence(:two_words_connector => ' or ', :last_word_connector => ', or ', :locale => :en)} in model #{through_reflection.klass}.  Try 'has_many #{reflection.name.inspect}, :through => #{through_reflection.name.inspect}, :source => <name>'.  Is it one of #{source_associations.to_sentence(:two_words_connector => ' or ', :last_word_connector => ', or ', :locale => :en)}?")
+      super("Could not find the source association(s) #{source_reflection_names.collect{ |a| a.inspect }.to_sentence(:two_words_connector => ' or ', :last_word_connector => ', or ', :locale => :en)} in model #{through_reflection.klass}.  Try 'has_many #{reflection.name.inspect}, :through => #{through_reflection.name.inspect}, :source => <name>'.  Is it one of #{source_associations.to_sentence(:two_words_connector => ' or ', :last_word_connector => ', or ', :locale => :en)}?")
     end
   end
 
@@ -114,7 +114,7 @@ module ActiveRecord
     autoload :HasOneAssociation, 'active_record/associations/has_one_association'
     autoload :HasOneThroughAssociation, 'active_record/associations/has_one_through_association'
 
-    # Clears out the association cache
+    # Clears out the association cache.
     def clear_association_cache #:nodoc:
       self.class.reflect_on_all_associations.to_a.each do |assoc|
         instance_variable_set "@#{assoc.name}", nil
@@ -122,7 +122,7 @@ module ActiveRecord
     end
 
     private
-      # Gets the specified association instance if it responds to :loaded?, nil otherwise.
+      # Returns the specified association instance if it responds to :loaded?, nil otherwise.
       def association_instance_get(name)
         ivar = "@#{name}"
         if instance_variable_defined?(ivar)
@@ -136,10 +136,12 @@ module ActiveRecord
         instance_variable_set("@#{name}", association)
       end
 
-    # Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like
-    # "Project has one Project Manager" or "Project belongs to a Portfolio". Each macro adds a number of methods to the class which are
-    # specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby's own <tt>attr*</tt>
-    # methods. Example:
+    # Associations are a set of macro-like class methods for tying objects together through
+    # foreign keys. They express relationships like "Project has one Project Manager"
+    # or "Project belongs to a Portfolio". Each macro adds a number of methods to the
+    # class which are specialized according to the collection or association symbol and the
+    # options hash. It works much the same way as Ruby's own <tt>attr*</tt>
+    # methods.
     #
     #   class Project < ActiveRecord::Base
     #     belongs_to              :portfolio
@@ -148,7 +150,8 @@ module ActiveRecord
     #     has_and_belongs_to_many :categories
     #   end
     #
-    # The project class now has the following methods (and more) to ease the traversal and manipulation of its relationships:
+    # The project class now has the following methods (and more) to ease the traversal and
+    # manipulation of its relationships:
     # * <tt>Project#portfolio, Project#portfolio=(portfolio), Project#portfolio.nil?</tt>
     # * <tt>Project#project_manager, Project#project_manager=(project_manager), Project#project_manager.nil?,</tt>
     # * <tt>Project#milestones.empty?, Project#milestones.size, Project#milestones, Project#milestones<<(milestone),</tt>
@@ -159,8 +162,9 @@ module ActiveRecord
     #
     # === A word of warning
     #
-    # Don't create associations that have the same name as instance methods of ActiveRecord::Base. Since the association
-    # adds a method with that name to its model, it will override the inherited method and break things.
+    # Don't create associations that have the same name as instance methods of
+    # <tt>ActiveRecord::Base</tt>. Since the association adds a method with that name to
+    # its model, it will override the inherited method and break things.
     # For instance, +attributes+ and +connection+ would be bad choices for association names.
     #
     # == Auto-generated methods
@@ -270,8 +274,8 @@ module ActiveRecord
     #
     # == Is it a +belongs_to+ or +has_one+ association?
     #
-    # Both express a 1-1 relationship. The difference is mostly where to place the foreign key, which goes on the table for the class
-    # declaring the +belongs_to+ relationship. Example:
+    # Both express a 1-1 relationship. The difference is mostly where to place the foreign
+    # key, which goes on the table for the class declaring the +belongs_to+ relationship.
     #
     #   class User < ActiveRecord::Base
     #     # I reference an account.
@@ -300,36 +304,45 @@ module ActiveRecord
     #
     # == Unsaved objects and associations
     #
-    # You can manipulate objects and associations before they are saved to the database, but there is some special behavior you should be
-    # aware of, mostly involving the saving of associated objects.
+    # You can manipulate objects and associations before they are saved to the database, but
+    # there is some special behavior you should be aware of, mostly involving the saving of
+    # associated objects.
     #
-    # Unless you set the :autosave option on a <tt>has_one</tt>, <tt>belongs_to</tt>,
+    # You can set the :autosave option on a <tt>has_one</tt>, <tt>belongs_to</tt>,
     # <tt>has_many</tt>, or <tt>has_and_belongs_to_many</tt> association. Setting it
     # to +true+ will _always_ save the members, whereas setting it to +false+ will
-    # _never_ save the members.
+    # _never_ save the members. More details about :autosave option is available at
+    # autosave_association.rb .
     #
     # === One-to-one associations
     #
-    # * Assigning an object to a +has_one+ association automatically saves that object and the object being replaced (if there is one), in
-    #   order to update their primary keys - except if the parent object is unsaved (<tt>new_record? == true</tt>).
-    # * If either of these saves fail (due to one of the objects being invalid) the assignment statement returns +false+ and the assignment
-    #   is cancelled.
-    # * If you wish to assign an object to a +has_one+ association without saving it, use the <tt>association.build</tt> method (documented below).
-    # * Assigning an object to a +belongs_to+ association does not save the object, since the foreign key field belongs on the parent. It
-    #   does not save the parent either.
+    # * Assigning an object to a +has_one+ association automatically saves that object and
+    # the object being replaced (if there is one), in order to update their primary
+    # keys - except if the parent object is unsaved (<tt>new_record? == true</tt>).
+    # * If either of these saves fail (due to one of the objects being invalid) the assignment
+    # statement returns +false+ and the assignment is cancelled.
+    # * If you wish to assign an object to a +has_one+ association without saving it,
+    # use the <tt>association.build</tt> method (documented below).
+    # * Assigning an object to a +belongs_to+ association does not save the object, since
+    # the foreign key field belongs on the parent. It does not save the parent either.
     #
     # === Collections
     #
-    # * Adding an object to a collection (+has_many+ or +has_and_belongs_to_many+) automatically saves that object, except if the parent object
-    #   (the owner of the collection) is not yet stored in the database.
-    # * If saving any of the objects being added to a collection (via <tt>push</tt> or similar) fails, then <tt>push</tt> returns +false+.
-    # * You can add an object to a collection without automatically saving it by using the <tt>collection.build</tt> method (documented below).
-    # * All unsaved (<tt>new_record? == true</tt>) members of the collection are automatically saved when the parent is saved.
+    # * Adding an object to a collection (+has_many+ or +has_and_belongs_to_many+) automatically
+    # saves that object, except if the parent object (the owner of the collection) is not yet
+    # stored in the database.
+    # * If saving any of the objects being added to a collection (via <tt>push</tt> or similar)
+    # fails, then <tt>push</tt> returns +false+.
+    # * You can add an object to a collection without automatically saving it by using the
+    # <tt>collection.build</tt> method (documented below).
+    # * All unsaved (<tt>new_record? == true</tt>) members of the collection are automatically
+    # saved when the parent is saved.
     #
     # === Association callbacks
     #
-    # Similar to the normal callbacks that hook into the lifecycle of an Active Record object, you can also define callbacks that get
-    # triggered when you add an object to or remove an object from an association collection. Example:
+    # Similar to the normal callbacks that hook into the lifecycle of an Active Record object,
+    # you can also define callbacks that get triggered when you add an object to or remove an
+    # object from an association collection.
     #
     #   class Project
     #     has_and_belongs_to_many :developers, :after_add => :evaluate_velocity
@@ -342,19 +355,21 @@ module ActiveRecord
     # It's possible to stack callbacks by passing them as an array. Example:
     #
     #   class Project
-    #     has_and_belongs_to_many :developers, :after_add => [:evaluate_velocity, Proc.new { |p, d| p.shipping_date = Time.now}]
+    #     has_and_belongs_to_many :developers,
+    #                             :after_add => [:evaluate_velocity, Proc.new { |p, d| p.shipping_date = Time.now}]
     #   end
     #
     # Possible callbacks are: +before_add+, +after_add+, +before_remove+ and +after_remove+.
     #
-    # Should any of the +before_add+ callbacks throw an exception, the object does not get added to the collection. Same with
-    # the +before_remove+ callbacks; if an exception is thrown the object doesn't get removed.
+    # Should any of the +before_add+ callbacks throw an exception, the object does not get
+    # added to the collection. Same with the +before_remove+ callbacks; if an exception is
+    # thrown the object doesn't get removed.
     #
     # === Association extensions
     #
-    # The proxy objects that control the access to associations can be extended through anonymous modules. This is especially
-    # beneficial for adding new finders, creators, and other factory-type methods that are only used as part of this association.
-    # Example:
+    # The proxy objects that control the access to associations can be extended through anonymous
+    # modules. This is especially beneficial for adding new finders, creators, and other
+    # factory-type methods that are only used as part of this association.
     #
     #   class Account < ActiveRecord::Base
     #     has_many :people do
@@ -369,7 +384,8 @@ module ActiveRecord
     #   person.first_name # => "David"
     #   person.last_name  # => "Heinemeier Hansson"
     #
-    # If you need to share the same extensions between many associations, you can use a named extension module. Example:
+    # If you need to share the same extensions between many associations, you can use a named
+    # extension module.
     #
     #   module FindOrCreateByNameExtension
     #     def find_or_create_by_name(name)
@@ -386,9 +402,10 @@ module ActiveRecord
     #     has_many :people, :extend => FindOrCreateByNameExtension
     #   end
     #
-    # If you need to use multiple named extension modules, you can specify an array of modules with the <tt>:extend</tt> option.
-    # In the case of name conflicts between methods in the modules, methods in modules later in the array supercede
-    # those earlier in the array. Example:
+    # If you need to use multiple named extension modules, you can specify an array of modules
+    # with the <tt>:extend</tt> option.
+    # In the case of name conflicts between methods in the modules, methods in modules later
+    # in the array supercede those earlier in the array.
     #
     #   class Account < ActiveRecord::Base
     #     has_many :people, :extend => [FindOrCreateByNameExtension, FindRecentExtension]
@@ -399,12 +416,14 @@ module ActiveRecord
     #
     # * +proxy_owner+ - Returns the object the association is part of.
     # * +proxy_reflection+ - Returns the reflection object that describes the association.
-    # * +proxy_target+ - Returns the associated object for +belongs_to+ and +has_one+, or the collection of associated objects for +has_many+ and +has_and_belongs_to_many+.
+    # * +proxy_target+ - Returns the associated object for +belongs_to+ and +has_one+, or
+    #   the collection of associated objects for +has_many+ and +has_and_belongs_to_many+.
     #
     # === Association Join Models
     #
-    # Has Many associations can be configured with the <tt>:through</tt> option to use an explicit join model to retrieve the data.  This
-    # operates similarly to a +has_and_belongs_to_many+ association.  The advantage is that you're able to add validations,
+    # Has Many associations can be configured with the <tt>:through</tt> option to use an
+    # explicit join model to retrieve the data.  This operates similarly to a
+    # +has_and_belongs_to_many+ association.  The advantage is that you're able to add validations,
     # callbacks, and extra attributes on the join model.  Consider the following schema:
     #
     #   class Author < ActiveRecord::Base
@@ -418,7 +437,7 @@ module ActiveRecord
     #   end
     #
     #   @author = Author.find :first
-    #   @author.authorships.collect { |a| a.book } # selects all books that the author's authorships belong to.
+    #   @author.authorships.collect { |a| a.book } # selects all books that the author's authorships belong to
     #   @author.books                              # selects all books by using the Authorship join model
     #
     # You can also go through a +has_many+ association on the join model:
@@ -439,7 +458,7 @@ module ActiveRecord
     #
     #   @firm = Firm.find :first
     #   @firm.clients.collect { |c| c.invoices }.flatten # select all invoices for all clients of the firm
-    #   @firm.invoices                                   # selects all invoices by going through the Client join model.
+    #   @firm.invoices                                   # selects all invoices by going through the Client join model
     #
     # Similarly you can go through a +has_one+ association on the join model:
     #
@@ -461,16 +480,18 @@ module ActiveRecord
     #   @group.users.collect { |u| u.avatar }.flatten # select all avatars for all users in the group
     #   @group.avatars                                # selects all avatars by going through the User join model.
     #
-    # An important caveat with going through +has_one+ or +has_many+ associations on the join model is that these associations are
-    # *read-only*.  For example, the following would not work following the previous example:
+    # An important caveat with going through +has_one+ or +has_many+ associations on the
+    # join model is that these associations are *read-only*.  For example, the following
+    # would not work following the previous example:
     #
-    #   @group.avatars << Avatar.new                # this would work if User belonged_to Avatar rather than the other way around.
+    #   @group.avatars << Avatar.new   # this would work if User belonged_to Avatar rather than the other way around
     #   @group.avatars.delete(@group.avatars.last)  # so would this
     #
     # === Polymorphic Associations
     #
-    # Polymorphic associations on models are not restricted on what types of models they can be associated with.  Rather, they
-    # specify an interface that a +has_many+ association must adhere to.
+    # Polymorphic associations on models are not restricted on what types of models they
+    # can be associated with.  Rather, they specify an interface that a +has_many+ association
+    # must adhere to.
     #
     #   class Asset < ActiveRecord::Base
     #     belongs_to :attachable, :polymorphic => true
@@ -482,13 +503,16 @@ module ActiveRecord
     #
     #   @asset.attachable = @post
     #
-    # This works by using a type column in addition to a foreign key to specify the associated record.  In the Asset example, you'd need
-    # an +attachable_id+ integer column and an +attachable_type+ string column.
+    # This works by using a type column in addition to a foreign key to specify the associated
+    # record.  In the Asset example, you'd need an +attachable_id+ integer column and an
+    # +attachable_type+ string column.
     #
-    # Using polymorphic associations in combination with single table inheritance (STI) is a little tricky. In order
-    # for the associations to work as expected, ensure that you store the base model for the STI models in the
-    # type column of the polymorphic association. To continue with the asset example above, suppose there are guest posts
-    # and member posts that use the posts table for STI. In this case, there must be a +type+ column in the posts table.
+    # Using polymorphic associations in combination with single table inheritance (STI) is
+    # a little tricky. In order for the associations to work as expected, ensure that you
+    # store the base model for the STI models in the type column of the polymorphic
+    # association. To continue with the asset example above, suppose there are guest posts
+    # and member posts that use the posts table for STI. In this case, there must be a +type+
+    # column in the posts table.
     #
     #   class Asset < ActiveRecord::Base
     #     belongs_to :attachable, :polymorphic => true
@@ -511,9 +535,10 @@ module ActiveRecord
     #
     # == Caching
     #
-    # All of the methods are built on a simple caching principle that will keep the result of the last query around unless specifically
-    # instructed not to. The cache is even shared across methods to make it even cheaper to use the macro-added methods without
-    # worrying too much about performance at the first go. Example:
+    # All of the methods are built on a simple caching principle that will keep the result
+    # of the last query around unless specifically instructed not to. The cache is even
+    # shared across methods to make it even cheaper to use the macro-added methods without
+    # worrying too much about performance at the first go.
     #
     #   project.milestones             # fetches milestones from the database
     #   project.milestones.size        # uses the milestone cache
@@ -523,9 +548,10 @@ module ActiveRecord
     #
     # == Eager loading of associations
     #
-    # Eager loading is a way to find objects of a certain class and a number of named associations. This is
-    # one of the easiest ways of to prevent the dreaded 1+N problem in which fetching 100 posts that each need to display their author
-    # triggers 101 database queries. Through the use of eager loading, the 101 queries can be reduced to 2. Example:
+    # Eager loading is a way to find objects of a certain class and a number of named associations.
+    # This is one of the easiest ways of to prevent the dreaded 1+N problem in which fetching 100
+    # posts that each need to display their author triggers 101 database queries. Through the
+    # use of eager loading, the 101 queries can be reduced to 2.
     #
     #   class Post < ActiveRecord::Base
     #     belongs_to :author
@@ -540,44 +566,55 @@ module ActiveRecord
     #     puts "Last comment on: " + post.comments.first.created_on
     #   end
     #
-    # To iterate over these one hundred posts, we'll generate 201 database queries. Let's first just optimize it for retrieving the author:
+    # To iterate over these one hundred posts, we'll generate 201 database queries. Let's
+    # first just optimize it for retrieving the author:
     #
     #   for post in Post.find(:all, :include => :author)
     #
-    # This references the name of the +belongs_to+ association that also used the <tt>:author</tt> symbol. After loading the posts, find
-    # will collect the +author_id+ from each one and load all the referenced authors with one query. Doing so will cut down the number of queries from 201 to 102.
+    # This references the name of the +belongs_to+ association that also used the <tt>:author</tt>
+    # symbol. After loading the posts, find will collect the +author_id+ from each one and load
+    # all the referenced authors with one query. Doing so will cut down the number of queries
+    # from 201 to 102.
     #
     # We can improve upon the situation further by referencing both associations in the finder with:
     #
     #   for post in Post.find(:all, :include => [ :author, :comments ])
     #
-    # This will load all comments with a single query. This reduces the total number of queries to 3. More generally the number of queries
-    # will be 1 plus the number of associations named (except if some of the associations are polymorphic +belongs_to+ - see below).
+    # This will load all comments with a single query. This reduces the total number of queries
+    # to 3. More generally the number of queries will be 1 plus the number of associations
+    # named (except if some of the associations are polymorphic +belongs_to+ - see below).
     #
     # To include a deep hierarchy of associations, use a hash:
     #
     #   for post in Post.find(:all, :include => [ :author, { :comments => { :author => :gravatar } } ])
     #
-    # That'll grab not only all the comments but all their authors and gravatar pictures.  You can mix and match
-    # symbols, arrays and hashes in any combination to describe the associations you want to load.
+    # That'll grab not only all the comments but all their authors and gravatar pictures.
+    # You can mix and match symbols, arrays and hashes in any combination to describe the
+    # associations you want to load.
     #
-    # All of this power shouldn't fool you into thinking that you can pull out huge amounts of data with no performance penalty just because you've reduced
-    # the number of queries. The database still needs to send all the data to Active Record and it still needs to be processed. So it's no
-    # catch-all for performance problems, but it's a great way to cut down on the number of queries in a situation as the one described above.
+    # All of this power shouldn't fool you into thinking that you can pull out huge amounts
+    # of data with no performance penalty just because you've reduced the number of queries.
+    # The database still needs to send all the data to Active Record and it still needs to
+    # be processed. So it's no catch-all for performance problems, but it's a great way to
+    # cut down on the number of queries in a situation as the one described above.
     #
-    # Since only one table is loaded at a time, conditions or orders cannot reference tables other than the main one. If this is the case
-    # Active Record falls back to the previously used LEFT OUTER JOIN based strategy. For example
+    # Since only one table is loaded at a time, conditions or orders cannot reference tables
+    # other than the main one. If this is the case Active Record falls back to the previously
+    # used LEFT OUTER JOIN based strategy. For example
     #
     #   Post.find(:all, :include => [ :author, :comments ], :conditions => ['comments.approved = ?', true])
     #
-    # This will result in a single SQL query with joins along the lines of: <tt>LEFT OUTER JOIN comments ON comments.post_id = posts.id</tt> and
-    # <tt>LEFT OUTER JOIN authors ON authors.id = posts.author_id</tt>. Note that using conditions like this can have unintended consequences.
-    # In the above example posts with no approved comments are not returned at all, because the conditions apply to the SQL statement as a whole
-    # and not just to the association. You must disambiguate column references for this fallback to happen, for example
+    # This will result in a single SQL query with joins along the lines of:
+    # <tt>LEFT OUTER JOIN comments ON comments.post_id = posts.id</tt> and
+    # <tt>LEFT OUTER JOIN authors ON authors.id = posts.author_id</tt>. Note that using conditions
+    # like this can have unintended consequences.
+    # In the above example posts with no approved comments are not returned at all, because
+    # the conditions apply to the SQL statement as a whole and not just to the association.
+    # You must disambiguate column references for this fallback to happen, for example
     # <tt>:order => "author.name DESC"</tt> will work but <tt>:order => "name DESC"</tt> will not.
     #
-    # If you do want eager load only some members of an association it is usually more natural to <tt>:include</tt> an association
-    # which has conditions defined on it:
+    # If you do want eager load only some members of an association it is usually more natural
+    # to <tt>:include</tt> an association which has conditions defined on it:
     #
     #   class Post < ActiveRecord::Base
     #     has_many :approved_comments, :class_name => 'Comment', :conditions => ['approved = ?', true]
@@ -585,9 +622,11 @@ module ActiveRecord
     #
     #   Post.find(:all, :include => :approved_comments)
     #
-    # This will load posts and eager load the +approved_comments+ association, which contains only those comments that have been approved.
+    # This will load posts and eager load the +approved_comments+ association, which contains
+    # only those comments that have been approved.
     #
-    # If you eager load an association with a specified <tt>:limit</tt> option, it will be ignored, returning all the associated objects:
+    # If you eager load an association with a specified <tt>:limit</tt> option, it will be ignored,
+    # returning all the associated objects:
     #
     #   class Picture < ActiveRecord::Base
     #     has_many :most_recent_comments, :class_name => 'Comment', :order => 'id DESC', :limit => 10
@@ -595,8 +634,8 @@ module ActiveRecord
     #
     #   Picture.find(:first, :include => :most_recent_comments).most_recent_comments # => returns all associated comments.
     #
-    # When eager loaded, conditions are interpolated in the context of the model class, not the model instance.  Conditions are lazily interpolated
-    # before the actual model exists.
+    # When eager loaded, conditions are interpolated in the context of the model class, not
+    # the model instance.  Conditions are lazily interpolated before the actual model exists.
     #
     # Eager loading is supported with polymorphic associations.
     #
@@ -608,17 +647,21 @@ module ActiveRecord
     #
     #   Address.find(:all, :include => :addressable)
     #
-    # This will execute one query to load the addresses and load the addressables with one query per addressable type.
-    # For example if all the addressables are either of class Person or Company then a total of 3 queries will be executed. The list of
-    # addressable types to load is determined on the back of the addresses loaded. This is not supported if Active Record has to fallback
-    # to the previous implementation of eager loading and will raise ActiveRecord::EagerLoadPolymorphicError. The reason is that the parent
-    # model's type is a column value so its corresponding table name cannot be put in the +FROM+/+JOIN+ clauses of that query.
+    # This will execute one query to load the addresses and load the addressables with one
+    # query per addressable type.
+    # For example if all the addressables are either of class Person or Company then a total
+    # of 3 queries will be executed. The list of addressable types to load is determined on
+    # the back of the addresses loaded. This is not supported if Active Record has to fallback
+    # to the previous implementation of eager loading and will raise ActiveRecord::EagerLoadPolymorphicError.
+    # The reason is that the parent model's type is a column value so its corresponding table
+    # name cannot be put in the +FROM+/+JOIN+ clauses of that query.
     #
     # == Table Aliasing
     #
-    # Active Record uses table aliasing in the case that a table is referenced multiple times in a join.  If a table is referenced only once,
-    # the standard table name is used.  The second time, the table is aliased as <tt>#{reflection_name}_#{parent_table_name}</tt>.  Indexes are appended
-    # for any more successive uses of the table name.
+    # Active Record uses table aliasing in the case that a table is referenced multiple times
+    # in a join.  If a table is referenced only once, the standard table name is used.  The
+    # second time, the table is aliased as <tt>#{reflection_name}_#{parent_table_name}</tt>.
+    # Indexes are appended for any more successive uses of the table name.
     #
     #   Post.find :all, :joins => :comments
     #   # => SELECT ... FROM posts INNER JOIN comments ON ...
@@ -651,7 +694,8 @@ module ActiveRecord
     #                              INNER JOIN categories_posts posts_categories_join INNER JOIN posts posts_categories
     #                              INNER JOIN categories_posts categories_posts_join INNER JOIN categories categories_posts_2
     #
-    # If you wish to specify your own custom joins using a <tt>:joins</tt> option, those table names will take precedence over the eager associations:
+    # If you wish to specify your own custom joins using a <tt>:joins</tt> option, those table
+    # names will take precedence over the eager associations:
     #
     #   Post.find :all, :joins => :comments, :joins => "inner join comments ..."
     #   # => SELECT ... FROM posts INNER JOIN comments_posts ON ... INNER JOIN comments ...
@@ -660,7 +704,8 @@ module ActiveRecord
     #                              INNER JOIN comments special_comments_posts ...
     #                              INNER JOIN comments ...
     #
-    # Table aliases are automatically truncated according to the maximum length of table identifiers according to the specific database.
+    # Table aliases are automatically truncated according to the maximum length of table identifiers
+    # according to the specific database.
     #
     # == Modules
     #
@@ -676,9 +721,10 @@ module ActiveRecord
     #     end
     #   end
     #
-    # When <tt>Firm#clients</tt> is called, it will in turn call <tt>MyApplication::Business::Client.find_all_by_firm_id(firm.id)</tt>.
-    # If you want to associate with a class in another module scope, this can be done by specifying the complete class name.
-    # Example:
+    # When <tt>Firm#clients</tt> is called, it will in turn call
+    # <tt>MyApplication::Business::Client.find_all_by_firm_id(firm.id)</tt>.
+    # If you want to associate with a class in another module scope, this can be done by
+    # specifying the complete class name.
     #
     #   module MyApplication
     #     module Business
@@ -694,8 +740,8 @@ module ActiveRecord
     #
     # == Bi-directional associations
     #
-    # When you specify an association there is usually an association on the associated model that specifies the same
-    # relationship in reverse.  For example, with the following models:
+    # When you specify an association there is usually an association on the associated model
+    # that specifies the same relationship in reverse.  For example, with the following models:
     #
     #    class Dungeon < ActiveRecord::Base
     #      has_many :traps
@@ -710,9 +756,11 @@ module ActiveRecord
     #      belongs_to :dungeon
     #    end
     #
-    # The +traps+ association on +Dungeon+ and the the +dungeon+ association on +Trap+ are the inverse of each other and the
-    # inverse of the +dungeon+ association on +EvilWizard+ is the +evil_wizard+ association on +Dungeon+ (and vice-versa).  By default,
-    # Active Record doesn't know anything about these inverse relationships and so no object loading optimisation is possible.  For example:
+    # The +traps+ association on +Dungeon+ and the the +dungeon+ association on +Trap+ are
+    # the inverse of each other and the inverse of the +dungeon+ association on +EvilWizard+
+    # is the +evil_wizard+ association on +Dungeon+ (and vice-versa).  By default,
+    # Active Record doesn't know anything about these inverse relationships and so no object
+    # loading optimisation is possible.  For example:
     #
     #    d = Dungeon.first
     #    t = d.traps.first
@@ -720,9 +768,11 @@ module ActiveRecord
     #    d.level = 10
     #    d.level == t.dungeon.level # => false
     #
-    # The +Dungeon+ instances +d+ and <tt>t.dungeon</tt> in the above example refer to the same object data from the database, but are
-    # actually different in-memory copies of that data.  Specifying the <tt>:inverse_of</tt> option on associations lets you tell
-    # Active Record about inverse relationships and it will optimise object loading.  For example, if we changed our model definitions to:
+    # The +Dungeon+ instances +d+ and <tt>t.dungeon</tt> in the above example refer to
+    # the same object data from the database, but are actually different in-memory copies
+    # of that data.  Specifying the <tt>:inverse_of</tt> option on associations lets you tell
+    # Active Record about inverse relationships and it will optimise object loading.  For
+    # example, if we changed our model definitions to:
     #
     #    class Dungeon < ActiveRecord::Base
     #      has_many :traps, :inverse_of => :dungeon
@@ -737,8 +787,8 @@ module ActiveRecord
     #      belongs_to :dungeon, :inverse_of => :evil_wizard
     #    end
     #
-    # Then, from our code snippet above, +d+ and <tt>t.dungeon</tt> are actually the same in-memory instance and our final <tt>d.level == t.dungeon.level</tt>
-    # will return +true+.
+    # Then, from our code snippet above, +d+ and <tt>t.dungeon</tt> are actually the same
+    # in-memory instance and our final <tt>d.level == t.dungeon.level</tt> will return +true+.
     #
     # There are limitations to <tt>:inverse_of</tt> support:
     #
@@ -748,13 +798,13 @@ module ActiveRecord
     #
     # == Type safety with <tt>ActiveRecord::AssociationTypeMismatch</tt>
     #
-    # If you attempt to assign an object to an association that doesn't match the inferred or specified <tt>:class_name</tt>, you'll
-    # get an <tt>ActiveRecord::AssociationTypeMismatch</tt>.
+    # If you attempt to assign an object to an association that doesn't match the inferred
+    # or specified <tt>:class_name</tt>, you'll get an <tt>ActiveRecord::AssociationTypeMismatch</tt>.
     #
     # == Options
     #
-    # All of the association macros can be specialized through options. This makes cases more complex than the simple and guessable ones
-    # possible.
+    # All of the association macros can be specialized through options. This makes cases
+    # more complex than the simple and guessable ones possible.
     module ClassMethods
       # Specifies a one-to-many association. The following methods for retrieval and query of
       # collections of associated objects will be added:
@@ -764,7 +814,7 @@ module ActiveRecord
       #   An empty array is returned if none are found.
       # [collection<<(object, ...)]
       #   Adds one or more objects to the collection by setting their foreign keys to the collection's primary key.
-      #   Note that this operation instantly fires update sql without waiting for the save or update call on the 
+      #   Note that this operation instantly fires update sql without waiting for the save or update call on the
       #   parent object.
       # [collection.delete(object, ...)]
       #   Removes one or more objects from the collection by setting their foreign keys to +NULL+.
@@ -828,20 +878,22 @@ module ActiveRecord
       # === Supported options
       # [:class_name]
       #   Specify the class name of the association. Use it only if that name can't be inferred
-      #   from the association name. So <tt>has_many :products</tt> will by default be linked to the Product class, but
-      #   if the real class name is SpecialProduct, you'll have to specify it with this option.
+      #   from the association name. So <tt>has_many :products</tt> will by default be linked
+      #   to the Product class, but if the real class name is SpecialProduct, you'll have to
+      #   specify it with this option.
       # [:conditions]
       #   Specify the conditions that the associated objects must meet in order to be included as a +WHERE+
-      #   SQL fragment, such as <tt>price > 5 AND name LIKE 'B%'</tt>.  Record creations from the association are scoped if a hash
-      #   is used.  <tt>has_many :posts, :conditions => {:published => true}</tt> will create published posts with <tt>@blog.posts.create</tt>
-      #   or <tt>@blog.posts.build</tt>.
+      #   SQL fragment, such as <tt>price > 5 AND name LIKE 'B%'</tt>.  Record creations from
+      #   the association are scoped if a hash is used.
+      #   <tt>has_many :posts, :conditions => {:published => true}</tt> will create published
+      #   posts with <tt>@blog.posts.create</tt> or <tt>@blog.posts.build</tt>.
       # [:order]
       #   Specify the order in which the associated objects are returned as an <tt>ORDER BY</tt> SQL fragment,
       #   such as <tt>last_name, first_name DESC</tt>.
       # [:foreign_key]
       #   Specify the foreign key used for the association. By default this is guessed to be the name
-      #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +has_many+ association will use "person_id"
-      #   as the default <tt>:foreign_key</tt>.
+      #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +has_many+
+      #   association will use "person_id" as the default <tt>:foreign_key</tt>.
       # [:primary_key]
       #   Specify the method that returns the primary key used for the association. By default this is +id+.
       # [:dependent]
@@ -855,10 +907,12 @@ module ActiveRecord
       #
       # [:finder_sql]
       #   Specify a complete SQL statement to fetch the association. This is a good way to go for complex
-      #   associations that depend on multiple tables. Note: When this option is used, +find_in_collection+ is _not_ added.
+      #   associations that depend on multiple tables. Note: When this option is used, +find_in_collection+
+      #   is _not_ added.
       # [:counter_sql]
       #   Specify a complete SQL statement to fetch the size of the association. If <tt>:finder_sql</tt> is
-      #   specified but not <tt>:counter_sql</tt>, <tt>:counter_sql</tt> will be generated by replacing <tt>SELECT ... FROM</tt> with <tt>SELECT COUNT(*) FROM</tt>.
+      #   specified but not <tt>:counter_sql</tt>, <tt>:counter_sql</tt> will be generated by
+      #   replacing <tt>SELECT ... FROM</tt> with <tt>SELECT COUNT(*) FROM</tt>.
       # [:extend]
       #   Specify a named module for extending the proxy. See "Association extensions".
       # [:include]
@@ -866,25 +920,31 @@ module ActiveRecord
       # [:group]
       #   An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
       # [:having]
-      #   Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt> returns. Uses the <tt>HAVING</tt> SQL-clause.
+      #   Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt>
+      #   returns. Uses the <tt>HAVING</tt> SQL-clause.
       # [:limit]
       #   An integer determining the limit on the number of rows that should be returned.
       # [:offset]
-      #   An integer determining the offset from where the rows should be fetched. So at 5, it would skip the first 4 rows.
+      #   An integer determining the offset from where the rows should be fetched. So at 5,
+      #   it would skip the first 4 rows.
       # [:select]
-      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if you, for example, want to do a join
-      #   but not include the joined columns. Do not forget to include the primary and foreign keys, otherwise it will raise an error.
+      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if
+      #   you, for example, want to do a join but not include the joined columns. Do not forget
+      #   to include the primary and foreign keys, otherwise it will raise an error.
       # [:as]
       #   Specifies a polymorphic interface (See <tt>belongs_to</tt>).
       # [:through]
-      #   Specifies a join model through which to perform the query.  Options for <tt>:class_name</tt> and <tt>:foreign_key</tt>
-      #   are ignored, as the association uses the source reflection. You can only use a <tt>:through</tt> query through a <tt>belongs_to</tt>
-      #   <tt>has_one</tt> or <tt>has_many</tt> association on the join model. The collection of join models can be managed via the collection
-      #   API. For example, new join models are created for newly associated objects, and if some are gone their rows are deleted (directly,
+      #   Specifies a join model through which to perform the query.  Options for <tt>:class_name</tt>
+      #   and <tt>:foreign_key</tt> are ignored, as the association uses the source reflection. You
+      #   can only use a <tt>:through</tt> query through a <tt>belongs_to</tt>, <tt>has_one</tt>
+      #   or <tt>has_many</tt> association on the join model. The collection of join models
+      #   can be managed via the collection API. For example, new join models are created for
+      #   newly associated objects, and if some are gone their rows are deleted (directly,
       #   no destroy callbacks are triggered).
       # [:source]
-      #   Specifies the source association name used by <tt>has_many :through</tt> queries.  Only use it if the name cannot be
-      #   inferred from the association.  <tt>has_many :subscribers, :through => :subscriptions</tt> will look for either <tt>:subscribers</tt> or
+      #   Specifies the source association name used by <tt>has_many :through</tt> queries.
+      #   Only use it if the name cannot be inferred from the association.
+      #   <tt>has_many :subscribers, :through => :subscriptions</tt> will look for either <tt>:subscribers</tt> or
       #   <tt>:subscriber</tt> on Subscription, unless a <tt>:source</tt> is given.
       # [:source_type]
       #   Specifies type of the source association used by <tt>has_many :through</tt> queries where the source
@@ -894,14 +954,15 @@ module ActiveRecord
       # [:readonly]
       #   If true, all the associated objects are readonly through the association.
       # [:validate]
-      #   If false, don't validate the associated objects when saving the parent object. true by default.
+      #   If +false+, don't validate the associated objects when saving the parent object. true by default.
       # [:autosave]
-      #   If true, always save the associated objects or destroy them if marked for destruction, when saving the parent object.
-      #   If false, never save or destroy the associated objects.
+      #   If true, always save the associated objects or destroy them if marked for destruction,
+      #   when saving the parent object. If false, never save or destroy the associated objects.
       #   By default, only save associated objects that are new records.
       # [:inverse_of]
-      #   Specifies the name of the <tt>belongs_to</tt> association on the associated object that is the inverse of this <tt>has_many</tt>
-      #   association.  Does not work in combination with <tt>:through</tt> or <tt>:as</tt> options.
+      #   Specifies the name of the <tt>belongs_to</tt> association on the associated object
+      #   that is the inverse of this <tt>has_many</tt> association. Does not work in combination
+      #   with <tt>:through</tt> or <tt>:as</tt> options.
       #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
       #
       # Option examples:
@@ -975,19 +1036,20 @@ module ActiveRecord
       # [:conditions]
       #   Specify the conditions that the associated object must meet in order to be included as a +WHERE+
       #   SQL fragment, such as <tt>rank = 5</tt>. Record creation from the association is scoped if a hash
-      #   is used. <tt>has_one :account, :conditions => {:enabled => true}</tt> will create an enabled account with <tt>@company.create_account</tt>
-      #   or <tt>@company.build_account</tt>.
+      #   is used. <tt>has_one :account, :conditions => {:enabled => true}</tt> will create
+      #   an enabled account with <tt>@company.create_account</tt> or <tt>@company.build_account</tt>.
       # [:order]
       #   Specify the order in which the associated objects are returned as an <tt>ORDER BY</tt> SQL fragment,
       #   such as <tt>last_name, first_name DESC</tt>.
       # [:dependent]
       #   If set to <tt>:destroy</tt>, the associated object is destroyed when this object is. If set to
-      #   <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method. If set to <tt>:nullify</tt>, the associated
-      #   object's foreign key is set to +NULL+. Also, association is assigned.
+      #   <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method.
+      #   If set to <tt>:nullify</tt>, the associated object's foreign key is set to +NULL+.
+      #   Also, association is assigned.
       # [:foreign_key]
       #   Specify the foreign key used for the association. By default this is guessed to be the name
-      #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +has_one+ association will use "person_id"
-      #   as the default <tt>:foreign_key</tt>.
+      #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +has_one+ association
+      #   will use "person_id" as the default <tt>:foreign_key</tt>.
       # [:primary_key]
       #   Specify the method that returns the primary key used for the association. By default this is +id+.
       # [:include]
@@ -995,15 +1057,18 @@ module ActiveRecord
       # [:as]
       #   Specifies a polymorphic interface (See <tt>belongs_to</tt>).
       # [:select]
-      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if, for example, you want to do a join
-      #   but not include the joined columns. Do not forget to include the primary and foreign keys, otherwise it will raise an error.
+      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if, for example,
+      #   you want to do a join but not include the joined columns. Do not forget to include the
+      #   primary and foreign keys, otherwise it will raise an error.
       # [:through]
-      #   Specifies a Join Model through which to perform the query.  Options for <tt>:class_name</tt> and <tt>:foreign_key</tt>
-      #   are ignored, as the association uses the source reflection. You can only use a <tt>:through</tt> query through a
-      #   <tt>has_one</tt> or <tt>belongs_to</tt> association on the join model.
+      #   Specifies a Join Model through which to perform the query.  Options for <tt>:class_name</tt>
+      #   and <tt>:foreign_key</tt> are ignored, as the association uses the source reflection. You
+      #   can only use a <tt>:through</tt> query through a <tt>has_one</tt> or <tt>belongs_to</tt>
+      #   association on the join model.
       # [:source]
-      #   Specifies the source association name used by <tt>has_one :through</tt> queries.  Only use it if the name cannot be
-      #   inferred from the association.  <tt>has_one :favorite, :through => :favorites</tt> will look for a
+      #   Specifies the source association name used by <tt>has_one :through</tt> queries.
+      #   Only use it if the name cannot be inferred from the association.
+      #   <tt>has_one :favorite, :through => :favorites</tt> will look for a
       #   <tt>:favorite</tt> on Favorite, unless a <tt>:source</tt> is given.
       # [:source_type]
       #   Specifies type of the source association used by <tt>has_one :through</tt> queries where the source
@@ -1011,19 +1076,21 @@ module ActiveRecord
       # [:readonly]
       #   If true, the associated object is readonly through the association.
       # [:validate]
-      #   If false, don't validate the associated object when saving the parent object. +false+ by default.
+      #   If +false+, don't validate the associated object when saving the parent object. +false+ by default.
       # [:autosave]
-      #   If true, always save the associated object or destroy it if marked for destruction, when saving the parent object.
-      #   If false, never save or destroy the associated object.
+      #   If true, always save the associated object or destroy it if marked for destruction,
+      #   when saving the parent object. If false, never save or destroy the associated object.
       #   By default, only save the associated object if it's a new record.
       # [:inverse_of]
-      #   Specifies the name of the <tt>belongs_to</tt> association on the associated object that is the inverse of this <tt>has_one</tt>
-      #   association.  Does not work in combination with <tt>:through</tt> or <tt>:as</tt> options.
+      #   Specifies the name of the <tt>belongs_to</tt> association on the associated object
+      #   that is the inverse of this <tt>has_one</tt> association.  Does not work in combination
+      #   with <tt>:through</tt> or <tt>:as</tt> options.
       #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
       #
       # Option examples:
       #   has_one :credit_card, :dependent => :destroy  # destroys the associated credit card
-      #   has_one :credit_card, :dependent => :nullify  # updates the associated records foreign key value to NULL rather than destroying it
+      #   has_one :credit_card, :dependent => :nullify  # updates the associated records foreign
+      #                                                 # key value to NULL rather than destroying it
       #   has_one :last_comment, :class_name => "Comment", :order => "posted_on"
       #   has_one :project_manager, :class_name => "Person", :conditions => "role = 'project_manager'"
       #   has_one :attachment, :as => :attachable
@@ -1085,27 +1152,34 @@ module ActiveRecord
       #   Specify the conditions that the associated object must meet in order to be included as a +WHERE+
       #   SQL fragment, such as <tt>authorized = 1</tt>.
       # [:select]
-      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if, for example, you want to do a join
-      #   but not include the joined columns. Do not forget to include the primary and foreign keys, otherwise it will raise an error.
+      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed
+      #   if, for example, you want to do a join but not include the joined columns. Do not
+      #   forget to include the primary and foreign keys, otherwise it will raise an error.
       # [:foreign_key]
       #   Specify the foreign key used for the association. By default this is guessed to be the name
-      #   of the association with an "_id" suffix. So a class that defines a <tt>belongs_to :person</tt> association will use
-      #   "person_id" as the default <tt>:foreign_key</tt>. Similarly, <tt>belongs_to :favorite_person, :class_name => "Person"</tt>
-      #   will use a foreign key of "favorite_person_id".
+      #   of the association with an "_id" suffix. So a class that defines a <tt>belongs_to :person</tt>
+      #   association will use "person_id" as the default <tt>:foreign_key</tt>. Similarly,
+      #   <tt>belongs_to :favorite_person, :class_name => "Person"</tt> will use a foreign key
+      #   of "favorite_person_id".
       # [:primary_key]
-      #   Specify the method that returns the primary key of associated object used for the association. By default this is id.
+      #   Specify the method that returns the primary key of associated object used for the association.
+      #   By default this is id.
       # [:dependent]
       #   If set to <tt>:destroy</tt>, the associated object is destroyed when this object is. If set to
-      #   <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method. This option should not be specified when
-      #   <tt>belongs_to</tt> is used in conjunction with a <tt>has_many</tt> relationship on another class because of the potential to leave
+      #   <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method.
+      #   This option should not be specified when <tt>belongs_to</tt> is used in conjunction with
+      #   a <tt>has_many</tt> relationship on another class because of the potential to leave
       #   orphaned records behind.
       # [:counter_cache]
       #   Caches the number of belonging objects on the associate class through the use of +increment_counter+
-      #   and +decrement_counter+. The counter cache is incremented when an object of this class is created and decremented when it's
-      #   destroyed. This requires that a column named <tt>#{table_name}_count</tt> (such as +comments_count+ for a belonging Comment class)
-      #   is used on the associate class (such as a Post class). You can also specify a custom counter cache column by providing
-      #   a column name instead of a +true+/+false+ value to this option (e.g., <tt>:counter_cache => :my_custom_counter</tt>.)
-      #   Note: Specifying a counter cache will add it to that model's list of readonly attributes using +attr_readonly+.
+      #   and +decrement_counter+. The counter cache is incremented when an object of this
+      #   class is created and decremented when it's destroyed. This requires that a column
+      #   named <tt>#{table_name}_count</tt> (such as +comments_count+ for a belonging Comment class)
+      #   is used on the associate class (such as a Post class). You can also specify a custom counter
+      #   cache column by providing a column name instead of a +true+/+false+ value to this
+      #   option (e.g., <tt>:counter_cache => :my_custom_counter</tt>.)
+      #   Note: Specifying a counter cache will add it to that model's list of readonly attributes
+      #   using +attr_readonly+.
       # [:include]
       #   Specify second-order associations that should be eager loaded when this object is loaded.
       # [:polymorphic]
@@ -1115,17 +1189,20 @@ module ActiveRecord
       # [:readonly]
       #   If true, the associated object is readonly through the association.
       # [:validate]
-      #   If false, don't validate the associated objects when saving the parent object. +false+ by default.
+      #   If +false+, don't validate the associated objects when saving the parent object. +false+ by default.
       # [:autosave]
-      #   If true, always save the associated object or destroy it if marked for destruction, when saving the parent object.
+      #   If true, always save the associated object or destroy it if marked for destruction, when
+      #   saving the parent object.
       #   If false, never save or destroy the associated object.
       #   By default, only save the associated object if it's a new record.
       # [:touch]
-      #   If true, the associated object will be touched (the updated_at/on attributes set to now) when this record is either saved or
-      #   destroyed. If you specify a symbol, that attribute will be updated with the current time instead of the updated_at/on attribute.
+      #   If true, the associated object will be touched (the updated_at/on attributes set to now)
+      #   when this record is either saved or destroyed. If you specify a symbol, that attribute
+      #   will be updated with the current time instead of the updated_at/on attribute.
       # [:inverse_of]
-      #   Specifies the name of the <tt>has_one</tt> or <tt>has_many</tt> association on the associated object that is the inverse of this <tt>belongs_to</tt>
-      #   association.  Does not work in combination with the <tt>:polymorphic</tt> options.
+      #   Specifies the name of the <tt>has_one</tt> or <tt>has_many</tt> association on the associated
+      #   object that is the inverse of this <tt>belongs_to</tt> association.  Does not work in
+      #   combination with the <tt>:polymorphic</tt> options.
       #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
       #
       # Option examples:
@@ -1159,9 +1236,10 @@ module ActiveRecord
       # Specifies a many-to-many relationship with another class. This associates two classes via an
       # intermediate join table.  Unless the join table is explicitly specified as an option, it is
       # guessed using the lexical order of the class names. So a join between Developer and Project
-      # will give the default join table name of "developers_projects" because "D" outranks "P".  Note that this precedence
-      # is calculated using the <tt><</tt> operator for String.  This means that if the strings are of different lengths,
-      # and the strings are equal when compared up to the shortest length, then the longer string is considered of higher
+      # will give the default join table name of "developers_projects" because "D" outranks "P".
+      # Note that this precedence is calculated using the <tt><</tt> operator for String.  This
+      # means that if the strings are of different lengths, and the strings are equal when compared
+      # up to the shortest length, then the longer string is considered of higher
       # lexical precedence than the shorter one.  For example, one would expect the tables "paper_boxes" and "papers"
       # to generate a join table name of "papers_paper_boxes" because of the length of the name "paper_boxes",
       # but it in fact generates a join table name of "paper_boxes_papers".  Be aware of this caveat, and use the
@@ -1183,9 +1261,10 @@ module ActiveRecord
       #     end
       #   end
       #
-      # Deprecated: Any additional fields added to the join table will be placed as attributes when pulling records out through
-      # +has_and_belongs_to_many+ associations. Records returned from join tables with additional attributes will be marked as
-      # readonly (because we can't save changes to the additional attributes). It's strongly recommended that you upgrade any
+      # Deprecated: Any additional fields added to the join table will be placed as attributes when
+      # pulling records out through +has_and_belongs_to_many+ associations. Records returned from join
+      # tables with additional attributes will be marked as readonly (because we can't save changes
+      # to the additional attributes). It's strongly recommended that you upgrade any
       # associations with attributes to a real join model (see introduction).
       #
       # Adds the following methods for retrieval and query:
@@ -1196,7 +1275,7 @@ module ActiveRecord
       # [collection<<(object, ...)]
       #   Adds one or more objects to the collection by creating associations in the join table
       #   (<tt>collection.push</tt> and <tt>collection.concat</tt> are aliases to this method).
-      #   Note that this operation instantly fires update sql without waiting for the save or update call on the 
+      #   Note that this operation instantly fires update sql without waiting for the save or update call on the
       #   parent object.
       # [collection.delete(object, ...)]
       #   Removes one or more objects from the collection by removing their associations from the join table.
@@ -1225,7 +1304,8 @@ module ActiveRecord
       #   with +attributes+ and linked to this object through the join table, but has not yet been saved.
       # [collection.create(attributes = {})]
       #   Returns a new object of the collection type that has been instantiated
-      #   with +attributes+, linked to this object through the join table, and that has already been saved (if it passed the validation).
+      #   with +attributes+, linked to this object through the join table, and that has already been
+      #   saved (if it passed the validation).
       #
       # (+collection+ is replaced with the symbol passed as the first argument, so
       # <tt>has_and_belongs_to_many :categories</tt> would add among others <tt>categories.empty?</tt>.)
@@ -1260,8 +1340,9 @@ module ActiveRecord
       #   MUST be declared underneath any +has_and_belongs_to_many+ declaration in order to work.
       # [:foreign_key]
       #   Specify the foreign key used for the association. By default this is guessed to be the name
-      #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +has_and_belongs_to_many+ association
-      #   to Project will use "person_id" as the default <tt>:foreign_key</tt>.
+      #   of this class in lower-case and "_id" suffixed. So a Person class that makes
+      #   a +has_and_belongs_to_many+ association to Project will use "person_id" as the
+      #   default <tt>:foreign_key</tt>.
       # [:association_foreign_key]
       #   Specify the foreign key used for the association on the receiving side of the association.
       #   By default this is guessed to be the name of the associated class in lower-case and "_id" suffixed.
@@ -1269,7 +1350,8 @@ module ActiveRecord
       #   the association will use "project_id" as the default <tt>:association_foreign_key</tt>.
       # [:conditions]
       #   Specify the conditions that the associated object must meet in order to be included as a +WHERE+
-      #   SQL fragment, such as <tt>authorized = 1</tt>.  Record creations from the association are scoped if a hash is used.
+      #   SQL fragment, such as <tt>authorized = 1</tt>.  Record creations from the association are
+      #   scoped if a hash is used.
       #   <tt>has_many :posts, :conditions => {:published => true}</tt> will create published posts with <tt>@blog.posts.create</tt>
       #   or <tt>@blog.posts.build</tt>.
       # [:order]
@@ -1281,7 +1363,8 @@ module ActiveRecord
       #   Overwrite the default generated SQL statement used to fetch the association with a manual statement
       # [:counter_sql]
       #   Specify a complete SQL statement to fetch the size of the association. If <tt>:finder_sql</tt> is
-      #   specified but not <tt>:counter_sql</tt>, <tt>:counter_sql</tt> will be generated by replacing <tt>SELECT ... FROM</tt> with <tt>SELECT COUNT(*) FROM</tt>.
+      #   specified but not <tt>:counter_sql</tt>, <tt>:counter_sql</tt> will be generated by
+      #   replacing <tt>SELECT ... FROM</tt> with <tt>SELECT COUNT(*) FROM</tt>.
       # [:delete_sql]
       #   Overwrite the default generated SQL statement used to remove links between the associated
       #   classes with a manual statement.
@@ -1295,20 +1378,24 @@ module ActiveRecord
       # [:group]
       #   An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
       # [:having]
-      #   Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt> returns. Uses the <tt>HAVING</tt> SQL-clause.
+      #   Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt> returns.
+      #   Uses the <tt>HAVING</tt> SQL-clause.
       # [:limit]
       #   An integer determining the limit on the number of rows that should be returned.
       # [:offset]
-      #   An integer determining the offset from where the rows should be fetched. So at 5, it would skip the first 4 rows.
+      #   An integer determining the offset from where the rows should be fetched. So at 5,
+      #   it would skip the first 4 rows.
       # [:select]
-      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if, for example, you want to do a join
-      #   but not include the joined columns. Do not forget to include the primary and foreign keys, otherwise it will raise an error.
+      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if, for example,
+      #   you want to do a join but not include the joined columns. Do not forget to include the primary
+      #   and foreign keys, otherwise it will raise an error.
       # [:readonly]
       #   If true, all the associated objects are readonly through the association.
       # [:validate]
-      #   If false, don't validate the associated objects when saving the parent object. +true+ by default.
+      #   If +false+, don't validate the associated objects when saving the parent object. +true+ by default.
       # [:autosave]
-      #   If true, always save the associated objects or destroy them if marked for destruction, when saving the parent object.
+      #   If true, always save the associated objects or destroy them if marked for destruction, when
+      #   saving the parent object.
       #   If false, never save or destroy the associated objects.
       #   By default, only save associated objects that are new records.
       #
@@ -1376,7 +1463,7 @@ module ActiveRecord
             association = association_instance_get(reflection.name)
             association && association.loaded?
           end
-          
+
           redefine_method("#{reflection.name}=") do |new_value|
             association = association_instance_get(reflection.name)
 
@@ -1387,7 +1474,7 @@ module ActiveRecord
             association.replace(new_value)
             association_instance_set(reflection.name, new_value.nil? ? nil : association)
           end
-          
+
           redefine_method("set_#{reflection.name}_target") do |target|
             return if target.nil? and association_proxy_class == BelongsToAssociation
             association = association_proxy_class.new(self, reflection)
@@ -1410,17 +1497,17 @@ module ActiveRecord
 
             association
           end
-          
+
           redefine_method("#{reflection.name.to_s.singularize}_ids") do
             if send(reflection.name).loaded? || reflection.options[:finder_sql]
-              send(reflection.name).map(&:id)
+              send(reflection.name).map { |r| r.id }
             else
               if reflection.through_reflection && reflection.source_reflection.belongs_to?
                 through = reflection.through_reflection
                 primary_key = reflection.source_reflection.primary_key_name
-                send(through.name).select("DISTINCT #{through.quoted_table_name}.#{primary_key}").map!(&:"#{primary_key}")
+                send(through.name).select("DISTINCT #{through.quoted_table_name}.#{primary_key}").map! { |r| r.send(primary_key) }
               else
-                send(reflection.name).select("#{reflection.quoted_table_name}.#{reflection.klass.primary_key}").except(:includes).map!(&:id)
+                send(reflection.name).select("#{reflection.quoted_table_name}.#{reflection.klass.primary_key}").except(:includes).map! { |r| r.id }
               end
             end
           end
@@ -1437,10 +1524,12 @@ module ActiveRecord
               association.replace(new_value)
               association
             end
-            
+
             redefine_method("#{reflection.name.to_s.singularize}_ids=") do |new_value|
-              ids = (new_value || []).reject { |nid| nid.blank? }.map(&:to_i)
-              send("#{reflection.name}=", reflection.klass.find(ids).index_by(&:id).values_at(*ids))
+              pk_column = reflection.primary_key_column
+              ids = (new_value || []).reject { |nid| nid.blank? }
+              ids.map!{ |i| pk_column.type_cast(i) }
+              send("#{reflection.name}=", reflection.klass.find(ids).index_by{ |r| r.id }.values_at(*ids))
             end
           end
         end
@@ -1498,6 +1587,7 @@ module ActiveRecord
             end
           end
           after_save(method_name)
+          after_touch(method_name)
           after_destroy(method_name)
         end
 
@@ -1802,9 +1892,7 @@ module ActiveRecord
             case associations
               when Symbol, String
                 reflection = base.reflections[associations]
-                if reflection && reflection.collection?
-                  records.each { |record| record.send(reflection.name).target.uniq! }
-                end
+                remove_uniq_by_reflection(reflection, records)
               when Array
                 associations.each do |association|
                   remove_duplicate_results!(base, records, association)
@@ -1812,6 +1900,7 @@ module ActiveRecord
               when Hash
                 associations.keys.each do |name|
                   reflection = base.reflections[name]
+                  remove_uniq_by_reflection(reflection, records)
 
                   parent_records = []
                   records.each do |record|
@@ -1830,6 +1919,7 @@ module ActiveRecord
           end
 
           protected
+
             def build(associations, parent = nil, join_class = Arel::InnerJoin)
               parent ||= @joins.last
               case associations
@@ -1852,6 +1942,12 @@ module ActiveRecord
               end
             end
 
+            def remove_uniq_by_reflection(reflection, records)
+              if reflection && reflection.collection?
+                records.each { |record| record.send(reflection.name).target.uniq! }
+              end
+            end
+
             def build_join_association(reflection, parent)
               JoinAssociation.new(reflection, self, parent)
             end