Merge branch 'master' into mrbrdo-fixserialization

* master: (142 commits)
  Use Colspan in th Tags
  Added test for link_to_unless to make sure the result consistency.
  Escape the string even when the condition of link_to_unless is not satisfied.
  Add CHANGELOG entry for #10969
  Use a case insensitive URI Regexp for #asset_path
  collection tags accept html attributes as the last element of collection
  Rewind StringIO instances before be parsed again
  Use xml instead already parsed xml
  Updated the doc for const_regexp [ci skip]
  Make test name descriptive and add reference to original regression commit
  fixture setup does not rely on `AR::Base.configurations`.
  regression test + mysql2 adapter raises correct error if conn is closed.
  cleanup, remove trailing whitespace from AR changelog
  'json' gem is no more required under JRuby
  fix typos
  Fix AS changelog [ci skip]
  Update the HTML boolean attributes per the HTML 5.1 spec
  Changing const_regexp to check for constant name.
  valid_app_const? -> valid_const?
  Add CHANGELOG entry for #10740
  ...

41 files changed, 522 insertions, 301 deletions

diff --git a/activerecord/CHANGELOG.md b/activerecord/CHANGELOG.md
index e5312d7d7c..21b0a52180 100644
--- a/activerecord/CHANGELOG.md
+++ b/activerecord/CHANGELOG.md
@@ -1,3 +1,81 @@
+*   Fixture setup does no longer depend on `ActiveRecord::Base.configurations`.
+    This is relevant when `ENV["DATABASE_URL"]` is used in place of a `database.yml`.
+
+    *Yves Senn*
+
+*   Fix mysql2 adapter raises the correct exception when executing a query on a
+    closed connection.
+
+    *Yves Senn*
+
+*   Ambiguous reflections are on :through relationships are no longer supported.
+    For example, you need to change this:
+
+      class Author < ActiveRecord::Base
+        has_many :posts
+        has_many :taggings, :through => :posts
+      end
+
+      class Post < ActiveRecord::Base
+        has_one :tagging
+        has_many :taggings
+      end
+
+      class Tagging < ActiveRecord::Base
+      end
+
+    To this:
+
+      class Author < ActiveRecord::Base
+        has_many :posts
+        has_many :taggings, :through => :posts, :source => :tagging
+      end
+
+      class Post < ActiveRecord::Base
+        has_one :tagging
+        has_many :taggings
+      end
+
+      class Tagging < ActiveRecord::Base
+      end
+
+*   Remove column restrictions for `count`, let the database raise if the SQL is
+    invalid. The previous behavior was untested and surprising for the user.
+    Fixes #5554.
+
+    Example:
+
+        User.select("name, username").count
+        # Before => SELECT count(*) FROM users
+        # After => ActiveRecord::StatementInvalid
+
+        # you can still use `count(:all)` to perform a query unrelated to the
+        # selected columns
+        User.select("name, username").count(:all) # => SELECT count(*) FROM users
+
+    *Yves Senn*
+
+*   Rails now automatically detects inverse associations. If you do not set the
+    `:inverse_of` option on the association, then Active Record will guess the
+    inverse association based on heuristics.
+
+    Note that automatic inverse detection only works on `has_many`, `has_one`,
+    and `belongs_to` associations. Extra options on the associations will
+    also prevent the association's inverse from being found automatically.
+
+    The automatic guessing of the inverse association uses a heuristic based
+    on the name of the class, so it may not work for all associations,
+    especially the ones with non-standard names.
+
+    You can turn off the automatic detection of inverse associations by setting
+    the `:inverse_of` option to `false` like so:
+
+      class Taggable < ActiveRecord::Base
+        belongs_to :tag, inverse_of: false
+      end
+
+    *John Wang*
+
 *   Fix `add_column` with `array` option when using PostgreSQL. Fixes #10432
 
     *Adam Anderson*
@@ -19,7 +97,7 @@
 
     *Yves Senn*
 
-*   Fix bug where tiny types are incorectly coerced as booleand when the length is more than 1.
+*   Fix bug where tiny types are incorrectly coerced as boolean when the length is more than 1.
 
     Fixes #10620.
 
@@ -102,8 +180,8 @@
 
     *Olek Janiszewski*
 
-*   fixes bug introduced by #3329.  Now, when autosaving associations,
-    deletions happen before inserts and saves.  This prevents a 'duplicate
+*   fixes bug introduced by #3329. Now, when autosaving associations,
+    deletions happen before inserts and saves. This prevents a 'duplicate
     unique value' database error that would occur if a record being created had
     the same value on a unique indexed field as that of a record being destroyed.
 
diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index 3490057298..6fd4f3042c 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -586,9 +586,10 @@ module ActiveRecord
     #     belongs_to :tag, inverse_of: :taggings
     #   end
     #
-    # If you do not set the +:inverse_of+ record, the association will do its
-    # best to match itself up with the correct inverse. Automatic +:inverse_of+
-    # detection only works on +has_many+, +has_one+, and +belongs_to+ associations.
+    # If you do not set the <tt>:inverse_of</tt> record, the association will
+    # do its best to match itself up with the correct inverse. Automatic
+    # inverse detection only works on <tt>has_many</tt>, <tt>has_one</tt>, and
+    # <tt>belongs_to</tt> associations.
     #
     # Extra options on the associations, as defined in the
     # <tt>AssociationReflection::INVALID_AUTOMATIC_INVERSE_OPTIONS</tt> constant, will
@@ -599,10 +600,10 @@ module ActiveRecord
     # especially the ones with non-standard names.
     #
     # You can turn off the automatic detection of inverse associations by setting
-    # the +:automatic_inverse_of+ option to +false+ like so:
+    # the <tt>:inverse_of</tt> option to <tt>false</tt> like so:
     #
     #   class Taggable < ActiveRecord::Base
-    #     belongs_to :tag, automatic_inverse_of: false
+    #     belongs_to :tag, inverse_of: false
     #   end
     #
     # == Nested \Associations
diff --git a/activerecord/lib/active_record/associations/association.rb b/activerecord/lib/active_record/associations/association.rb
index 608a6af16c..ee62298793 100644
--- a/activerecord/lib/active_record/associations/association.rb
+++ b/activerecord/lib/active_record/associations/association.rb
@@ -200,13 +200,14 @@ module ActiveRecord
           creation_attributes.each { |key, value| record[key] = value }
         end
 
-        # Should be true if there is a foreign key present on the owner which
+        # Returns true if there is a foreign key present on the owner which
         # references the target. This is used to determine whether we can load
         # the target if the owner is currently a new record (and therefore
-        # without a key).
+        # without a key). If the owner is a new record then foreign_key must
+        # be present in order to load target.
         #
         # Currently implemented by belongs_to (vanilla and polymorphic) and
-        # has_one/has_many :through associations which go through a belongs_to
+        # has_one/has_many :through associations which go through a belongs_to.
         def foreign_key_present?
           false
         end
diff --git a/activerecord/lib/active_record/associations/association_scope.rb b/activerecord/lib/active_record/associations/association_scope.rb
index aa5551fe0c..f1bec5787a 100644
--- a/activerecord/lib/active_record/associations/association_scope.rb
+++ b/activerecord/lib/active_record/associations/association_scope.rb
@@ -96,7 +96,7 @@ module ActiveRecord
             item  = eval_scope(klass, scope_chain_item)
 
             if scope_chain_item == self.reflection.scope
-              scope.merge! item.except(:where, :includes)
+              scope.merge! item.except(:where, :includes, :bind)
             end
 
             scope.includes! item.includes_values
diff --git a/activerecord/lib/active_record/associations/builder/association.rb b/activerecord/lib/active_record/associations/builder/association.rb
index 6a3658f328..3254da4677 100644
--- a/activerecord/lib/active_record/associations/builder/association.rb
+++ b/activerecord/lib/active_record/associations/builder/association.rb
@@ -111,13 +111,8 @@ module ActiveRecord::Associations::Builder
         )
       end
 
-      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{macro}_dependent_for_#{name}
-          association(:#{name}).handle_dependency
-        end
-      CODE
-
-      model.before_destroy "#{macro}_dependent_for_#{name}"
+      n = name
+      model.before_destroy lambda { |o| o.association(n).handle_dependency }
     end
 
     def valid_dependent_options
diff --git a/activerecord/lib/active_record/associations/builder/belongs_to.rb b/activerecord/lib/active_record/associations/builder/belongs_to.rb
index 63e9526436..d4e1a0dda1 100644
--- a/activerecord/lib/active_record/associations/builder/belongs_to.rb
+++ b/activerecord/lib/active_record/associations/builder/belongs_to.rb
@@ -19,82 +19,116 @@ module ActiveRecord::Associations::Builder
       reflection
     end
 
-    def add_counter_cache_callbacks(reflection)
-      cache_column = reflection.counter_cache_column
-      foreign_key = reflection.foreign_key
+    def valid_dependent_options
+      [:destroy, :delete]
+    end
+
+    private
 
-      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def belongs_to_counter_cache_after_create_for_#{name}
-          if record = #{name}
-            record.class.increment_counter(:#{cache_column}, record.id)
+    def add_counter_cache_methods(mixin)
+      return if mixin.method_defined? :belongs_to_counter_cache_after_create
+
+      mixin.class_eval do
+        def belongs_to_counter_cache_after_create(association, reflection)
+          if record = send(association.name)
+            cache_column = reflection.counter_cache_column
+            record.class.increment_counter(cache_column, record.id)
             @_after_create_counter_called = true
           end
         end
 
-        def belongs_to_counter_cache_before_destroy_for_#{name}
-          unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == #{foreign_key.to_sym.inspect}
-            record = #{name}
+        def belongs_to_counter_cache_before_destroy(association, reflection)
+          foreign_key = reflection.foreign_key.to_sym
+          unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == foreign_key
+            record = send association.name
             if record && !self.destroyed?
-              record.class.decrement_counter(:#{cache_column}, record.id)
+              cache_column = reflection.counter_cache_column
+              record.class.decrement_counter(cache_column, record.id)
             end
           end
         end
 
-        def belongs_to_counter_cache_after_update_for_#{name}
+        def belongs_to_counter_cache_after_update(association, reflection)
+          foreign_key  = reflection.foreign_key
+          cache_column = reflection.counter_cache_column
+
           if (@_after_create_counter_called ||= false)
             @_after_create_counter_called = false
-          elsif self.#{foreign_key}_changed? && !new_record? && defined?(#{name.to_s.camelize})
-            model = #{name.to_s.camelize}
-            foreign_key_was = self.#{foreign_key}_was
-            foreign_key = self.#{foreign_key}
+          elsif attribute_changed?(foreign_key) && !new_record? && association.constructable?
+            model           = reflection.klass
+            foreign_key_was = attribute_was foreign_key
+            foreign_key     = attribute foreign_key
 
             if foreign_key && model.respond_to?(:increment_counter)
-              model.increment_counter(:#{cache_column}, foreign_key)
+              model.increment_counter(cache_column, foreign_key)
             end
             if foreign_key_was && model.respond_to?(:decrement_counter)
-              model.decrement_counter(:#{cache_column}, foreign_key_was)
+              model.decrement_counter(cache_column, foreign_key_was)
             end
           end
         end
-      CODE
+      end
+    end
+
+    def add_counter_cache_callbacks(reflection)
+      cache_column = reflection.counter_cache_column
+      add_counter_cache_methods mixin
+      association = self
+
+      model.after_create lambda { |record|
+        record.belongs_to_counter_cache_after_create(association, reflection)
+      }
 
-      model.after_create   "belongs_to_counter_cache_after_create_for_#{name}"
-      model.before_destroy "belongs_to_counter_cache_before_destroy_for_#{name}"
-      model.after_update   "belongs_to_counter_cache_after_update_for_#{name}"
+      model.before_destroy lambda { |record|
+        record.belongs_to_counter_cache_before_destroy(association, reflection)
+      }
+
+      model.after_update lambda { |record|
+        record.belongs_to_counter_cache_after_update(association, reflection)
+      }
 
       klass = reflection.class_name.safe_constantize
       klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
     end
 
-    def add_touch_callbacks(reflection)
-      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def belongs_to_touch_after_save_or_destroy_for_#{name}
-          foreign_key_field = #{reflection.foreign_key.inspect}
-          old_foreign_id    = attribute_was(foreign_key_field)
+    def self.touch_record(o, foreign_key, name, touch) # :nodoc:
+      old_foreign_id = o.attribute_was(foreign_key)
 
-          if old_foreign_id
-            klass      = association(#{name.inspect}).klass
-            old_record = klass.find_by(klass.primary_key => old_foreign_id)
+      if old_foreign_id
+        klass      = o.association(name).klass
+        old_record = klass.find_by(klass.primary_key => old_foreign_id)
 
-            if old_record
-              old_record.touch #{options[:touch].inspect if options[:touch] != true}
-            end
-          end
-
-          record = #{name}
-          unless record.nil? || record.new_record?
-            record.touch #{options[:touch].inspect if options[:touch] != true}
+        if old_record
+          if touch != true
+            old_record.touch touch
+          else
+            old_record.touch
           end
         end
-      CODE
-
-      model.after_save    "belongs_to_touch_after_save_or_destroy_for_#{name}"
-      model.after_touch   "belongs_to_touch_after_save_or_destroy_for_#{name}"
-      model.after_destroy "belongs_to_touch_after_save_or_destroy_for_#{name}"
+      end
+
+      record = o.send name
+      unless record.nil? || record.new_record?
+        if touch != true
+          record.touch touch
+        else
+          record.touch
+        end
+      end
     end
 
-    def valid_dependent_options
-      [:destroy, :delete]
+    def add_touch_callbacks(reflection)
+      foreign_key = reflection.foreign_key
+      n           = name
+      touch       = options[:touch]
+
+      callback = lambda { |record|
+        BelongsTo.touch_record(record, foreign_key, n, touch)
+      }
+
+      model.after_save    callback
+      model.after_touch   callback
+      model.after_destroy callback
     end
   end
 end
diff --git a/activerecord/lib/active_record/associations/builder/has_many.rb b/activerecord/lib/active_record/associations/builder/has_many.rb
index 429def5455..0d1bdd21ee 100644
--- a/activerecord/lib/active_record/associations/builder/has_many.rb
+++ b/activerecord/lib/active_record/associations/builder/has_many.rb
@@ -5,7 +5,7 @@ module ActiveRecord::Associations::Builder
     end
 
     def valid_options
-      super + [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :automatic_inverse_of, :counter_cache]
+      super + [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :counter_cache]
     end
 
     def valid_dependent_options
diff --git a/activerecord/lib/active_record/associations/builder/singular_association.rb b/activerecord/lib/active_record/associations/builder/singular_association.rb
index 96ccbeb8a3..76e48e66e5 100644
--- a/activerecord/lib/active_record/associations/builder/singular_association.rb
+++ b/activerecord/lib/active_record/associations/builder/singular_association.rb
@@ -3,7 +3,7 @@
 module ActiveRecord::Associations::Builder
   class SingularAssociation < Association #:nodoc:
     def valid_options
-      super + [:remote, :dependent, :counter_cache, :primary_key, :inverse_of, :automatic_inverse_of]
+      super + [:remote, :dependent, :counter_cache, :primary_key, :inverse_of]
     end
 
     def constructable?
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 c982d65d65..0be4b5cb19 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
@@ -25,6 +25,9 @@ module ActiveRecord
       end
     end
 
+    class ChangeColumnDefinition < Struct.new(:column, :type, :options) #:nodoc:
+    end
+
     # Represents the schema of an SQL table in an abstract way. This class
     # provides methods for manipulating the schema representation.
     #
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 2a4eda3622..3ac55a0f11 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
@@ -694,17 +694,6 @@ module ActiveRecord
         end
       end
 
-      def add_column_options!(sql, options) #:nodoc:
-        sql << " DEFAULT #{quote(options[:default], options[:column])}" if options_include_default?(options)
-        # must explicitly check for :null to allow change_column to work on migrations
-        if options[:null] == false
-          sql << " NOT NULL"
-        end
-        if options[:auto_increment] == true
-          sql << " AUTO_INCREMENT"
-        end
-      end
-
       # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
       #
       #   distinct("posts.id", ["posts.created_at desc"])
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index 26586f0974..e232cad982 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -116,6 +116,12 @@ module ActiveRecord
           send m, o
         end
 
+        def visit_AddColumn(o)
+          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+          sql = "ADD #{quote_column_name(o.name)} #{sql_type}"
+          add_column_options!(sql, column_options(o))
+        end
+
         private
 
         def visit_AlterTable(o)
@@ -123,12 +129,6 @@ module ActiveRecord
           sql << o.adds.map { |col| visit_AddColumn col }.join(' ')
         end
 
-        def visit_AddColumn(o)
-          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
-          sql = "ADD #{quote_column_name(o.name)} #{sql_type}"
-          add_column_options!(sql, column_options(o))
-        end
-
         def visit_ColumnDefinition(o)
           sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
           column_sql = "#{quote_column_name(o.name)} #{sql_type}"
@@ -149,6 +149,8 @@ module ActiveRecord
           column_options[:null] = o.null unless o.null.nil?
           column_options[:default] = o.default unless o.default.nil?
           column_options[:column] = o
+          column_options[:first] = o.first
+          column_options[:after] = o.after
           column_options
         end
 
@@ -164,9 +166,20 @@ module ActiveRecord
           @conn.type_to_sql type.to_sym, limit, precision, scale
         end
 
-        def add_column_options!(column_sql, column_options)
-          @conn.add_column_options! column_sql, column_options
-          column_sql
+        def add_column_options!(sql, options)
+          sql << " DEFAULT #{@conn.quote(options[:default], options[:column])}" if options_include_default?(options)
+          # must explicitly check for :null to allow change_column to work on migrations
+          if options[:null] == false
+            sql << " NOT NULL"
+          end
+          if options[:auto_increment] == true
+            sql << " AUTO_INCREMENT"
+          end
+          sql
+        end
+
+        def options_include_default?(options)
+          options.include?(:default) && !(options[:null] == false && options[:default].nil?)
         end
       end
 
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
index d098ded77c..5b25b26164 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -4,17 +4,26 @@ module ActiveRecord
   module ConnectionAdapters
     class AbstractMysqlAdapter < AbstractAdapter
       class SchemaCreation < AbstractAdapter::SchemaCreation
-        private
 
         def visit_AddColumn(o)
-          add_column_position!(super, o)
+          add_column_position!(super, column_options(o))
+        end
+
+        private
+        def visit_ChangeColumnDefinition(o)
+          column = o.column
+          options = o.options
+          sql_type = type_to_sql(o.type, options[:limit], options[:precision], options[:scale])
+          change_column_sql = "CHANGE #{quote_column_name(column.name)} #{quote_column_name(options[:name])} #{sql_type}"
+          add_column_options!(change_column_sql, options)
+          add_column_position!(change_column_sql, options)
         end
 
-        def add_column_position!(sql, column)
-          if column.first
+        def add_column_position!(sql, options)
+          if options[:first]
             sql << " FIRST"
-          elsif column.after
-            sql << " AFTER #{quote_column_name(column.after)}"
+          elsif options[:after]
+            sql << " AFTER #{quote_column_name(options[:after])}"
           end
           sql
         end
@@ -661,10 +670,9 @@ module ActiveRecord
       end
 
       def add_column_sql(table_name, column_name, type, options = {})
-        add_column_sql = "ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(add_column_sql, options)
-        add_column_position!(add_column_sql, options)
-        add_column_sql
+        td = create_table_definition table_name, options[:temporary], options[:options]
+        cd = td.new_column_definition(column_name, type, options)
+        schema_creation.visit_AddColumn cd
       end
 
       def change_column_sql(table_name, column_name, type, options = {})
@@ -678,14 +686,12 @@ module ActiveRecord
           options[:null] = column.null
         end
 
-        change_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(change_column_sql, options)
-        add_column_position!(change_column_sql, options)
-        change_column_sql
+        options[:name] = column.name
+        schema_creation.accept ChangeColumnDefinition.new column, type, options
       end
 
       def rename_column_sql(table_name, column_name, new_column_name)
-        options = {}
+        options = { name: new_column_name }
 
         if column = columns(table_name).find { |c| c.name == column_name.to_s }
           options[:default] = column.default
@@ -696,9 +702,7 @@ module ActiveRecord
         end
 
         current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'", 'SCHEMA')["Type"]
-        rename_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
-        add_column_options!(rename_column_sql, options)
-        rename_column_sql
+        schema_creation.accept ChangeColumnDefinition.new column, current_type, options
       end
 
       def remove_column_sql(table_name, column_name, type = nil, options = {})
diff --git a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
index 530a27d099..edeb338310 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
@@ -213,9 +213,11 @@ module ActiveRecord
 
       # Executes the SQL statement in the context of this connection.
       def execute(sql, name = nil)
-        # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
-        # made since we established the connection
-        @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+        if @connection
+          # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+          # made since we established the connection
+          @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+        end
 
         super
       end
diff --git a/activerecord/lib/active_record/counter_cache.rb b/activerecord/lib/active_record/counter_cache.rb
index 81cca37939..e1faadf1ab 100644
--- a/activerecord/lib/active_record/counter_cache.rb
+++ b/activerecord/lib/active_record/counter_cache.rb
@@ -50,7 +50,7 @@ module ActiveRecord
       # ==== Parameters
       #
       # * +id+ - The id of the object you wish to update a counter on or an Array of ids.
-      # * +counters+ - An Array of Hashes containing the names of the fields
+      # * +counters+ - A Hash containing the names of the fields
       #   to update as keys and the amount to update the field by as values.
       #
       # ==== Examples
diff --git a/activerecord/lib/active_record/errors.rb b/activerecord/lib/active_record/errors.rb
index 017b8bace6..7e38719811 100644
--- a/activerecord/lib/active_record/errors.rb
+++ b/activerecord/lib/active_record/errors.rb
@@ -69,10 +69,6 @@ module ActiveRecord
     end
   end
 
-  # Raised when SQL statement is invalid and the application gets a blank result.
-  class ThrowResult < ActiveRecordError
-  end
-
   # Defunct wrapper class kept for compatibility.
   # +StatementInvalid+ wraps the original exception now.
   class WrappedDatabaseException < StatementInvalid
diff --git a/activerecord/lib/active_record/fixtures.rb b/activerecord/lib/active_record/fixtures.rb
index 33e19313a0..70eda332b3 100644
--- a/activerecord/lib/active_record/fixtures.rb
+++ b/activerecord/lib/active_record/fixtures.rb
@@ -841,8 +841,6 @@ module ActiveRecord
     end
 
     def setup_fixtures
-      return if ActiveRecord::Base.configurations.blank?
-
       if pre_loaded_fixtures && !use_transactional_fixtures
         raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures'
       end
@@ -875,8 +873,6 @@ module ActiveRecord
     end
 
     def teardown_fixtures
-      return if ActiveRecord::Base.configurations.blank?
-
       # Rollback changes if a transaction is active.
       if run_in_transaction?
         @fixture_connections.each do |connection|
diff --git a/activerecord/lib/active_record/inheritance.rb b/activerecord/lib/active_record/inheritance.rb
index 40976bc29e..e826762def 100644
--- a/activerecord/lib/active_record/inheritance.rb
+++ b/activerecord/lib/active_record/inheritance.rb
@@ -5,7 +5,7 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      # Determine whether to store the full constant name including namespace when using STI
+      # Determines whether to store the full constant name including namespace when using STI.
       class_attribute :store_full_sti_class, instance_writer: false
       self.store_full_sti_class = true
     end
@@ -13,7 +13,7 @@ module ActiveRecord
     module ClassMethods
       # Determines if one of the attributes passed in is the inheritance column,
       # and if the inheritance column is attr accessible, it initializes an
-      # instance of the given subclass instead of the base class
+      # instance of the given subclass instead of the base class.
       def new(*args, &block)
         if abstract_class? || self == Base
           raise NotImplementedError, "#{self} is an abstract class and can not be instantiated."
@@ -27,7 +27,8 @@ module ActiveRecord
         super
       end
 
-      # True if this isn't a concrete subclass needing a STI type condition.
+      # Returns +true+ if this does not need STI type condition. Returns
+      # +false+ if STI type condition needs to be applied.
       def descends_from_active_record?
         if self == Base
           false
diff --git a/activerecord/lib/active_record/nested_attributes.rb b/activerecord/lib/active_record/nested_attributes.rb
index 8bdaeef924..e53e8553ad 100644
--- a/activerecord/lib/active_record/nested_attributes.rb
+++ b/activerecord/lib/active_record/nested_attributes.rb
@@ -230,6 +230,10 @@ module ActiveRecord
     #     validates_presence_of :member
     #   end
     #
+    # Note that if you do not specify the <tt>inverse_of</tt> option, then
+    # Active Record will try to automatically guess the inverse association
+    # based on heuristics.
+    #
     # For one-to-one nested associations, if you build the new (in-memory)
     # child object yourself before assignment, then this module will not
     # overwrite it, e.g.:
@@ -302,14 +306,9 @@ module ActiveRecord
 
         attr_names.each do |association_name|
           if reflection = reflect_on_association(association_name)
-            reflection.options[:autosave] = true
+            reflection.autosave = true
             add_autosave_association_callbacks(reflection)
 
-            # Clear cached values of any inverse associations found in the
-            # reflection and prevent the reflection from finding inverses
-            # automatically in the future.
-            reflection.remove_automatic_inverse_of!
-
             nested_attributes_options = self.nested_attributes_options.dup
             nested_attributes_options[association_name.to_sym] = options
             self.nested_attributes_options = nested_attributes_options
diff --git a/activerecord/lib/active_record/null_relation.rb b/activerecord/lib/active_record/null_relation.rb
index 711fc8b883..d166f0dd66 100644
--- a/activerecord/lib/active_record/null_relation.rb
+++ b/activerecord/lib/active_record/null_relation.rb
@@ -39,7 +39,7 @@ module ActiveRecord
     end
 
     def to_sql
-      @to_sql ||= ""
+      ""
     end
 
     def where_values_hash
@@ -55,7 +55,11 @@ module ActiveRecord
     end
 
     def calculate(_operation, _column_name, _options = {})
-      nil
+      if _operation == :count
+        0
+      else
+        nil
+      end
     end
 
     def exists?(_id = false)
diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index f69e9b2217..0b74553bf8 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -324,7 +324,7 @@ db_namespace = namespace :db do
         ActiveRecord::Schema.verbose = false
         db_namespace["schema:load"].invoke
       ensure
-        ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[Rails.env])
+        ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[ActiveRecord::Tasks::DatabaseTasks.env])
       end
     end
 
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index 27aa20b6c0..8a9488656b 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -5,7 +5,9 @@ module ActiveRecord
 
     included do
       class_attribute :reflections
+      class_attribute :aggregate_reflections
       self.reflections = {}
+      self.aggregate_reflections = {}
     end
 
     # \Reflection enables to interrogate Active Record classes and objects
@@ -27,13 +29,18 @@ module ActiveRecord
 
         reflection = klass.new(macro, name, scope, options, active_record)
 
-        self.reflections = self.reflections.merge(name => reflection)
+        if klass == AggregateReflection
+          self.aggregate_reflections = self.aggregate_reflections.merge(name => reflection)
+        else
+          self.reflections = self.reflections.merge(name => reflection)
+        end
+
         reflection
       end
 
       # Returns an array of AggregateReflection objects for all the aggregations in the class.
       def reflect_on_all_aggregations
-        reflections.values.grep(AggregateReflection)
+        aggregate_reflections.values
       end
 
       # Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
@@ -41,8 +48,7 @@ module ActiveRecord
       #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
       #
       def reflect_on_aggregation(aggregation)
-        reflection = reflections[aggregation]
-        reflection if reflection.is_a?(AggregateReflection)
+        aggregate_reflections[aggregation]
       end
 
       # Returns an array of AssociationReflection objects for all the
@@ -56,7 +62,7 @@ module ActiveRecord
       #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
       #
       def reflect_on_all_associations(macro = nil)
-        association_reflections = reflections.values.grep(AssociationReflection)
+        association_reflections = reflections.values
         macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
       end
 
@@ -66,8 +72,7 @@ module ActiveRecord
       #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
       #
       def reflect_on_association(association)
-        reflection = reflections[association]
-        reflection if reflection.is_a?(AssociationReflection)
+        reflections[association]
       end
 
       # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
@@ -118,6 +123,11 @@ module ActiveRecord
                             name.to_s.pluralize : name.to_s
       end
 
+      def autosave=(autosave)
+        @automatic_inverse_of = false
+        @options[:autosave] = autosave
+      end
+
       # Returns the class for the macro.
       #
       # <tt>composed_of :balance, class_name: 'Money'</tt> returns the Money class
@@ -179,10 +189,14 @@ module ActiveRecord
         @klass ||= active_record.send(:compute_type, class_name)
       end
 
+      attr_reader :type, :foreign_type
+
       def initialize(*args)
         super
         @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
         @automatic_inverse_of = nil
+        @type         = options[:as] && "#{options[:as]}_type"
+        @foreign_type = options[:foreign_type] || "#{name}_type"
       end
 
       # Returns a new, unsaved instance of the associated class. +attributes+ will
@@ -192,11 +206,11 @@ module ActiveRecord
       end
 
       def table_name
-        @table_name ||= klass.table_name
+        klass.table_name
       end
 
       def quoted_table_name
-        @quoted_table_name ||= klass.quoted_table_name
+        klass.quoted_table_name
       end
 
       def join_table
@@ -207,16 +221,8 @@ module ActiveRecord
         @foreign_key ||= options[:foreign_key] || derive_foreign_key
       end
 
-      def foreign_type
-        @foreign_type ||= options[:foreign_type] || "#{name}_type"
-      end
-
-      def type
-        @type ||= options[:as] && "#{options[:as]}_type"
-      end
-
       def primary_key_column
-        @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
+        klass.columns_hash[klass.primary_key]
       end
 
       def association_foreign_key
@@ -240,14 +246,6 @@ module ActiveRecord
         end
       end
 
-      def columns(tbl_name)
-        @columns ||= klass.connection.columns(tbl_name)
-      end
-
-      def reset_column_information
-        @columns = nil
-      end
-
       def check_validity!
         check_validity_of_inverse!
 
@@ -291,30 +289,13 @@ module ActiveRecord
       alias :source_macro :macro
 
       def has_inverse?
-        @options[:inverse_of] || find_inverse_of_automatically
+        inverse_name
       end
 
       def inverse_of
-        @inverse_of ||= if options[:inverse_of]
-          klass.reflect_on_association(options[:inverse_of])
-        else
-          find_inverse_of_automatically
-        end
-      end
+        return unless inverse_name
 
-      # Clears the cached value of +@inverse_of+ on this object. This will
-      # not remove the :inverse_of option however, so future calls on the
-      # +inverse_of+ will have to recompute the inverse.
-      def clear_inverse_of_cache!
-        @inverse_of = nil
-      end
-
-      # Removes the cached inverse association that was found automatically
-      # and prevents this object from finding the inverse association
-      # automatically in the future.
-      def remove_automatic_inverse_of!
-        @automatic_inverse_of = nil
-        options[:automatic_inverse_of] = false
+        @inverse_of ||= klass.reflect_on_association inverse_name
       end
 
       def polymorphic_inverse_of(associated_class)
@@ -389,26 +370,21 @@ module ActiveRecord
       INVALID_AUTOMATIC_INVERSE_OPTIONS = [:conditions, :through, :polymorphic, :foreign_key]
 
       private
-        # Attempts to find the inverse association automatically.
-        # If it cannot find a suitable inverse association, it returns
+        # Attempts to find the inverse association name automatically.
+        # If it cannot find a suitable inverse association name, it returns
         # nil.
-        def find_inverse_of_automatically
-          if @automatic_inverse_of == false
-            nil
-          elsif @automatic_inverse_of.nil?
-            set_automatic_inverse_of
-          else
-            klass.reflect_on_association(@automatic_inverse_of)
+        def inverse_name
+          options.fetch(:inverse_of) do
+            if @automatic_inverse_of == false
+              nil
+            else
+              @automatic_inverse_of ||= automatic_inverse_of
+            end
           end
         end
 
-        # Sets the +@automatic_inverse_of+ instance variable, and returns
-        # either nil or the inverse association that it finds.
-        #
-        # This method caches the inverse association that is found so that
-        # future calls to +find_inverse_of_automatically+ have much less
-        # overhead.
-        def set_automatic_inverse_of
+        # returns either nil or the inverse association name that it finds.
+        def automatic_inverse_of
           if can_find_inverse_of_automatically?(self)
             inverse_name = active_record.name.downcase.to_sym
 
@@ -421,16 +397,11 @@ module ActiveRecord
             end
 
             if valid_inverse_reflection?(reflection)
-              @automatic_inverse_of = inverse_name
-              reflection
-            else
-              @automatic_inverse_of = false
-              nil
+              return inverse_name
             end
-          else
-            @automatic_inverse_of = false
-            nil
           end
+
+          false
         end
 
         # Checks if the inverse reflection that is returned from the
@@ -442,22 +413,23 @@ module ActiveRecord
         # from calling +klass+, +reflection+ will already be set to false.
         def valid_inverse_reflection?(reflection)
           reflection &&
-            klass.name == reflection.active_record.try(:name) &&
+            klass.name == reflection.active_record.name &&
             klass.primary_key == reflection.active_record_primary_key &&
             can_find_inverse_of_automatically?(reflection)
         end
 
         # Checks to see if the reflection doesn't have any options that prevent
         # us from being able to guess the inverse automatically. First, the
-        # +automatic_inverse_of+ option cannot be set to false. Second, we must
-        # have +has_many+, +has_one+, +belongs_to+ associations. Third, we must
-        # not have options such as +:polymorphic+ or +:foreign_key+ which prevent us
-        # from correctly guessing the inverse association.
+        # <tt>inverse_of</tt> option cannot be set to false. Second, we must
+        # have <tt>has_many</tt>, <tt>has_one</tt>, <tt>belongs_to</tt> associations.
+        # Third, we must not have options such as <tt>:polymorphic</tt> or
+        # <tt>:foreign_key</tt> which prevent us from correctly guessing the
+        # inverse association.
         #
         # Anything with a scope can additionally ruin our attempt at finding an
         # inverse, so we exclude reflections with scopes.
         def can_find_inverse_of_automatically?(reflection)
-          reflection.options[:automatic_inverse_of] != false &&
+          reflection.options[:inverse_of] != false &&
             VALID_AUTOMATIC_INVERSE_MACROS.include?(reflection.macro) &&
             !INVALID_AUTOMATIC_INVERSE_OPTIONS.any? { |opt| reflection.options[opt] } &&
             !reflection.scope
@@ -494,6 +466,11 @@ module ActiveRecord
       delegate :foreign_key, :foreign_type, :association_foreign_key,
                :active_record_primary_key, :type, :to => :source_reflection
 
+      def initialize(macro, name, scope, options, active_record)
+        super
+        @source_reflection_name = options[:source]
+      end
+
       # Returns the source of the through reflection. It checks both a singularized
       # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
       #
@@ -512,7 +489,7 @@ module ActiveRecord
       #   # => <ActiveRecord::Reflection::AssociationReflection: @macro=:belongs_to, @name=:tag, @active_record=Tagging, @plural_name="tags">
       #
       def source_reflection
-        @source_reflection ||= source_reflection_names.collect { |name| through_reflection.klass.reflect_on_association(name) }.compact.first
+        through_reflection.klass.reflect_on_association(source_reflection_name)
       end
 
       # Returns the AssociationReflection object specified in the <tt>:through</tt> option
@@ -528,7 +505,7 @@ module ActiveRecord
       #   # => <ActiveRecord::Reflection::AssociationReflection: @macro=:has_many, @name=:taggings, @active_record=Post, @plural_name="taggings">
       #
       def through_reflection
-        @through_reflection ||= active_record.reflect_on_association(options[:through])
+        active_record.reflect_on_association(options[:through])
       end
 
       # Returns an array of reflections which are involved in this association. Each item in the
@@ -630,7 +607,32 @@ module ActiveRecord
       #   # => [:tag, :tags]
       #
       def source_reflection_names
-        @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }
+        (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }.uniq
+      end
+
+      def source_reflection_name # :nodoc:
+        return @source_reflection_name if @source_reflection_name
+
+        names = [name.to_s.singularize, name].collect { |n| n.to_sym }.uniq
+        names = names.find_all { |n|
+          through_reflection.klass.reflect_on_association(n)
+        }
+
+        if names.length > 1
+          example_options = options.dup
+          example_options[:source] = source_reflection_names.first
+          ActiveSupport::Deprecation.warn <<-eowarn
+Ambiguous source reflection for through association.  Please specify a :source
+directive on your declaration like:
+
+  class #{active_record.name} < ActiveRecord::Base
+    #{macro} :#{name}, #{example_options}
+  end
+
+          eowarn
+        end
+
+        @source_reflection_name = names.first
       end
 
       def source_options
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index d54479edbb..d37471e9ad 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -247,7 +247,7 @@ module ActiveRecord
     def empty?
       return @records.empty? if loaded?
 
-      c = count
+      c = count(:all)
       c.respond_to?(:zero?) ? c.zero? : c.empty?
     end
 
diff --git a/activerecord/lib/active_record/relation/batches.rb b/activerecord/lib/active_record/relation/batches.rb
index b921f2eddb..41291844fc 100644
--- a/activerecord/lib/active_record/relation/batches.rb
+++ b/activerecord/lib/active_record/relation/batches.rb
@@ -11,7 +11,7 @@ module ActiveRecord
     # The #find_each method uses #find_in_batches with a batch size of 1000 (or as
     # specified by the +:batch_size+ option).
     #
-    #   Person.all.find_each do |person|
+    #   Person.find_each do |person|
     #     person.do_awesome_stuff
     #   end
     #
@@ -19,8 +19,26 @@ module ActiveRecord
     #     person.party_all_night!
     #   end
     #
-    #  You can also pass the +:start+ option to specify
-    #  an offset to control the starting point.
+    # ==== Options
+    # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
+    # * <tt>:start</tt> - Specifies the starting point for the batch processing.
+    # This is especially useful if you want multiple workers dealing with
+    # the same processing queue. You can make worker 1 handle all the records
+    # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
+    # (by setting the +:start+ option on that worker).
+    #
+    #   # Let's process for a batch of 2000 records, skiping the first 2000 rows
+    #   Person.find_each(start: 2000, batch_size: 2000) do |person|
+    #     person.party_all_night!
+    #   end
+    #
+    # NOTE: It's not possible to set the order. That is automatically set to
+    # ascending on the primary key ("id ASC") to make the batch ordering
+    # work. This also means that this method only works with integer-based
+    # primary keys.
+    #
+    # NOTE: You can't set the limit either, that's used to control
+    # the batch sizes.
     def find_each(options = {})
       find_in_batches(options) do |records|
         records.each { |record| yield record }
@@ -28,31 +46,33 @@ module ActiveRecord
     end
 
     # Yields each batch of records that was found by the find +options+ as
-    # an array. The size of each batch is set by the +:batch_size+
-    # option; the default is 1000.
-    #
-    # You can control the starting point for the batch processing by
-    # supplying the +:start+ option. This is especially useful if you
-    # want multiple workers dealing with the same processing queue. You can
-    # make worker 1 handle all the records between id 0 and 10,000 and
-    # worker 2 handle from 10,000 and beyond (by setting the +:start+
-    # option on that worker).
-    #
-    # It's not possible to set the order. That is automatically set to
-    # ascending on the primary key ("id ASC") to make the batch ordering
-    # work. This also means that this method only works with integer-based
-    # primary keys. You can't set the limit either, that's used to control
-    # the batch sizes.
+    # an array.
     #
     #   Person.where("age > 21").find_in_batches do |group|
     #     sleep(50) # Make sure it doesn't get too crowded in there!
     #     group.each { |person| person.party_all_night! }
     #   end
     #
+    # ==== Options
+    # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
+    # * <tt>:start</tt> - Specifies the starting point for the batch processing.
+    # This is especially useful if you want multiple workers dealing with
+    # the same processing queue. You can make worker 1 handle all the records
+    # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
+    # (by setting the +:start+ option on that worker).
+    #
     #   # Let's process the next 2000 records
-    #   Person.all.find_in_batches(start: 2000, batch_size: 2000) do |group|
+    #   Person.find_in_batches(start: 2000, batch_size: 2000) do |group|
     #     group.each { |person| person.party_all_night! }
     #   end
+    #
+    # NOTE: It's not possible to set the order. That is automatically set to
+    # ascending on the primary key ("id ASC") to make the batch ordering
+    # work. This also means that this method only works with integer-based
+    # primary keys.
+    #
+    # NOTE: You can't set the limit either, that's used to control
+    # the batch sizes.
     def find_in_batches(options = {})
       options.assert_valid_keys(:start, :batch_size)
 
diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index e234e02032..4becf3980d 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -106,8 +106,6 @@ module ActiveRecord
       else
         relation.calculate(operation, column_name, options)
       end
-    rescue ThrowResult
-      0
     end
 
     # Use <tt>pluck</tt> as a shortcut to select one or more attributes without
@@ -209,15 +207,18 @@ module ActiveRecord
       end
 
       if operation == "count"
-        column_name ||= (select_for_count || :all)
+        if select_values.present?
+          column_name ||= select_values.join(", ")
+        else
+          column_name ||= :all
+        end
 
         unless arel.ast.grep(Arel::Nodes::OuterJoin).empty?
           distinct = true
         end
 
         column_name = primary_key if column_name == :all && distinct
-
-        distinct = nil if column_name =~ /\s*DISTINCT\s+/i
+        distinct = nil if column_name =~ /\s*DISTINCT[\s(]+/i
       end
 
       if group_values.any?
@@ -378,13 +379,6 @@ module ActiveRecord
       column ? column.type_cast(value) : value
     end
 
-    def select_for_count
-      if select_values.present?
-        select = select_values.join(", ")
-        select if select !~ /[,*]/
-      end
-    end
-
     def build_count_subquery(relation, column_name, distinct)
       column_alias = Arel.sql('count_column')
       subquery_alias = Arel.sql('subquery_for_count')
diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index ba222aac93..3ea3c33fcc 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -11,9 +11,11 @@ module ActiveRecord
     #   Person.find([1])     # returns an array for the object with ID = 1
     #   Person.where("administrator = 1").order("created_on DESC").find(1)
     #
-    # Note that returned records may not be in the same order as the ids you
-    # provide since database rows are unordered. Give an explicit <tt>order</tt>
-    # to ensure the results are sorted.
+    # <tt>ActiveRecord::RecordNotFound</tt> will be raised if one or more ids are not found.
+    #
+    # NOTE: The returned records may not be in the same order as the ids you
+    # provide since database rows are unordered. You'd need to provide an explicit <tt>order</tt>
+    # option if you want the results are sorted.
     #
     # ==== Find with lock
     #
@@ -28,6 +30,34 @@ module ActiveRecord
     #     person.visits += 1
     #     person.save!
     #   end
+    #
+    # ==== Variations of +find+
+    # 
+    #   Person.where(name: 'Spartacus', rating: 4)
+    #   # returns a chainable list (which can be empty).
+    #
+    #   Person.find_by(name: 'Spartacus', rating: 4)
+    #   # returns the first item or nil.
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).first_or_initialize
+    #   # returns the first item or returns a new instance (requires you call .save to persist against the database).
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).first_or_create
+    #   # returns the first item or creates it and returns it, available since Rails 3.2.1.
+    #
+    # ==== Alternatives for +find+
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).exists?(conditions = :none)
+    #   # returns a boolean indicating if any record with the given conditions exist.
+    #   
+    #   Person.where(name: 'Spartacus', rating: 4).select("field1, field2, field3")
+    #   # returns a chainable list of instances with only the mentioned fields.
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).ids
+    #   # returns an Array of ids, available since Rails 3.2.1.
+    #
+    #   Person.where(name: 'Spartacus', rating: 4).pluck(:field1, :field2)
+    #   # returns an Array of the required fields, available since Rails 3.1.
     def find(*args)
       if block_given?
         to_a.find { |*block_args| yield(*block_args) }
@@ -79,13 +109,22 @@ module ActiveRecord
     #   Person.where(["user_name = :u", { u: user_name }]).first
     #   Person.order("created_on DESC").offset(5).first
     #   Person.first(3) # returns the first three objects fetched by SELECT * FROM people LIMIT 3
+    #
+    # ==== Rails 3
+    #
+    #   Person.first # SELECT "people".* FROM "people" LIMIT 1
+    #
+    # NOTE: Rails 3 may not order this query by the primary key and the order
+    # will depend on the database implementation. In order to ensure that behavior,
+    # use <tt>User.order(:id).first</tt> instead.
+    #
+    # ==== Rails 4
+    #
+    #   Person.first # SELECT "people".* FROM "people" ORDER BY "people"."id" ASC LIMIT 1
+    #
     def first(limit = nil)
       if limit
-        if order_values.empty? && primary_key
-          order(arel_table[primary_key].asc).limit(limit).to_a
-        else
-          limit(limit).to_a
-        end
+        find_first_with_limit(order_values, limit)
       else
         find_first
       end
@@ -160,8 +199,9 @@ module ActiveRecord
       conditions = conditions.id if Base === conditions
       return false if !conditions
 
-      join_dependency = construct_join_dependency
-      relation = construct_relation_for_association_find(join_dependency)
+      relation = construct_relation_for_association_find(construct_join_dependency)
+      return false if ActiveRecord::NullRelation === relation
+
       relation = relation.except(:select, :order).select("1 AS one").limit(1)
 
       case conditions
@@ -171,9 +211,8 @@ module ActiveRecord
         relation = relation.where(table[primary_key].eq(conditions)) if conditions != :none
       end
 
-      connection.select_value(relation, "#{name} Exists", relation.bind_values)
-    rescue ThrowResult
-      false
+      relation = relation.with_default_scope
+      connection.select_value(relation.arel, "#{name} Exists", relation.bind_values)
     end
 
     # This method is called whenever no records are found with either a single
@@ -203,10 +242,12 @@ module ActiveRecord
     def find_with_associations
       join_dependency = construct_join_dependency
       relation = construct_relation_for_association_find(join_dependency)
-      rows = connection.select_all(relation, 'SQL', relation.bind_values.dup)
-      join_dependency.instantiate(rows)
-    rescue ThrowResult
-      []
+      if ActiveRecord::NullRelation === relation
+        []
+      else
+        rows = connection.select_all(relation, 'SQL', relation.bind_values.dup)
+        join_dependency.instantiate(rows)
+      end
     end
 
     def construct_join_dependency(joins = [])
@@ -230,21 +271,22 @@ module ActiveRecord
       if using_limitable_reflections?(join_dependency.reflections)
         relation
       else
-        relation.where!(construct_limited_ids_condition(relation)) if relation.limit_value
+        if relation.limit_value
+          limited_ids = limited_ids_for(relation)
+          limited_ids.empty? ? relation.none! : relation.where!(table[primary_key].in(limited_ids))
+        end
         relation.except(:limit, :offset)
       end
     end
 
-    def construct_limited_ids_condition(relation)
+    def limited_ids_for(relation)
       values = @klass.connection.columns_for_distinct(
         "#{quoted_table_name}.#{quoted_primary_key}", relation.order_values)
 
       relation = relation.except(:select).select(values).distinct!
 
       id_rows = @klass.connection.select_all(relation.arel, 'SQL', relation.bind_values)
-      ids_array = id_rows.map {|row| row[primary_key]}
-
-      ids_array.empty? ? raise(ThrowResult) : table[primary_key].in(ids_array)
+      id_rows.map {|row| row[primary_key]}
     end
 
     def find_with_ids(*ids)
@@ -312,12 +354,15 @@ module ActiveRecord
       if loaded?
         @records.first
       else
-        @first ||=
-          if with_default_scope.order_values.empty? && primary_key
-            order(arel_table[primary_key].asc).limit(1).to_a.first
-          else
-            limit(1).to_a.first
-          end
+        @first ||= find_first_with_limit(with_default_scope.order_values, 1).first
+      end
+    end
+
+    def find_first_with_limit(order_values, limit)
+      if order_values.empty? && primary_key
+        order(arel_table[primary_key].asc).limit(limit).to_a
+      else
+        limit(limit).to_a
       end
     end
 
diff --git a/activerecord/lib/active_record/timestamp.rb b/activerecord/lib/active_record/timestamp.rb
index ae99cff35e..9253150c4f 100644
--- a/activerecord/lib/active_record/timestamp.rb
+++ b/activerecord/lib/active_record/timestamp.rb
@@ -10,9 +10,9 @@ module ActiveRecord
   #
   #   config.active_record.record_timestamps = false
   #
-  # Timestamps are in the local timezone by default but you can use UTC by setting:
+  # Timestamps are in UTC by default but you can use the local timezone by setting:
   #
-  #   config.active_record.default_timezone = :utc
+  #   config.active_record.default_timezone = :local
   #
   # == Time Zone aware attributes
   #
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 4aa6567d85..1cfaf552af 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -250,7 +250,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_nil Post.all.merge!(:includes => :author).find(posts(:authorless).id).author
   end
 
-  def test_nested_loading_with_no_associations
+  # Regression test for 21c75e5
+  def test_nested_loading_does_not_raise_exception_when_association_does_not_exist
     assert_nothing_raised do
       Post.all.merge!(:includes => {:author => :author_addresss}).find(posts(:authorless).id)
     end
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 095b78c6c8..0f3f9aecfc 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -6,6 +6,7 @@ require 'models/edge'
 require 'models/organization'
 require 'models/possession'
 require 'models/topic'
+require 'models/reply'
 require 'models/minivan'
 require 'models/speedometer'
 require 'models/ship_part'
@@ -166,6 +167,15 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_no_match(/OFFSET/, queries.first)
   end
 
+  def test_count_on_invalid_columns_raises
+    e = assert_raises(ActiveRecord::StatementInvalid) {
+      Account.select("credit_limit, firm_name").count
+    }
+
+    assert_match "accounts", e.message
+    assert_match "credit_limit, firm_name", e.message
+  end
+
   def test_should_group_by_summed_field_having_condition
     c = Account.group(:firm_id).having('sum(credit_limit) > 50').sum(:credit_limit)
     assert_nil        c[1]
@@ -472,6 +482,11 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal [1,2,3,4], Topic.order(:id).pluck(:id)
   end
 
+  def test_pluck_without_column_names
+    assert_equal [[1, "Firm", 1, nil, "37signals", nil, 1, nil, ""]],
+      Company.order(:id).limit(1).pluck
+  end
+
   def test_pluck_type_cast
     topic = topics(:first)
     relation = Topic.where(:id => topic.id)
@@ -533,6 +548,11 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal Company.all.map(&:id).sort, Company.ids.sort
   end
 
+  def test_pluck_with_includes_limit_and_empty_result
+    assert_equal [], Topic.includes(:replies).limit(0).pluck(:id)
+    assert_equal [], Topic.includes(:replies).limit(1).where('0 = 1').pluck(:id)
+  end
+
   def test_pluck_not_auto_table_name_prefix_if_column_included
     Company.create!(:name => "test", :contracts => [Contract.new(:developer_id => 7)])
     ids = Company.includes(:contracts).pluck(:developer_id)
diff --git a/activerecord/test/cases/connection_pool_test.rb b/activerecord/test/cases/connection_pool_test.rb
index e6af29282c..d5365b695e 100644
--- a/activerecord/test/cases/connection_pool_test.rb
+++ b/activerecord/test/cases/connection_pool_test.rb
@@ -329,7 +329,7 @@ module ActiveRecord
       end
 
       # make sure exceptions are thrown when establish_connection
-      # is called with a anonymous class
+      # is called with an anonymous class
       def test_anonymous_class_exception
         anonymous = Class.new(ActiveRecord::Base)
         handler = ActiveRecord::Base.connection_handler
diff --git a/activerecord/test/cases/disconnected_test.rb b/activerecord/test/cases/disconnected_test.rb
new file mode 100644
index 0000000000..cc2c1f6489
--- /dev/null
+++ b/activerecord/test/cases/disconnected_test.rb
@@ -0,0 +1,26 @@
+require "cases/helper"
+
+class TestRecord < ActiveRecord::Base
+end
+
+class TestDisconnectedAdapter < ActiveRecord::TestCase
+  self.use_transactional_fixtures = false
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    spec = ActiveRecord::Base.connection_config
+    ActiveRecord::Base.establish_connection(spec)
+    @connection = nil
+  end
+
+  test "can't execute statements while disconnected" do
+    @connection.execute "SELECT count(*) from products"
+    @connection.disconnect!
+    assert_raises(ActiveRecord::StatementInvalid) do
+      @connection.execute "SELECT count(*) from products"
+    end
+  end
+end
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index f6cfee0cb8..df6edc4057 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -245,6 +245,22 @@ class FixturesTest < ActiveRecord::TestCase
   def test_serialized_fixtures
     assert_equal ["Green", "Red", "Orange"], traffic_lights(:uk).state
   end
+
+  def test_fixtures_are_set_up_with_database_env_variable
+    ENV.stubs(:[]).with("DATABASE_URL").returns("sqlite3:///:memory:")
+    ActiveRecord::Base.stubs(:configurations).returns({})
+    test_case = Class.new(ActiveRecord::TestCase) do
+      fixtures :accounts
+
+      def test_fixtures
+        assert accounts(:signals37)
+      end
+    end
+
+    result = test_case.new(:test_fixtures).run
+
+    assert result.passed?, "Expected #{result.name} to pass:\n#{result}"
+  end
 end
 
 if Account.connection.respond_to?(:reset_pk_sequence!)
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index 77891b9156..0030f1b464 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -242,7 +242,7 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     car = Car.create!
 
     assert_difference 'car.wheels.count'  do
-    	car.wheels << Wheel.create!
+      car.wheels << Wheel.create!
     end
     assert_difference 'car.wheels.count', -1  do
       car.destroy
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index 6fe81e0d96..2f89699df7 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -797,26 +797,6 @@ module NestedAttributesOnACollectionAssociationTests
     end
   end
 
-  def test_validate_presence_of_parent_fails_without_inverse_of
-    Man.accepts_nested_attributes_for(:interests)
-    Man.reflect_on_association(:interests).options.delete(:inverse_of)
-    Man.reflect_on_association(:interests).clear_inverse_of_cache!
-    Interest.reflect_on_association(:man).options.delete(:inverse_of)
-    Interest.reflect_on_association(:man).clear_inverse_of_cache!
-
-    repair_validations(Interest) do
-      Interest.validates_presence_of(:man)
-      assert_no_difference ['Man.count', 'Interest.count'] do
-        man = Man.create(:name => 'John',
-                         :interests_attributes => [{:topic=>'Cars'}, {:topic=>'Sports'}])
-        assert !man.errors[:"interests.man"].empty?
-      end
-    end
-  ensure
-    Man.reflect_on_association(:interests).options[:inverse_of] = :man
-    Interest.reflect_on_association(:man).options[:inverse_of]  = :interests
-  end
-
   def test_can_use_symbols_as_object_identifier
     @pirate.attributes = { :parrots_attributes => { :foo => { :name => 'Lovely Day' }, :bar => { :name => 'Blown Away' } } }
     assert_nothing_raised(NoMethodError) { @pirate.save! }
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index b64ff13d29..e746ca2805 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -278,8 +278,9 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_null_relation_calculations_methods
     assert_no_queries do
-      assert_equal 0,     Developer.none.count
-      assert_equal nil,   Developer.none.calculate(:average, 'salary')
+      assert_equal 0, Developer.none.count
+      assert_equal 0, Developer.none.calculate(:count, nil, {})
+      assert_equal nil, Developer.none.calculate(:average, 'salary')
     end
   end
 
diff --git a/activerecord/test/models/author.rb b/activerecord/test/models/author.rb
index a96899ae10..af80b1ba42 100644
--- a/activerecord/test/models/author.rb
+++ b/activerecord/test/models/author.rb
@@ -85,7 +85,7 @@ class Author < ActiveRecord::Base
   has_many :author_favorites
   has_many :favorite_authors, -> { order('name') }, :through => :author_favorites
 
-  has_many :taggings,        :through => :posts
+  has_many :taggings,        :through => :posts, :source => :taggings
   has_many :taggings_2,      :through => :posts, :source => :tagging
   has_many :tags,            :through => :posts
   has_many :post_categories, :through => :posts, :source => :categories
diff --git a/activerecord/test/models/club.rb b/activerecord/test/models/club.rb
index 7d7c205041..816c5e6937 100644
--- a/activerecord/test/models/club.rb
+++ b/activerecord/test/models/club.rb
@@ -1,6 +1,6 @@
 class Club < ActiveRecord::Base
   has_one :membership
-  has_many :memberships, :automatic_inverse_of => false
+  has_many :memberships, :inverse_of => false
   has_many :members, :through => :memberships
   has_many :current_memberships
   has_one :sponsor
diff --git a/activerecord/test/models/company.rb b/activerecord/test/models/company.rb
index dcda62e71d..b988184f34 100644
--- a/activerecord/test/models/company.rb
+++ b/activerecord/test/models/company.rb
@@ -141,7 +141,7 @@ class Client < Company
   belongs_to :firm_with_primary_key_symbols, :class_name => "Firm", :primary_key => :name, :foreign_key => :firm_name
   belongs_to :readonly_firm, -> { readonly }, :class_name => "Firm", :foreign_key => "firm_id"
   belongs_to :bob_firm, -> { where :name => "Bob" }, :class_name => "Firm", :foreign_key => "client_of"
-  has_many :accounts, :through => :firm
+  has_many :accounts, :through => :firm, :source => :accounts
   belongs_to :account
 
   class RaisedOnSave < RuntimeError; end
diff --git a/activerecord/test/models/interest.rb b/activerecord/test/models/interest.rb
index f772bb1c7f..d5d9226204 100644
--- a/activerecord/test/models/interest.rb
+++ b/activerecord/test/models/interest.rb
@@ -1,5 +1,5 @@
 class Interest < ActiveRecord::Base
-  belongs_to :man, :inverse_of => :interests, :automatic_inverse_of => false
+  belongs_to :man, :inverse_of => :interests
   belongs_to :polymorphic_man, :polymorphic => true, :inverse_of => :polymorphic_interests
   belongs_to :zine, :inverse_of => :interests
 end
diff --git a/activerecord/test/models/man.rb b/activerecord/test/models/man.rb
index 49f002aa9a..4bff92dc98 100644
--- a/activerecord/test/models/man.rb
+++ b/activerecord/test/models/man.rb
@@ -1,7 +1,7 @@
 class Man < ActiveRecord::Base
   has_one :face, :inverse_of => :man
   has_one :polymorphic_face, :class_name => 'Face', :as => :polymorphic_man, :inverse_of => :polymorphic_man
-  has_many :interests, :inverse_of => :man, :automatic_inverse_of => false
+  has_many :interests, :inverse_of => :man
   has_many :polymorphic_interests, :class_name => 'Interest', :as => :polymorphic_man, :inverse_of => :polymorphic_man
   # These are "broken" inverse_of associations for the purposes of testing
   has_one :dirty_face, :class_name => 'Face', :inverse_of => :dirty_man
diff --git a/activerecord/test/models/member.rb b/activerecord/test/models/member.rb
index b81304b8e0..cc47c7bc18 100644
--- a/activerecord/test/models/member.rb
+++ b/activerecord/test/models/member.rb
@@ -9,7 +9,7 @@ class Member < ActiveRecord::Base
   has_one :hairy_club, -> { where :clubs => {:name => "Moustache and Eyebrow Fancier Club"} }, :through => :membership, :source => :club
   has_one :sponsor, :as => :sponsorable
   has_one :sponsor_club, :through => :sponsor
-  has_one :member_detail, :automatic_inverse_of => false
+  has_one :member_detail, :inverse_of => false
   has_one :organization, :through => :member_detail
   belongs_to :member_type
 
diff --git a/activerecord/test/models/member_detail.rb b/activerecord/test/models/member_detail.rb
index a256c73c7e..9d253aa126 100644
--- a/activerecord/test/models/member_detail.rb
+++ b/activerecord/test/models/member_detail.rb
@@ -1,5 +1,5 @@
 class MemberDetail < ActiveRecord::Base
-  belongs_to :member, :automatic_inverse_of => false
+  belongs_to :member, :inverse_of => false
   belongs_to :organization
   has_one :member_type, :through => :member