Merge branch 'master' of github.com:lifo/docrails

30 files changed, 396 insertions, 490 deletions

diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index c4b10a8dae..210820062b 100644
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -22,7 +22,6 @@
 #++
 
 require 'active_support'
-require 'active_support/i18n'
 require 'active_model'
 require 'arel'
 require 'active_record_deprecated_finders'
@@ -63,8 +62,6 @@ module ActiveRecord
     autoload :CounterCache
     autoload :ConnectionHandling
     autoload :DynamicMatchers
-    autoload :DynamicFinderMatch
-    autoload :DynamicScopeMatch
     autoload :Explain
     autoload :Inheritance
     autoload :Integration
@@ -147,4 +144,6 @@ ActiveSupport.on_load(:active_record) do
   Arel::Table.engine = self
 end
 
-I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'
+ActiveSupport.on_load(:i18n) do
+  I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'
+end
diff --git a/activerecord/lib/active_record/aggregations.rb b/activerecord/lib/active_record/aggregations.rb
index a4db627535..c7a329d74d 100644
--- a/activerecord/lib/active_record/aggregations.rb
+++ b/activerecord/lib/active_record/aggregations.rb
@@ -71,7 +71,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
diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index c7a24de11d..c30e8e08b8 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -1596,7 +1596,7 @@ module ActiveRecord
       #   has_and_belongs_to_many :categories, :join_table => "prods_cats"
       #   has_and_belongs_to_many :categories, :readonly => true
       #   has_and_belongs_to_many :active_projects, :join_table => 'developers_projects', :delete_sql =>
-      #   "DELETE FROM developers_projects WHERE active=1 AND developer_id = #{id} AND project_id = #{record.id}"
+      #   proc { |record| "DELETE FROM developers_projects WHERE active=1 AND developer_id = #{id} AND project_id = #{record.id}" }
       def has_and_belongs_to_many(name, options = {}, &extension)
         Builder::HasAndBelongsToMany.build(self, name, options, &extension)
       end
diff --git a/activerecord/lib/active_record/associations/collection_association.rb b/activerecord/lib/active_record/associations/collection_association.rb
index 14aa557b6c..00321ec860 100644
--- a/activerecord/lib/active_record/associations/collection_association.rb
+++ b/activerecord/lib/active_record/associations/collection_association.rb
@@ -16,12 +16,6 @@ module ActiveRecord
     # If you need to work on all current children, new and existing records,
     # +load_target+ and the +loaded+ flag are your friends.
     class CollectionAssociation < Association #:nodoc:
-      attr_reader :proxy
-
-      def initialize(owner, reflection)
-        super
-        @proxy = CollectionProxy.new(self)
-      end
 
       # Implements the reader method, e.g. foo.items for Foo.has_many :items
       def reader(force_reload = false)
@@ -31,7 +25,7 @@ module ActiveRecord
           reload
         end
 
-        proxy
+        CollectionProxy.new(self)
       end
 
       # Implements the writer method, e.g. foo.items= for Foo.has_many :items
diff --git a/activerecord/lib/active_record/associations/collection_proxy.rb b/activerecord/lib/active_record/associations/collection_proxy.rb
index ad029d1101..cf4cc98f38 100644
--- a/activerecord/lib/active_record/associations/collection_proxy.rb
+++ b/activerecord/lib/active_record/associations/collection_proxy.rb
@@ -33,14 +33,7 @@ module ActiveRecord
     #
     # is computed directly through SQL and does not trigger by itself the
     # instantiation of the actual post records.
-    class CollectionProxy # :nodoc:
-      alias :proxy_extend :extend
-
-      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/ }
-
-      delegate :group, :order, :limit, :joins, :where, :preload, :eager_load, :includes, :from,
-               :lock, :readonly, :having, :pluck, :to => :scoped
-
+    class CollectionProxy < Relation # :nodoc:
       delegate :target, :load_target, :loaded?, :to => :@association
 
       delegate :select, :find, :first, :last,
@@ -52,7 +45,8 @@ module ActiveRecord
 
       def initialize(association)
         @association = association
-        Array(association.options[:extend]).each { |ext| proxy_extend(ext) }
+        super association.klass, association.klass.arel_table
+        merge! association.scoped
       end
 
       alias_method :new, :build
@@ -61,54 +55,28 @@ module ActiveRecord
         @association
       end
 
-      def scoped(options = nil)
-        association = @association
-        scope       = association.scoped
-
-        scope.extending! do
-          define_method(:proxy_association) { association }
-        end
-        scope.merge!(options) if options
-        scope
+      # We don't want this object to be put on the scoping stack, because
+      # that could create an infinite loop where we call an @association
+      # method, which gets the current scope, which is this object, which
+      # delegates to @association, and so on.
+      def scoping
+        @association.scoped.scoping { yield }
       end
 
-      def respond_to?(name, include_private = false)
-        super ||
-        (load_target && target.respond_to?(name, include_private)) ||
-        proxy_association.klass.respond_to?(name, include_private)
+      def spawn
+        scoped
       end
 
-      def method_missing(method, *args, &block)
-        match = DynamicFinderMatch.match(method)
-        if match && match.instantiator?
-          send(:find_or_instantiator_by_attributes, match, match.attribute_names, *args) do |r|
-            proxy_association.send :set_owner_attributes, r
-            proxy_association.send :add_to_target, r
-            yield(r) if block_given?
-          end
-
-        elsif target.respond_to?(method) || (!proxy_association.klass.respond_to?(method) && Class.respond_to?(method))
-          if load_target
-            if target.respond_to?(method)
-              target.send(method, *args, &block)
-            else
-              begin
-                super
-              rescue NoMethodError => e
-                raise e, e.message.sub(/ for #<.*$/, " via proxy for #{target}")
-              end
-            end
-          end
+      def scoped(options = nil)
+        association = @association
 
-        else
-          scoped.readonly(nil).send(method, *args, &block)
+        super.extending! do
+          define_method(:proxy_association) { association }
         end
       end
 
-      # Forwards <tt>===</tt> explicitly to the \target because the instance method
-      # removal above doesn't catch it. Loads the \target if needed.
-      def ===(other)
-        other === load_target
+      def ==(other)
+        load_target == other
       end
 
       def to_ary
@@ -130,19 +98,6 @@ module ActiveRecord
         proxy_association.reload
         self
       end
-
-      # Define array public methods because we know it should be invoked over
-      # the target, so we can have a performance improvement using those methods
-      # in association collections
-      Array.public_instance_methods.each do |m|
-        unless method_defined?(m)
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{m}(*args, &block)
-              target.public_send(:#{m}, *args, &block) if load_target
-            end
-          RUBY
-        end
-      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/autosave_association.rb b/activerecord/lib/active_record/autosave_association.rb
index 3005bef092..d545e7799d 100644
--- a/activerecord/lib/active_record/autosave_association.rb
+++ b/activerecord/lib/active_record/autosave_association.rb
@@ -350,7 +350,7 @@ module ActiveRecord
           end
 
           records_to_destroy.each do |record|
-            association.proxy.destroy(record)
+            association.destroy(record)
           end
         end
 
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 44ac37c498..6f9f0399db 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -34,6 +34,7 @@ module ActiveRecord
         when Numeric    then value.to_s
         when Date, Time then "'#{quoted_date(value)}'"
         when Symbol     then "'#{quote_string(value.to_s)}'"
+        when Class      then "'#{value.to_s}'"
         else
           "'#{quote_string(YAML.dump(value))}'"
         end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
index 3546873550..f17baec722 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
@@ -262,7 +262,7 @@ module ActiveRecord
       
       # Adds index options to the indexes hash, keyed by column name
       # This is primarily used to track indexes that need to be created after the table
-      # === Examples
+      #
       #   index(:account_id, :name => 'index_projects_on_account_id')
       def index(column_name, options = {})
         indexes[column_name] = options
@@ -348,7 +348,7 @@ module ActiveRecord
 
       # Adds a new column to the named table.
       # See TableDefinition#column for details of the options you can use.
-      # ===== Example
+      #
       # ====== Creating a simple column
       #  t.column(:name, :string)
       def column(column_name, type, options = {})
@@ -363,7 +363,6 @@ module ActiveRecord
       # Adds a new index to the table. +column_name+ can be a single Symbol, or
       # an Array of Symbols. See SchemaStatements#add_index
       #
-      # ===== Examples
       # ====== Creating a simple index
       #  t.index(:name)
       # ====== Creating a unique index
@@ -380,7 +379,7 @@ module ActiveRecord
       end
 
       # Adds timestamps (+created_at+ and +updated_at+) columns to the table. See SchemaStatements#add_timestamps
-      # ===== Example
+      #
       #  t.timestamps
       def timestamps
         @base.add_timestamps(@table_name)
@@ -388,7 +387,7 @@ module ActiveRecord
 
       # Changes the column's definition according to the new options.
       # See TableDefinition#column for details of the options you can use.
-      # ===== Examples
+      #
       #  t.change(:name, :string, :limit => 80)
       #  t.change(:description, :text)
       def change(column_name, type, options = {})
@@ -396,7 +395,7 @@ module ActiveRecord
       end
 
       # Sets a new default value for a column. See SchemaStatements#change_column_default
-      # ===== Examples
+      #
       #  t.change_default(:qualification, 'new')
       #  t.change_default(:authorized, 1)
       def change_default(column_name, default)
@@ -404,16 +403,15 @@ module ActiveRecord
       end
 
       # Removes the column(s) from the table definition.
-      # ===== Examples
+      #
       #  t.remove(:qualification)
       #  t.remove(:qualification, :experience)
       def remove(*column_names)
-        @base.remove_column(@table_name, column_names)
+        @base.remove_column(@table_name, *column_names)
       end
 
       # Removes the given index from the table.
       #
-      # ===== Examples
       # ====== Remove the index_table_name_on_column in the table_name table
       #   t.remove_index :column
       # ====== Remove the index named index_table_name_on_branch_id in the table_name table
@@ -427,14 +425,14 @@ module ActiveRecord
       end
 
       # Removes the timestamp columns (+created_at+ and +updated_at+) from the table.
-      # ===== Example
+      #
       #  t.remove_timestamps
       def remove_timestamps
         @base.remove_timestamps(@table_name)
       end
 
       # Renames a column.
-      # ===== Example
+      #
       #  t.rename(:description, :name)
       def rename(column_name, new_column_name)
         @base.rename_column(@table_name, column_name, new_column_name)
@@ -442,7 +440,7 @@ module ActiveRecord
 
       # Adds a reference. Optionally adds a +type+ column, if <tt>:polymorphic</tt> option is provided.
       # <tt>references</tt> and <tt>belongs_to</tt> are acceptable.
-      # ===== Examples
+      #
       #  t.references(:goat)
       #  t.references(:goat, :polymorphic => true)
       #  t.belongs_to(:goat)
@@ -460,7 +458,7 @@ module ActiveRecord
 
       # Removes a reference. Optionally removes a +type+ column.
       # <tt>remove_references</tt> and <tt>remove_belongs_to</tt> are acceptable.
-      # ===== Examples
+      #
       #  t.remove_references(:goat)
       #  t.remove_references(:goat, :polymorphic => true)
       #  t.remove_belongs_to(:goat)
@@ -475,7 +473,7 @@ module ActiveRecord
       alias :remove_belongs_to  :remove_references
 
       # Adds a column or columns of a specified type
-      # ===== Examples
+      #
       #  t.string(:goat)
       #  t.string(:goat, :sheep)
       %w( string text integer float decimal datetime timestamp time date binary boolean ).each do |column_type|
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
index 30a4f9aa35..62b0f51bb2 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
@@ -21,7 +21,6 @@ module ActiveRecord
 
       # Checks to see if the table +table_name+ exists on the database.
       #
-      # === Example
       #   table_exists?(:developers)
       def table_exists?(table_name)
         tables.include?(table_name.to_s)
@@ -32,7 +31,6 @@ module ActiveRecord
 
       # Checks to see if an index exists on a table for a given index definition.
       #
-      # === Examples
       #  # Check an index exists
       #  index_exists?(:suppliers, :company_id)
       #
@@ -126,7 +124,6 @@ module ActiveRecord
       #   Set to true to drop the table before creating it.
       #   Defaults to false.
       #
-      # ===== Examples
       # ====== Add a backend specific option to the generated SQL (MySQL)
       #  create_table(:suppliers, :options => 'ENGINE=InnoDB DEFAULT CHARSET=utf8')
       # generates:
@@ -193,7 +190,6 @@ module ActiveRecord
       #   Set to true to drop the table before creating it.
       #   Defaults to false.
       #
-      # ===== Examples
       # ====== Add a backend specific option to the generated SQL (MySQL)
       #  create_join_table(:assemblies, :parts, :options => 'ENGINE=InnoDB DEFAULT CHARSET=utf8')
       # generates:
@@ -215,7 +211,6 @@ module ActiveRecord
 
       # A block for changing columns in +table+.
       #
-      # === Example
       #  # change_table() yields a Table instance
       #  change_table(:suppliers) do |t|
       #    t.column :name, :string, :limit => 60
@@ -229,7 +224,6 @@ module ActiveRecord
       #
       #   Defaults to false.
       #
-      # ===== Examples
       # ====== Add a column
       #  change_table(:suppliers) do |t|
       #    t.column :name, :string, :limit => 60
@@ -288,7 +282,7 @@ module ActiveRecord
       end
 
       # Renames a table.
-      # ===== Example
+      #
       #  rename_table('octopuses', 'octopi')
       def rename_table(table_name, new_name)
         raise NotImplementedError, "rename_table is not implemented"
@@ -308,7 +302,7 @@ module ActiveRecord
       end
 
       # Removes the column(s) from the table definition.
-      # ===== Examples
+      #
       #  remove_column(:suppliers, :qualification)
       #  remove_columns(:suppliers, :qualification, :experience)
       def remove_column(table_name, *column_names)
@@ -318,7 +312,7 @@ module ActiveRecord
 
       # Changes the column's definition according to the new options.
       # See TableDefinition#column for details of the options you can use.
-      # ===== Examples
+      #
       #  change_column(:suppliers, :name, :string, :limit => 80)
       #  change_column(:accounts, :description, :text)
       def change_column(table_name, column_name, type, options = {})
@@ -326,7 +320,7 @@ module ActiveRecord
       end
 
       # Sets a new default value for a column.
-      # ===== Examples
+      #
       #  change_column_default(:suppliers, :qualification, 'new')
       #  change_column_default(:accounts, :authorized, 1)
       #  change_column_default(:users, :email, nil)
@@ -335,7 +329,7 @@ module ActiveRecord
       end
 
       # Renames a column.
-      # ===== Example
+      #
       #  rename_column(:suppliers, :description, :name)
       def rename_column(table_name, column_name, new_column_name)
         raise NotImplementedError, "rename_column is not implemented"
@@ -347,8 +341,6 @@ module ActiveRecord
       # The index will be named after the table and the column name(s), unless
       # you pass <tt>:name</tt> as an option.
       #
-      # ===== Examples
-      #
       # ====== Creating a simple index
       #  add_index(:suppliers, :name)
       # generates
@@ -537,7 +529,7 @@ module ActiveRecord
       end
 
       # Adds timestamps (created_at and updated_at) columns to the named table.
-      # ===== Examples
+      #
       #  add_timestamps(:suppliers)
       def add_timestamps(table_name)
         add_column table_name, :created_at, :datetime
@@ -545,7 +537,7 @@ module ActiveRecord
       end
 
       # Removes the timestamp columns (created_at and updated_at) from the table definition.
-      # ===== Examples
+      #
       #  remove_timestamps(:suppliers)
       def remove_timestamps(table_name)
         remove_column table_name, :updated_at
@@ -618,8 +610,6 @@ module ActiveRecord
         end
 
         def columns_for_remove(table_name, *column_names)
-          column_names = column_names.flatten
-
           raise ArgumentError.new("You must specify at least one column name. Example: remove_column(:people, :first_name)") if column_names.blank?
           column_names.map {|column_name| quote_column_name(column_name) }
         end
diff --git a/activerecord/lib/active_record/connection_adapters/column.rb b/activerecord/lib/active_record/connection_adapters/column.rb
index b7e1513422..1933ce2b46 100644
--- a/activerecord/lib/active_record/connection_adapters/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/column.rb
@@ -95,7 +95,7 @@ module ActiveRecord
 
         case type
         when :string, :text        then value
-        when :integer              then value.to_i rescue value ? 1 : 0
+        when :integer              then value.to_i
         when :float                then value.to_f
         when :decimal              then klass.value_to_decimal(value)
         when :datetime, :timestamp then klass.string_to_time(value)
@@ -158,7 +158,7 @@ module ActiveRecord
 
         def value_to_date(value)
           if value.is_a?(String)
-            return nil if value.empty?
+            return nil if value.blank?
             fast_string_to_date(value) || fallback_string_to_date(value)
           elsif value.respond_to?(:to_date)
             value.to_date
@@ -169,14 +169,14 @@ module ActiveRecord
 
         def string_to_time(string)
           return string unless string.is_a?(String)
-          return nil if string.empty?
+          return nil if string.blank?
 
           fast_string_to_time(string) || fallback_string_to_time(string)
         end
 
         def string_to_dummy_time(string)
           return string unless string.is_a?(String)
-          return nil if string.empty?
+          return nil if string.blank?
 
           string_to_time "2000-01-01 #{string}"
         end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
index 92908d9599..350ccce03d 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
@@ -253,6 +253,14 @@ module ActiveRecord
         # By default, MySQL 'where id is null' selects the last inserted id.
         # Turn this off. http://dev.rubyonrails.org/ticket/6778
         variable_assignments = ['SQL_AUTO_IS_NULL=0']
+
+        # Make MySQL reject illegal values rather than truncating or
+        # blanking them. See
+        # http://dev.mysql.com/doc/refman/5.5/en/server-sql-mode.html#sqlmode_strict_all_tables
+        if @config.fetch(:strict, true)
+          variable_assignments << "SQL_MODE='STRICT_ALL_TABLES'"
+        end
+
         encoding = @config[:encoding]
 
         # make sure we set the encoding
diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index 724dbff1f0..0b6734b010 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -53,6 +53,7 @@ module ActiveRecord
     # * <tt>:database</tt> - The name of the database. No default, must be provided.
     # * <tt>:encoding</tt> - (Optional) Sets the client encoding by executing "SET NAMES <encoding>" after connection.
     # * <tt>:reconnect</tt> - Defaults to false (See MySQL documentation: http://dev.mysql.com/doc/refman/5.0/en/auto-reconnect.html).
+    # * <tt>:strict</tt> - Defaults to true. Enable STRICT_ALL_TABLES. (See MySQL documentation: http://dev.mysql.com/doc/refman/5.5/en/server-sql-mode.html)
     # * <tt>:sslca</tt> - Necessary to use MySQL with an SSL connection.
     # * <tt>:sslkey</tt> - Necessary to use MySQL with an SSL connection.
     # * <tt>:sslcert</tt> - Necessary to use MySQL with an SSL connection.
@@ -404,6 +405,13 @@ module ActiveRecord
         # By default, MySQL 'where id is null' selects the last inserted id.
         # Turn this off. http://dev.rubyonrails.org/ticket/6778
         execute("SET SQL_AUTO_IS_NULL=0", :skip_logging)
+
+        # Make MySQL reject illegal values rather than truncating or
+        # blanking them. See
+        # http://dev.mysql.com/doc/refman/5.5/en/server-sql-mode.html#sqlmode_strict_all_tables
+        if @config.fetch(:strict, true)
+          execute("SET SQL_MODE='STRICT_ALL_TABLES'", :skip_logging)
+        end
       end
 
       def select(sql, name = nil, binds = [])
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 273c165084..4d5459939b 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -511,8 +511,13 @@ module ActiveRecord
           else super
           end
         when Float
-          return super unless value.infinite? && column.type == :datetime
-          "'#{value.to_s.downcase}'"
+          if value.infinite? && column.type == :datetime
+            "'#{value.to_s.downcase}'"
+          elsif value.infinite? || value.nan?
+            "'#{value.to_s}'"
+          else
+            super
+          end
         when Numeric
           return super unless column.sql_type == 'money'
           # Not truly string input, so doesn't require (or allow) escape string syntax.
@@ -1233,7 +1238,10 @@ module ActiveRecord
 
         # Construct a clean list of column names from the ORDER BY clause, removing
         # any ASC/DESC modifiers
-        order_columns = orders.collect { |s| s.gsub(/\s+(ASC|DESC)\s*(NULLS\s+(FIRST|LAST)\s*)?/i, '') }
+        order_columns = orders.collect do |s|
+          s = s.to_sql unless s.is_a?(String)
+          s.gsub(/\s+(ASC|DESC)\s*(NULLS\s+(FIRST|LAST)\s*)?/i, '')
+        end
         order_columns.delete_if { |c| c.blank? }
         order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
 
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
index 83f75e3505..44e407a561 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
@@ -446,7 +446,7 @@ module ActiveRecord
 
       def remove_column(table_name, *column_names) #:nodoc:
         raise ArgumentError.new("You must specify at least one column name. Example: remove_column(:people, :first_name)") if column_names.empty?
-        column_names.flatten.each do |column_name|
+        column_names.each do |column_name|
           alter_table(table_name) do |definition|
             definition.columns.delete(definition[column_name])
           end
diff --git a/activerecord/lib/active_record/core.rb b/activerecord/lib/active_record/core.rb
index eb8f4ad669..f5349b0bea 100644
--- a/activerecord/lib/active_record/core.rb
+++ b/activerecord/lib/active_record/core.rb
@@ -1,5 +1,6 @@
 require 'active_support/concern'
 require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/object/deep_dup'
 require 'thread'
 
 module ActiveRecord
@@ -76,7 +77,7 @@ module ActiveRecord
 
       ##
       # :singleton-method:
-      # Specifies wether or not has_many or has_one association option
+      # Specifies whether or not has_many or has_one association option
       # :dependent => :restrict raises an exception. If set to true, the
       # ActiveRecord::DeleteRestrictionError exception will be raised
       # along with a DEPRECATION WARNING. If set to false, an error would
@@ -165,7 +166,7 @@ module ActiveRecord
     #   # Instantiates a single new object bypassing mass-assignment security
     #   User.new({ :first_name => 'Jamie', :is_admin => true }, :without_protection => true)
     def initialize(attributes = nil, options = {})
-      @attributes = self.class.initialize_attributes(self.class.column_defaults.dup)
+      @attributes = self.class.initialize_attributes(self.class.column_defaults.deep_dup)
       @columns_hash = self.class.column_types.dup
 
       init_internals
@@ -203,13 +204,35 @@ module ActiveRecord
 
       self
     end
-
+    
+    ##
+    # :method: clone
+    # Identical to Ruby's clone method.  This is a "shallow" copy.  Be warned that your attributes are not copied.
+    # That means that modifying attributes of the clone will modify the original, since they will both point to the
+    # same attributes hash. If you need a copy of your attributes hash, please use the #dup method.
+    #
+    #   user = User.first
+    #   new_user = user.clone
+    #   user.name               # => "Bob"
+    #   new_user.name = "Joe"
+    #   user.name               # => "Joe"
+    #
+    #   user.object_id == new_user.object_id            # => false
+    #   user.name.object_id == new_user.name.object_id  # => true
+    # 
+    #   user.name.object_id == user.dup.name.object_id  # => false
+    
+    ##
+    # :method: dup
     # Duped objects have no id assigned and are treated as new records. Note
     # that this is a "shallow" copy as it copies the object's attributes
     # only, not its associations. The extent of a "deep" copy is application
     # specific and is therefore left to the application to implement according
     # to its need.
     # The dup method does not preserve the timestamps (created|updated)_(at|on).
+    
+    ##
+    # :nodoc:
     def initialize_dup(other)
       cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
       self.class.initialize_attributes(cloned_attributes)
diff --git a/activerecord/lib/active_record/dynamic_finder_match.rb b/activerecord/lib/active_record/dynamic_finder_match.rb
deleted file mode 100644
index 0473d6aafc..0000000000
--- a/activerecord/lib/active_record/dynamic_finder_match.rb
+++ /dev/null
@@ -1,108 +0,0 @@
-module ActiveRecord
-
-  # = Active Record Dynamic Finder Match
-  #
-  # Refer to ActiveRecord::Base documentation for Dynamic attribute-based finders for detailed info
-  #
-  class DynamicFinderMatch
-    def self.match(method)
-      method = method.to_s
-      klass = klasses.find do |_klass|
-        _klass.matches?(method)
-      end
-      klass.new(method) if klass
-    end
-
-    def self.matches?(method)
-      method =~ self::METHOD_PATTERN
-    end
-
-    def self.klasses
-      [FindBy, FindByBang, FindOrInitializeCreateBy, FindOrCreateByBang]
-    end
-
-    def initialize(method)
-      @finder = :first
-      @instantiator = nil
-      match_data = method.match(self.class::METHOD_PATTERN)
-      @attribute_names = match_data[-1].split("_and_")
-      initialize_from_match_data(match_data)
-    end
-
-    attr_reader :finder, :attribute_names, :instantiator
-
-    def finder?
-      @finder && !@instantiator
-    end
-
-    def creator?
-      @finder == :first && @instantiator == :create
-    end
-
-    def instantiator?
-      @instantiator
-    end
-
-    def bang?
-      false
-    end
-
-    def valid_arguments?(arguments)
-      arguments.size >= @attribute_names.size
-    end
-
-    def save_record?
-      @instantiator == :create
-    end
-
-    def save_method
-      bang? ? :save! : :save
-    end
-
-    private
-
-    def initialize_from_match_data(match_data)
-    end
-  end
-
-  class FindBy < DynamicFinderMatch
-    METHOD_PATTERN = /^find_(all_|last_)?by_([_a-zA-Z]\w*)$/
-
-    def initialize_from_match_data(match_data)
-      @finder = :last if match_data[1] == 'last_'
-      @finder = :all if match_data[1] == 'all_'
-    end
-  end
-
-  class FindByBang < DynamicFinderMatch
-    METHOD_PATTERN = /^find_by_([_a-zA-Z]\w*)\!$/
-
-    def bang?
-      true
-    end
-  end
-
-  class FindOrInitializeCreateBy < DynamicFinderMatch
-    METHOD_PATTERN = /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
-
-    def initialize_from_match_data(match_data)
-      @instantiator = match_data[1] == 'initialize' ? :new : :create
-    end
-
-    def valid_arguments?(arguments)
-      arguments.size == 1 && arguments.first.is_a?(Hash) || super
-    end
-  end
-
-  class FindOrCreateByBang < DynamicFinderMatch
-    METHOD_PATTERN = /^find_or_create_by_([_a-zA-Z]\w*)\!$/
-
-    def initialize_from_match_data(match_data)
-      @instantiator = :create
-    end
-
-    def bang?
-      true
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/dynamic_matchers.rb b/activerecord/lib/active_record/dynamic_matchers.rb
index e35b1c91a0..e278e62ce7 100644
--- a/activerecord/lib/active_record/dynamic_matchers.rb
+++ b/activerecord/lib/active_record/dynamic_matchers.rb
@@ -1,83 +1,130 @@
 module ActiveRecord
-  module DynamicMatchers
-    def respond_to?(method_id, include_private = false)
-      match       = find_dynamic_match(method_id)
-      valid_match = match && all_attributes_exists?(match.attribute_names)
+  module DynamicMatchers #:nodoc:
+    # This code in this file seems to have a lot of indirection, but the indirection
+    # is there to provide extension points for the active_record_deprecated_finders
+    # gem. When we stop supporting active_record_deprecated_finders (from Rails 5),
+    # then we can remove the indirection.
 
-      valid_match || super
+    def respond_to?(name, include_private = false)
+      match = Method.match(self, name)
+      match && match.valid? || super
     end
 
     private
 
-    # Enables dynamic finders like <tt>User.find_by_user_name(user_name)</tt> and
-    # <tt>User.scoped_by_user_name(user_name). Refer to Dynamic attribute-based finders
-    # section at the top of this file for more detailed information.
-    #
-    # It's even possible to use all the additional parameters to +find+. For example, the
-    # full interface for +find_all_by_amount+ is actually <tt>find_all_by_amount(amount, options)</tt>.
-    #
-    # Each dynamic finder using <tt>scoped_by_*</tt> is also defined in the class after it
-    # is first invoked, so that future attempts to use it do not run through method_missing.
-    def method_missing(method_id, *arguments, &block)
-      if match = find_dynamic_match(method_id)
-        attribute_names = match.attribute_names
-        super unless all_attributes_exists?(attribute_names)
-
-        unless match.valid_arguments?(arguments)
-          method_trace = "#{__FILE__}:#{__LINE__}:in `#{method_id}'"
-          backtrace = [method_trace] + caller
-          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{attribute_names.size})", backtrace
-        end
+    def method_missing(name, *arguments, &block)
+      match = Method.match(self, name)
 
-        if match.respond_to?(:scope?) && match.scope?
-          define_scope_method(method_id, attribute_names)
-          send(method_id, *arguments)
-        elsif match.finder?
-          options = arguments.extract_options!
-          relation = options.any? ? scoped(options) : scoped
-          relation.send :find_by_attributes, match, attribute_names, *arguments, &block
-        elsif match.instantiator?
-          scoped.send :find_or_instantiator_by_attributes, match, attribute_names, *arguments, &block
-        end
+      if match && match.valid?
+        match.define
+        send(name, *arguments, &block)
       else
         super
       end
     end
 
-    def define_scope_method(method_id, attribute_names) #:nodoc
-      self.class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def self.#{method_id}(*args)                                    # def self.scoped_by_user_name_and_password(*args)
-          conditions = Hash[[:#{attribute_names.join(',:')}].zip(args)] #   conditions = Hash[[:user_name, :password].zip(args)]
-          where(conditions)                                             #   where(conditions)
-        end                                                             # end
-      METHOD
-    end
+    class Method
+      @matchers = []
 
-    def find_dynamic_match(method_id) #:nodoc:
-      DynamicFinderMatch.match(method_id) || DynamicScopeMatch.match(method_id)
-    end
+      class << self
+        attr_reader :matchers
 
-    # Similar in purpose to +expand_hash_conditions_for_aggregates+.
-    def expand_attribute_names_for_aggregates(attribute_names)
-      attribute_names.map do |attribute_name|
-        if aggregation = reflect_on_aggregation(attribute_name.to_sym)
-          aggregate_mapping(aggregation).map do |field_attr, _|
-            field_attr.to_sym
-          end
-        else
-          attribute_name.to_sym
+        def match(model, name)
+          klass = matchers.find { |k| name =~ k.pattern }
+          klass.new(model, name) if klass
+        end
+
+        def pattern
+          /^#{prefix}_([_a-zA-Z]\w*)#{suffix}$/
+        end
+
+        def prefix
+          raise NotImplementedError
+        end
+
+        def suffix
+          ''
         end
-      end.flatten
+      end
+
+      attr_reader :model, :name, :attribute_names
+
+      def initialize(model, name)
+        @model           = model
+        @name            = name.to_s
+        @attribute_names = @name.match(self.class.pattern)[1].split('_and_')
+      end
+
+      def valid?
+        attribute_names.all? { |name| model.columns_hash[name] || model.reflect_on_aggregation(name.to_sym) }
+      end
+
+      def define
+        model.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def self.#{name}(#{signature})
+            #{body}
+          end
+        CODE
+      end
+
+      def body
+        raise NotImplementedError
+      end
     end
 
-    def all_attributes_exists?(attribute_names)
-      (expand_attribute_names_for_aggregates(attribute_names) -
-       column_methods_hash.keys).empty?
+    module Finder
+      # Extended in active_record_deprecated_finders
+      def body
+        result
+      end
+
+      # Extended in active_record_deprecated_finders
+      def result
+        "#{finder}(#{attributes_hash})"
+      end
+
+      # Extended in active_record_deprecated_finders
+      def signature
+        attribute_names.join(', ')
+      end
+
+      def attributes_hash
+        "{" + attribute_names.map { |name| ":#{name} => #{name}" }.join(',') + "}"
+      end
+
+      def finder
+        raise NotImplementedError
+      end
     end
 
-    def aggregate_mapping(reflection)
-      mapping = reflection.options[:mapping] || [reflection.name, reflection.name]
-      mapping.first.is_a?(Array) ? mapping : [mapping]
+    class FindBy < Method
+      Method.matchers << self
+      include Finder
+
+      def self.prefix
+        "find_by"
+      end
+
+      def finder
+        "find_by"
+      end
+    end
+
+    class FindByBang < Method
+      Method.matchers << self
+      include Finder
+
+      def self.prefix
+        "find_by"
+      end
+
+      def self.suffix
+        "!"
+      end
+
+      def finder
+        "find_by!"
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/dynamic_scope_match.rb b/activerecord/lib/active_record/dynamic_scope_match.rb
deleted file mode 100644
index 6c043d29c4..0000000000
--- a/activerecord/lib/active_record/dynamic_scope_match.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-module ActiveRecord
-
-  # = Active Record Dynamic Scope Match
-  #
-  # Provides dynamic attribute-based scopes such as <tt>scoped_by_price(4.99)</tt>
-  # if, for example, the <tt>Product</tt> has an attribute with that name. You can
-  # chain more <tt>scoped_by_* </tt> methods after the other. It acts like a named
-  # scope except that it's dynamic.
-  class DynamicScopeMatch
-    METHOD_PATTERN = /^scoped_by_([_a-zA-Z]\w*)$/
-
-    def self.match(method)
-      if method.to_s =~ METHOD_PATTERN
-        new(true, $1 && $1.split('_and_'))
-      end
-    end
-
-    def initialize(scope, attribute_names)
-      @scope           = scope
-      @attribute_names = attribute_names
-    end
-
-    attr_reader :scope, :attribute_names
-    alias :scope? :scope
-
-    def valid_arguments?(arguments)
-      arguments.size >= @attribute_names.size
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/fixtures.rb b/activerecord/lib/active_record/fixtures.rb
index 9796b0a321..c630af59f0 100644
--- a/activerecord/lib/active_record/fixtures.rb
+++ b/activerecord/lib/active_record/fixtures.rb
@@ -372,19 +372,23 @@ module ActiveRecord
   #
   # Any fixture labeled "DEFAULTS" is safely ignored.
   class Fixtures
+    #--
+    # NOTE: an instance of Fixtures can be called fixture_set, it is normally stored in a single YAML file and possibly in a folder with the same name.
+    #++
     MAX_ID = 2 ** 30 - 1
 
     @@all_cached_fixtures = Hash.new { |h,k| h[k] = {} }
 
-    def self.default_fixture_model_name(fixture_name) # :nodoc:
+    def self.default_fixture_model_name(fixture_set_name) # :nodoc:
       ActiveRecord::Base.pluralize_table_names ?
-        fixture_name.singularize.camelize :
-        fixture_name.camelize
+        fixture_set_name.singularize.camelize :
+        fixture_set_name.camelize
     end
 
-    def self.default_fixture_table_name(fixture_name) # :nodoc:
-       "#{ActiveRecord::Base.table_name_prefix}"\
-         "#{fixture_name.tr('/', '_')}#{ActiveRecord::Base.table_name_suffix}".to_sym
+    def self.default_fixture_table_name(fixture_set_name) # :nodoc:
+       "#{ ActiveRecord::Base.table_name_prefix }"\
+       "#{ fixture_set_name.tr('/', '_') }"\
+       "#{ ActiveRecord::Base.table_name_suffix }".to_sym
     end
 
     def self.reset_cache
@@ -411,11 +415,11 @@ module ActiveRecord
       cache_for_connection(connection).update(fixtures_map)
     end
 
-    def self.instantiate_fixtures(object, fixture_name, fixtures, load_instances = true)
+    def self.instantiate_fixtures(object, fixture_set, load_instances = true)
       if load_instances
-        fixtures.each do |name, fixture|
+        fixture_set.each do |fixture_name, fixture|
           begin
-            object.instance_variable_set "@#{name}", fixture.find
+            object.instance_variable_set "@#{fixture_name}", fixture.find
           rescue FixtureClassNotFound
             nil
           end
@@ -424,61 +428,59 @@ module ActiveRecord
     end
 
     def self.instantiate_all_loaded_fixtures(object, load_instances = true)
-      all_loaded_fixtures.each do |table_name, fixtures|
-        ActiveRecord::Fixtures.instantiate_fixtures(object, table_name, fixtures, load_instances)
+      all_loaded_fixtures.each_value do |fixture_set|
+        instantiate_fixtures(object, fixture_set, load_instances)
       end
     end
 
     cattr_accessor :all_loaded_fixtures
     self.all_loaded_fixtures = {}
 
-    def self.create_fixtures(fixtures_directory, table_names, class_names = {})
-      table_names = Array(table_names).map(&:to_s)
+    def self.create_fixtures(fixtures_directory, fixture_set_names, class_names = {})
+      fixture_set_names = Array(fixture_set_names).map(&:to_s)
       class_names = class_names.stringify_keys
 
       # FIXME: Apparently JK uses this.
       connection = block_given? ? yield : ActiveRecord::Base.connection
 
-      files_to_read = table_names.reject { |table_name|
-        fixture_is_cached?(connection, table_name)
+      files_to_read = fixture_set_names.reject { |fs_name|
+        fixture_is_cached?(connection, fs_name)
       }
 
       unless files_to_read.empty?
         connection.disable_referential_integrity do
           fixtures_map = {}
 
-          fixture_files = files_to_read.map do |path|
-            fixture_name = path
-
-            fixtures_map[fixture_name] = new( # ActiveRecord::Fixtures.new
+          fixture_sets = files_to_read.map do |fs_name|
+            fixtures_map[fs_name] = new( # ActiveRecord::Fixtures.new
               connection,
-              fixture_name,
-              class_names[fixture_name.to_s] || default_fixture_model_name(fixture_name),
-              ::File.join(fixtures_directory, path))
+              fs_name,
+              class_names[fs_name] || default_fixture_model_name(fs_name),
+              ::File.join(fixtures_directory, fs_name))
           end
 
           all_loaded_fixtures.update(fixtures_map)
 
           connection.transaction(:requires_new => true) do
-            fixture_files.each do |ff|
-              conn = ff.model_class.respond_to?(:connection) ? ff.model_class.connection : connection
-              table_rows = ff.table_rows
+            fixture_sets.each do |fs|
+              conn = fs.model_class.respond_to?(:connection) ? fs.model_class.connection : connection
+              table_rows = fs.table_rows
 
               table_rows.keys.each do |table|
                 conn.delete "DELETE FROM #{conn.quote_table_name(table)}", 'Fixture Delete'
               end
 
-              table_rows.each do |table_name,rows|
+              table_rows.each do |fixture_set_name, rows|
                 rows.each do |row|
-                  conn.insert_fixture(row, table_name)
+                  conn.insert_fixture(row, fixture_set_name)
                 end
               end
             end
 
             # Cap primary key sequences to max(pk).
             if connection.respond_to?(:reset_pk_sequence!)
-              fixture_files.each do |ff|
-                connection.reset_pk_sequence!(ff.table_name)
+              fixture_sets.each do |fs|
+                connection.reset_pk_sequence!(fs.table_name)
               end
             end
           end
@@ -486,7 +488,7 @@ module ActiveRecord
           cache_fixtures(connection, fixtures_map)
         end
       end
-      cached_fixtures(connection, table_names)
+      cached_fixtures(connection, fixture_set_names)
     end
 
     # Returns a consistent, platform-independent identifier for +label+.
@@ -497,26 +499,23 @@ module ActiveRecord
 
     attr_reader :table_name, :name, :fixtures, :model_class
 
-    def initialize(connection, fixture_name, class_name, fixture_path)
-      @connection   = connection
-      @fixture_path = fixture_path
-      @name         = fixture_name
-      @class_name   = class_name
-
-      @fixtures     = {}
+    def initialize(connection, name, class_name, path)
+      @fixtures = {} # Ordered hash
+      @name     = name
+      @path     = path
 
-      # Should be an AR::Base type class
-      if class_name.is_a?(Class)
+      if class_name.is_a?(Class) # TODO: Should be an AR::Base type class, or any?
         @model_class = class_name
       else
         @model_class = class_name.constantize rescue nil
       end
 
-      @connection  = model_class.connection if model_class && model_class.respond_to?(:connection)
+      @connection  = ( model_class.respond_to?(:connection) ?
+                       model_class.connection : connection )
 
       @table_name = ( model_class.respond_to?(:table_name) ?
                       model_class.table_name :
-                      self.class.default_fixture_table_name(fixture_name) )
+                      self.class.default_fixture_table_name(name) )
 
       read_fixture_files
     end
@@ -555,8 +554,8 @@ module ActiveRecord
         if model_class && model_class < ActiveRecord::Model
           # fill in timestamp columns if they aren't specified and the model is set to record_timestamps
           if model_class.record_timestamps
-            timestamp_column_names.each do |name|
-              row[name] = now unless row.key?(name)
+            timestamp_column_names.each do |c_name|
+              row[c_name] = now unless row.key?(c_name)
             end
           end
 
@@ -634,26 +633,23 @@ module ActiveRecord
       end
 
       def read_fixture_files
-        yaml_files = Dir["#{@fixture_path}/**/*.yml"].select { |f|
+        yaml_files = Dir["#{@path}/**/*.yml"].select { |f|
           ::File.file?(f)
         } + [yaml_file_path]
 
         yaml_files.each do |file|
           Fixtures::File.open(file) do |fh|
-            fh.each do |name, row|
-              fixtures[name] = ActiveRecord::Fixture.new(row, model_class)
+            fh.each do |fixture_name, row|
+              fixtures[fixture_name] = ActiveRecord::Fixture.new(row, model_class)
             end
           end
         end
       end
 
       def yaml_file_path
-        "#{@fixture_path}.yml"
+        "#{@path}.yml"
       end
 
-      def yaml_fixtures_key(path)
-        ::File.basename(@fixture_path).split(".").first
-      end
   end
 
   class Fixture #:nodoc:
@@ -708,7 +704,7 @@ module ActiveRecord
       class_attribute :fixture_table_names
       class_attribute :fixture_class_names
       class_attribute :use_transactional_fixtures
-      class_attribute :use_instantiated_fixtures   # true, false, or :no_instances
+      class_attribute :use_instantiated_fixtures # true, false, or :no_instances
       class_attribute :pre_loaded_fixtures
 
       self.fixture_table_names = []
@@ -716,9 +712,8 @@ module ActiveRecord
       self.use_instantiated_fixtures = false
       self.pre_loaded_fixtures = false
 
-      self.fixture_class_names = Hash.new do |h, fixture_name|
-        fixture_name = fixture_name.to_s
-        h[fixture_name] = ActiveRecord::Fixtures.default_fixture_model_name(fixture_name)
+      self.fixture_class_names = Hash.new do |h, fixture_set_name|
+        h[fixture_set_name] = ActiveRecord::Fixtures.default_fixture_model_name(fixture_set_name)
       end
     end
 
@@ -742,18 +737,18 @@ module ActiveRecord
         self.fixture_class_names = self.fixture_class_names.merge(class_names.stringify_keys)
       end
 
-      def fixtures(*fixture_names)
-        if fixture_names.first == :all
-          fixture_names = Dir["#{fixture_path}/**/*.yml"].map { |f|
+      def fixtures(*fixture_set_names)
+        if fixture_set_names.first == :all
+          fixture_set_names = Dir["#{fixture_path}/**/*.yml"].map { |f|
             File.basename f, '.yml'
           }
         else
-          fixture_names = fixture_names.flatten.map { |n| n.to_s }
+          fixture_set_names = fixture_set_names.flatten.map { |n| n.to_s }
         end
 
-        self.fixture_table_names |= fixture_names
-        require_fixture_classes(fixture_names)
-        setup_fixture_accessors(fixture_names)
+        self.fixture_table_names |= fixture_set_names
+        require_fixture_classes(fixture_set_names)
+        setup_fixture_accessors(fixture_set_names)
       end
 
       def try_to_load_dependency(file_name)
@@ -768,33 +763,39 @@ module ActiveRecord
         end
       end
 
-      def require_fixture_classes(fixture_names = nil)
-        (fixture_names || fixture_table_names).each do |fixture_name|
-          file_name = fixture_name.to_s
+      def require_fixture_classes(fixture_set_names = nil)
+        if fixture_set_names
+          fixture_set_names = fixture_set_names.map { |n| n.to_s }
+        else
+          fixture_set_names = fixture_table_names
+        end
+
+        fixture_set_names.each do |file_name|
           file_name = file_name.singularize if ActiveRecord::Base.pluralize_table_names
           try_to_load_dependency(file_name)
         end
       end
 
-      def setup_fixture_accessors(fixture_names = nil)
-        fixture_names = Array(fixture_names || fixture_table_names)
+      def setup_fixture_accessors(fixture_set_names = nil)
+        fixture_set_names = Array(fixture_set_names || fixture_table_names)
         methods = Module.new do
-          fixture_names.each do |fixture_name|
-            fixture_name = fixture_name.to_s
-            accessor_name = fixture_name.tr('/', '_').to_sym
+          fixture_set_names.each do |fs_name|
+            fs_name = fs_name.to_s
+            accessor_name = fs_name.tr('/', '_').to_sym
 
-            define_method(accessor_name) do |*fixtures|
-              force_reload = fixtures.pop if fixtures.last == true || fixtures.last == :reload
+            define_method(accessor_name) do |*fixture_names|
+              force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
 
-              @fixture_cache[fixture_name] ||= {}
+              @fixture_cache[fs_name] ||= {}
 
-              instances = fixtures.map do |fixture|
-                @fixture_cache[fixture_name].delete(fixture) if force_reload
+              instances = fixture_names.map do |f_name|
+                f_name = f_name.to_s
+                @fixture_cache[fs_name].delete(f_name) if force_reload
 
-                if @loaded_fixtures[fixture_name][fixture.to_s]
-                  @fixture_cache[fixture_name][fixture] ||= @loaded_fixtures[fixture_name][fixture.to_s].find
+                if @loaded_fixtures[fs_name][f_name]
+                  @fixture_cache[fs_name][f_name] ||= @loaded_fixtures[fs_name][f_name].find
                 else
-                  raise StandardError, "No entry named '#{fixture}' found for fixture collection '#{fixture_name}'"
+                  raise StandardError, "No fixture named '#{f_name}' found for fixture set '#{fs_name}'"
                 end
               end
 
@@ -823,7 +824,7 @@ module ActiveRecord
     end
 
     def setup_fixtures
-      return unless !ActiveRecord::Base.configurations.blank?
+      return if ActiveRecord::Base.configurations.blank?
 
       if pre_loaded_fixtures && !use_transactional_fixtures
         raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures'
@@ -901,8 +902,8 @@ module ActiveRecord
           ActiveRecord::Fixtures.instantiate_all_loaded_fixtures(self, load_instances?)
         else
           raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?
-          @loaded_fixtures.each do |fixture_name, fixtures|
-            ActiveRecord::Fixtures.instantiate_fixtures(self, fixture_name, fixtures, load_instances?)
+          @loaded_fixtures.each_value do |fixture_set|
+            ActiveRecord::Fixtures.instantiate_fixtures(self, fixture_set, load_instances?)
           end
         end
       end
diff --git a/activerecord/lib/active_record/nested_attributes.rb b/activerecord/lib/active_record/nested_attributes.rb
index 32a1dae6bc..95a2ddcc11 100644
--- a/activerecord/lib/active_record/nested_attributes.rb
+++ b/activerecord/lib/active_record/nested_attributes.rb
@@ -19,10 +19,10 @@ module ActiveRecord
     # = Active Record Nested Attributes
     #
     # Nested attributes allow you to save attributes on associated records
-    # through the parent. By default nested attribute updating is turned off,
-    # you can enable it using the accepts_nested_attributes_for class method.
-    # When you enable nested attributes an attribute writer is defined on
-    # the model.
+    # through the parent. By default nested attribute updating is turned off
+    # and you can enable it using the accepts_nested_attributes_for class
+    # method. When you enable nested attributes an attribute writer is
+    # defined on the model.
     #
     # The attribute writer is named after the association, which means that
     # in the following example, two new methods are added to your model:
diff --git a/activerecord/lib/active_record/querying.rb b/activerecord/lib/active_record/querying.rb
index 29b8b2fb73..4d8283bcff 100644
--- a/activerecord/lib/active_record/querying.rb
+++ b/activerecord/lib/active_record/querying.rb
@@ -3,7 +3,7 @@ require 'active_support/deprecation'
 
 module ActiveRecord
   module Querying
-    delegate :find, :first, :first!, :last, :last!, :all, :exists?, :any?, :many?, :to => :scoped
+    delegate :find, :take, :take!, :first, :first!, :last, :last!, :all, :exists?, :any?, :many?, :to => :scoped
     delegate :first_or_create, :first_or_create!, :first_or_initialize, :to => :scoped
     delegate :find_by, :find_by!, :to => :scoped
     delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, :to => :scoped
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index d4f4d593c6..c380b5c029 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -153,6 +153,10 @@ module ActiveRecord
     # Holds all the meta-data about an aggregation as it was specified in the
     # Active Record class.
     class AggregateReflection < MacroReflection #:nodoc:
+      def mapping
+        mapping = options[:mapping] || [name, name]
+        mapping.first.is_a?(Array) ? mapping : [mapping]
+      end
     end
 
     # Holds all the meta-data about an association as it was specified in the
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index 333d31d8a3..779e052e3c 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -390,6 +390,8 @@ module ActiveRecord
     # If you need to destroy dependent associations or call your <tt>before_*</tt> or
     # +after_destroy+ callbacks, use the +destroy_all+ method instead.
     def delete_all(conditions = nil)
+      raise ActiveRecordError.new("delete_all doesn't support limit scope") if self.limit_value
+
       if conditions
         where(conditions).delete_all
       else
diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index 1ceb1949a4..4fedd33d64 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -51,15 +51,37 @@ module ActiveRecord
     #   Post.find_by "published_at < ?", 2.weeks.ago
     #
     def find_by(*args)
-      where(*args).first
+      where(*args).take
     end
 
     # Like <tt>find_by</tt>, except that if no record is found, raises
     # an <tt>ActiveRecord::RecordNotFound</tt> error.
     def find_by!(*args)
-      where(*args).first!
+      where(*args).take!
     end
 
+    # Gives a record (or N records if a parameter is supplied) without any implied
+    # order. The order will depend on the database implementation.
+    # If an order is supplied it will be respected.
+    #
+    # Examples:
+    #
+    #   Person.take # returns an object fetched by SELECT * FROM people
+    #   Person.take(5) # returns 5 objects fetched by SELECT * FROM people LIMIT 5
+    #   Person.where(["name LIKE '%?'", name]).take
+    def take(limit = nil)
+      limit ? limit(limit).to_a : find_take
+    end
+
+    # Same as +take+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
+    # is found. Note that <tt>take!</tt> accepts no arguments.
+    def take!
+      take or raise RecordNotFound
+    end
+
+    # Find the first record (or first N records if a parameter is supplied).
+    # If no order is defined it will order by primary key.
+    #
     # Examples:
     #
     #   Person.first # returns the first object fetched by SELECT * FROM people
@@ -67,7 +89,15 @@ module ActiveRecord
     #   Person.where(["user_name = :u", { :u => user_name }]).first
     #   Person.order("created_on DESC").offset(5).first
     def first(limit = nil)
-      limit ? limit(limit).to_a : find_first
+      if limit
+        if order_values.empty? && primary_key
+          order(arel_table[primary_key].asc).limit(limit).to_a
+        else
+          limit(limit).to_a
+        end
+      else
+        find_first
+      end
     end
 
     # Same as +first+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
@@ -76,6 +106,9 @@ module ActiveRecord
       first or raise RecordNotFound
     end
 
+    # Find the last record (or last N records if a parameter is supplied).
+    # If no order is defined it will order by primary key.
+    #
     # Examples:
     #
     #   Person.last # returns the last object fetched by SELECT * FROM people
@@ -83,8 +116,8 @@ module ActiveRecord
     #   Person.order("created_on DESC").offset(5).last
     def last(limit = nil)
       if limit
-        if order_values.empty?
-          order("#{primary_key} DESC").limit(limit).reverse
+        if order_values.empty? && primary_key
+          order(arel_table[primary_key].desc).limit(limit).reverse
         else
           to_a.last(limit)
         end
@@ -137,9 +170,8 @@ module ActiveRecord
     #   Person.exists?(['name LIKE ?', "%#{query}%"])
     #   Person.exists?
     def exists?(id = false)
-      return false if id.nil?
-
       id = id.id if ActiveRecord::Model === id
+      return false if id.nil?
 
       join_dependency = construct_join_dependency_for_association_find
       relation = construct_relation_for_association_find(join_dependency)
@@ -210,47 +242,6 @@ module ActiveRecord
       ids_array.empty? ? raise(ThrowResult) : table[primary_key].in(ids_array)
     end
 
-    def find_by_attributes(match, attributes, *args)
-      conditions = Hash[attributes.map {|a| [a, args[attributes.index(a)]]}]
-      result = where(conditions).send(match.finder)
-
-      if match.bang? && result.blank?
-        raise RecordNotFound, "Couldn't find #{@klass.name} with #{conditions.to_a.collect {|p| p.join(' = ')}.join(', ')}"
-      else
-        if block_given? && result
-          yield(result)
-        else
-          result
-        end
-      end
-    end
-
-    def find_or_instantiator_by_attributes(match, attributes, *args)
-      options = args.size > 1 && args.last(2).all?{ |a| a.is_a?(Hash) } ? args.extract_options! : {}
-      protected_attributes_for_create, unprotected_attributes_for_create = {}, {}
-      args.each_with_index do |arg, i|
-        if arg.is_a?(Hash)
-          protected_attributes_for_create = args[i].with_indifferent_access
-        else
-          unprotected_attributes_for_create[attributes[i]] = args[i]
-        end
-      end
-
-      conditions = (protected_attributes_for_create.merge(unprotected_attributes_for_create)).slice(*attributes).symbolize_keys
-
-      record = where(conditions).first
-
-      unless record
-        record = @klass.new(protected_attributes_for_create, options) do |r|
-          r.assign_attributes(unprotected_attributes_for_create, :without_protection => true)
-        end
-        yield(record) if block_given?
-        record.send(match.save_method) if match.save_record?
-      end
-
-      record
-    end
-
     def find_with_ids(*ids)
       return to_a.find { |*block_args| yield(*block_args) } if block_given?
 
@@ -277,7 +268,7 @@ module ActiveRecord
       substitute = connection.substitute_at(column, bind_values.length)
       relation = where(table[primary_key].eq(substitute))
       relation.bind_values += [[column, id]]
-      record = relation.first
+      record = relation.take
 
       unless record
         conditions = arel.where_sql
@@ -315,11 +306,24 @@ module ActiveRecord
       end
     end
 
+    def find_take
+      if loaded?
+        @records.first
+      else
+        @take ||= limit(1).to_a.first
+      end
+    end
+
     def find_first
       if loaded?
         @records.first
       else
-        @first ||= limit(1).to_a[0]
+        @first ||=
+          if order_values.empty? && primary_key
+            order(arel_table[primary_key].asc).limit(1).to_a.first
+          else
+            limit(1).to_a.first
+          end
       end
     end
 
@@ -331,7 +335,7 @@ module ActiveRecord
           if offset_value || limit_value
             to_a.last
           else
-            reverse_order.limit(1).to_a[0]
+            reverse_order.limit(1).to_a.first
           end
       end
     end
diff --git a/activerecord/lib/active_record/relation/predicate_builder.rb b/activerecord/lib/active_record/relation/predicate_builder.rb
index b40bf2b3cf..6a0cdd5917 100644
--- a/activerecord/lib/active_record/relation/predicate_builder.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder.rb
@@ -34,9 +34,6 @@ module ActiveRecord
     private
       def self.build(attribute, value)
         case value
-        when ActiveRecord::Relation
-          value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
-          attribute.in(value.arel.ast)
         when Array, ActiveRecord::Associations::CollectionProxy
           values = value.to_a.map {|x| x.is_a?(ActiveRecord::Model) ? x.id : x}
           ranges, values = values.partition {|v| v.is_a?(Range)}
@@ -59,6 +56,9 @@ module ActiveRecord
           array_predicates = ranges.map { |range| attribute.in(range) }
           array_predicates << values_predicate
           array_predicates.inject { |composite, predicate| composite.or(predicate) }
+        when ActiveRecord::Relation
+          value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
+          attribute.in(value.arel.ast)
         when Range
           attribute.in(value)
         when ActiveRecord::Model
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index 855477eaed..29536b16c4 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -40,7 +40,7 @@ module ActiveRecord
     alias extensions extending_values
 
     def includes(*args)
-      args.empty? ? self : clone.includes!(*args)
+      args.empty? ? self : spawn.includes!(*args)
     end
 
     def includes!(*args)
@@ -51,7 +51,7 @@ module ActiveRecord
     end
 
     def eager_load(*args)
-      args.blank? ? self : clone.eager_load!(*args)
+      args.blank? ? self : spawn.eager_load!(*args)
     end
 
     def eager_load!(*args)
@@ -60,7 +60,7 @@ module ActiveRecord
     end
 
     def preload(*args)
-      args.blank? ? self : clone.preload!(*args)
+      args.blank? ? self : spawn.preload!(*args)
     end
 
     def preload!(*args)
@@ -79,7 +79,7 @@ module ActiveRecord
     #   User.includes(:posts).where("posts.name = 'foo'").references(:posts)
     #   # => Query now knows the string references posts, so adds a JOIN
     def references(*args)
-      args.blank? ? self : clone.references!(*args)
+      args.blank? ? self : spawn.references!(*args)
     end
 
     def references!(*args)
@@ -120,7 +120,7 @@ module ActiveRecord
       if block_given?
         to_a.select { |*block_args| value.call(*block_args) }
       else
-        clone.select!(value)
+        spawn.select!(value)
       end
     end
 
@@ -130,7 +130,7 @@ module ActiveRecord
     end
 
     def group(*args)
-      args.blank? ? self : clone.group!(*args)
+      args.blank? ? self : spawn.group!(*args)
     end
 
     def group!(*args)
@@ -139,7 +139,7 @@ module ActiveRecord
     end
 
     def order(*args)
-      args.blank? ? self : clone.order!(*args)
+      args.blank? ? self : spawn.order!(*args)
     end
 
     def order!(*args)
@@ -165,7 +165,7 @@ module ActiveRecord
     # generates a query with 'ORDER BY id ASC, name ASC'.
     #
     def reorder(*args)
-      args.blank? ? self : clone.reorder!(*args)
+      args.blank? ? self : spawn.reorder!(*args)
     end
 
     def reorder!(*args)
@@ -175,7 +175,7 @@ module ActiveRecord
     end
 
     def joins(*args)
-      args.compact.blank? ? self : clone.joins!(*args)
+      args.compact.blank? ? self : spawn.joins!(*args)
     end
 
     def joins!(*args)
@@ -186,7 +186,7 @@ module ActiveRecord
     end
 
     def bind(value)
-      clone.bind!(value)
+      spawn.bind!(value)
     end
 
     def bind!(value)
@@ -195,7 +195,7 @@ module ActiveRecord
     end
 
     def where(opts, *rest)
-      opts.blank? ? self : clone.where!(opts, *rest)
+      opts.blank? ? self : spawn.where!(opts, *rest)
     end
 
     def where!(opts, *rest)
@@ -206,7 +206,7 @@ module ActiveRecord
     end
 
     def having(opts, *rest)
-      opts.blank? ? self : clone.having!(opts, *rest)
+      opts.blank? ? self : spawn.having!(opts, *rest)
     end
 
     def having!(opts, *rest)
@@ -217,7 +217,7 @@ module ActiveRecord
     end
 
     def limit(value)
-      clone.limit!(value)
+      spawn.limit!(value)
     end
 
     def limit!(value)
@@ -226,7 +226,7 @@ module ActiveRecord
     end
 
     def offset(value)
-      clone.offset!(value)
+      spawn.offset!(value)
     end
 
     def offset!(value)
@@ -235,7 +235,7 @@ module ActiveRecord
     end
 
     def lock(locks = true)
-      clone.lock!(locks)
+      spawn.lock!(locks)
     end
 
     def lock!(locks = true)
@@ -283,7 +283,7 @@ module ActiveRecord
     end
 
     def readonly(value = true)
-      clone.readonly!(value)
+      spawn.readonly!(value)
     end
 
     def readonly!(value = true)
@@ -292,7 +292,7 @@ module ActiveRecord
     end
 
     def create_with(value)
-      clone.create_with!(value)
+      spawn.create_with!(value)
     end
 
     def create_with!(value)
@@ -301,7 +301,7 @@ module ActiveRecord
     end
 
     def from(value)
-      clone.from!(value)
+      spawn.from!(value)
     end
 
     def from!(value)
@@ -320,7 +320,7 @@ module ActiveRecord
     #   User.select(:name).uniq.uniq(false)
     #   # => You can also remove the uniqueness
     def uniq(value = true)
-      clone.uniq!(value)
+      spawn.uniq!(value)
     end
 
     def uniq!(value = true)
@@ -366,7 +366,7 @@ module ActiveRecord
     #   end
     def extending(*modules, &block)
       if modules.any? || block
-        clone.extending!(*modules, &block)
+        spawn.extending!(*modules, &block)
       else
         self
       end
@@ -382,7 +382,7 @@ module ActiveRecord
     end
 
     def reverse_order
-      clone.reverse_order!
+      spawn.reverse_order!
     end
 
     def reverse_order!
diff --git a/activerecord/lib/active_record/relation/spawn_methods.rb b/activerecord/lib/active_record/relation/spawn_methods.rb
index 41e55dfd0e..80d087a9ea 100644
--- a/activerecord/lib/active_record/relation/spawn_methods.rb
+++ b/activerecord/lib/active_record/relation/spawn_methods.rb
@@ -5,9 +5,14 @@ require 'active_record/relation/merger'
 
 module ActiveRecord
   module SpawnMethods
-    
+
+    # This is overridden by Associations::CollectionProxy
+    def spawn #:nodoc:
+      clone
+    end
+
     # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an <tt>ActiveRecord::Relation</tt>.
-    # Returns an array representing the union of the resulting records with <tt>other</tt>, if <tt>other</tt> is an array.
+    # Returns an array representing the intersection of the resulting records with <tt>other</tt>, if <tt>other</tt> is an array.
     #
     # ==== Examples
     #
@@ -16,14 +21,14 @@ module ActiveRecord
     #
     #   recent_posts = Post.order('created_at DESC').first(5)
     #   Post.where(:published => true).merge(recent_posts)
-    #   # Returns the union of all published posts with the 5 most recently created posts.
+    #   # Returns the intersection of all published posts with the 5 most recently created posts.
     #   # (This is just an example. You'd probably want to do this with a single query!)
     #
     def merge(other)
       if other.is_a?(Array)
         to_a & other
       elsif other
-        clone.merge!(other)
+        spawn.merge!(other)
       else
         self
       end
@@ -42,7 +47,7 @@ module ActiveRecord
     #   Post.where('id > 10').order('id asc').except(:where) # discards the where condition but keeps the order
     #
     def except(*skips)
-      result = self.class.new(@klass, table, values.except(*skips))
+      result = Relation.new(klass, table, values.except(*skips))
       result.default_scoped = default_scoped
       result.extend(*extending_values) if extending_values.any?
       result
@@ -56,7 +61,7 @@ module ActiveRecord
     #   Post.order('id asc').only(:where, :order) # uses the specified order
     #
     def only(*onlies)
-      result = self.class.new(@klass, table, values.slice(*onlies))
+      result = Relation.new(klass, table, values.slice(*onlies))
       result.default_scoped = default_scoped
       result.extend(*extending_values) if extending_values.any?
       result
diff --git a/activerecord/lib/active_record/result.rb b/activerecord/lib/active_record/result.rb
index fb4b89b87b..fd276ccf5d 100644
--- a/activerecord/lib/active_record/result.rb
+++ b/activerecord/lib/active_record/result.rb
@@ -28,6 +28,7 @@ module ActiveRecord
     alias :map! :map
     alias :collect! :map
 
+    # Returns true if there are no records.
     def empty?
       rows.empty?
     end
diff --git a/activerecord/lib/active_record/sanitization.rb b/activerecord/lib/active_record/sanitization.rb
index 81b13fe529..5530be3219 100644
--- a/activerecord/lib/active_record/sanitization.rb
+++ b/activerecord/lib/active_record/sanitization.rb
@@ -58,7 +58,7 @@ module ActiveRecord
         expanded_attrs = {}
         attrs.each do |attr, value|
           if aggregation = reflect_on_aggregation(attr.to_sym)
-            mapping = aggregate_mapping(aggregation)
+            mapping = aggregation.mapping
             mapping.each do |field_attr, aggregate_attr|
               if mapping.size == 1 && !value.respond_to?(aggregate_attr)
                 expanded_attrs[field_attr] = value
diff --git a/activerecord/lib/active_record/transactions.rb b/activerecord/lib/active_record/transactions.rb
index 743dfc5a38..64e5640791 100644
--- a/activerecord/lib/active_record/transactions.rb
+++ b/activerecord/lib/active_record/transactions.rb
@@ -302,12 +302,8 @@ module ActiveRecord
     def remember_transaction_record_state #:nodoc:
       @_start_transaction_state ||= {}
       @_start_transaction_state[:id] = id if has_attribute?(self.class.primary_key)
-      unless @_start_transaction_state.include?(:new_record)
-        @_start_transaction_state[:new_record] = @new_record
-      end
-      unless @_start_transaction_state.include?(:destroyed)
-        @_start_transaction_state[:destroyed] = @destroyed
-      end
+      @_start_transaction_state[:new_record] = @new_record
+      @_start_transaction_state[:destroyed] = @destroyed
       @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
     end