activerecord 4.2.11.3 → 5.0.0.beta1

data/lib/active_record/railtie.rb

@@ -16,11 +16,11 @@ module ActiveRecord
     config.app_generators.orm :active_record, :migration => true,
                                               :timestamps => true
 
-    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
-      "ActiveRecord::QueryCache"
+    config.app_middleware.insert_after ::ActionDispatch::Callbacks,
+      ActiveRecord::QueryCache
 
-    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
-      "ActiveRecord::ConnectionAdapters::ConnectionManagement"
+    config.app_middleware.insert_after ::ActionDispatch::Callbacks,
+      ActiveRecord::ConnectionAdapters::ConnectionManagement
 
     config.action_dispatch.rescue_responses.merge!(
       'ActiveRecord::RecordNotFound'   => :not_found,
@@ -57,10 +57,8 @@ module ActiveRecord
     console do |app|
       require "active_record/railties/console_sandbox" if app.sandbox?
       require "active_record/base"
-      unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
-        console = ActiveSupport::Logger.new(STDERR)
-        Rails.logger.extend ActiveSupport::Logger.broadcast console
-      end
+      console = ActiveSupport::Logger.new(STDERR)
+      Rails.logger.extend ActiveSupport::Logger.broadcast console
     end
 
     runner do
@@ -80,8 +78,8 @@ module ActiveRecord
 
     initializer "active_record.migration_error" do
       if config.active_record.delete(:migration_error) == :page_load
-        config.app_middleware.insert_after "::ActionDispatch::Callbacks",
-          "ActiveRecord::Migration::CheckPending"
+        config.app_middleware.insert_after ::ActionDispatch::Callbacks,
+          ActiveRecord::Migration::CheckPending
       end
     end
 
@@ -95,6 +93,7 @@ module ActiveRecord
               cache = Marshal.load File.binread filename
               if cache.version == ActiveRecord::Migrator.current_version
                 self.connection.schema_cache = cache
+                self.connection_pool.schema_cache = cache.dup
               else
                 warn "Ignoring db/schema_cache.dump because it has expired. The current schema version is #{ActiveRecord::Migrator.current_version}, but the one in the cache is #{cache.version}."
               end
@@ -104,6 +103,14 @@ module ActiveRecord
       end
     end
 
+    initializer "active_record.warn_on_records_fetched_greater_than" do
+      if config.active_record.warn_on_records_fetched_greater_than
+        ActiveSupport.on_load(:active_record) do
+          require 'active_record/relation/record_fetch_warning'
+        end
+      end
+    end
+
     initializer "active_record.set_configs" do |app|
       ActiveSupport.on_load(:active_record) do
         app.config.active_record.each do |k,v|
@@ -114,7 +121,7 @@ module ActiveRecord
 
     # This sets the database configuration from Configuration#database_configuration
     # and then establishes the connection.
-    initializer "active_record.initialize_database" do |app|
+    initializer "active_record.initialize_database" do
       ActiveSupport.on_load(:active_record) do
         self.configurations = Rails.application.config.database_configuration
 
@@ -127,8 +134,8 @@ Oops - You have a database configured, but it doesn't exist yet!
 Here's how to get started:
 
   1. Configure your database in config/database.yml.
-  2. Run `bin/rake db:create` to create the database.
-  3. Run `bin/rake db:setup` to load your database schema.
+  2. Run `bin/rails db:create` to create the database.
+  3. Run `bin/rails db:setup` to load your database schema.
 end_warning
           raise
         end

data/lib/active_record/railties/controller_runtime.rb

@@ -19,7 +19,7 @@ module ActiveRecord
       end
 
       def cleanup_view_runtime
-        if ActiveRecord::Base.connected?
+        if logger.info? && ActiveRecord::Base.connected?
           db_rt_before_render = ActiveRecord::LogSubscriber.reset_runtime
           self.db_runtime = (db_runtime || 0) + db_rt_before_render
           runtime = super

data/lib/active_record/railties/databases.rake

@@ -12,7 +12,7 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Creates the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:create:all to create all databases in the config). Without RAILS_ENV it defaults to creating the development and test databases.'
+  desc 'Creates the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:create:all to create all databases in the config). Without RAILS_ENV, it defaults to creating the development and test databases.'
   task :create => [:load_config] do
     ActiveRecord::Tasks::DatabaseTasks.create_current
   end
@@ -23,7 +23,7 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Drops the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in the config). Without RAILS_ENV it defaults to dropping the development and test databases.'
+  desc 'Drops the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in the config). Without RAILS_ENV, it defaults to dropping the development and test databases.'
   task :drop => [:load_config] do
     ActiveRecord::Tasks::DatabaseTasks.drop_current
   end
@@ -34,7 +34,7 @@ db_namespace = namespace :db do
     end
   end
 
-  # desc "Empty the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in the config). Without RAILS_ENV it defaults to purging the development and test databases."
+  # desc "Empty the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:purge:all to purge all databases in the config). Without RAILS_ENV it defaults to purging the development and test databases."
   task :purge => [:load_config] do
     ActiveRecord::Tasks::DatabaseTasks.purge_current
   end
@@ -63,8 +63,6 @@ db_namespace = namespace :db do
   namespace :migrate do
     # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
     task :redo => [:environment, :load_config] do
-      raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
-
       if ENV['VERSION']
         db_namespace['migrate:down'].invoke
         db_namespace['migrate:up'].invoke
@@ -79,18 +77,17 @@ db_namespace = namespace :db do
 
     # desc 'Runs the "up" for a given migration VERSION.'
     task :up => [:environment, :load_config] do
-      raise "VERSION is required" if ENV["VERSION"] && ENV["VERSION"].empty?
-
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      ActiveRecord::Migrator.run(:up, ActiveRecord::Migrator.migrations_paths, version)
+      raise 'VERSION is required' unless version
+      ActiveRecord::Migrator.run(:up, ActiveRecord::Tasks::DatabaseTasks.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
     task :down => [:environment, :load_config] do
-      raise "VERSION is required - To go down one migration, use db:rollback" if ENV["VERSION"] && ENV["VERSION"].empty?
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_paths, version)
+      raise 'VERSION is required - To go down one migration, run db:rollback' unless version
+      ActiveRecord::Migrator.run(:down, ActiveRecord::Tasks::DatabaseTasks.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
 
@@ -99,13 +96,28 @@ db_namespace = namespace :db do
       unless ActiveRecord::SchemaMigration.table_exists?
         abort 'Schema migrations table does not exist yet.'
       end
+      db_list = ActiveRecord::SchemaMigration.normalized_versions
+
+      file_list =
+          ActiveRecord::Tasks::DatabaseTasks.migrations_paths.flat_map do |path|
+            Dir.foreach(path).map do |file|
+              next unless ActiveRecord::Migrator.match_to_migration_filename?(file)
+
+              version, name, scope = ActiveRecord::Migrator.parse_migration_filename(file)
+              version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
+              status = db_list.delete(version) ? 'up' : 'down'
+              [status, version, (name + scope).humanize]
+            end.compact
+          end
 
+      db_list.map! do |version|
+        ['up', version, '********** NO FILE **********']
+      end
       # output
       puts "\ndatabase: #{ActiveRecord::Base.connection_config[:database]}\n\n"
       puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
       puts "-" * 50
-      paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
-      ActiveRecord::Migrator.migrations_status(paths).each do |status, version, name|
+      (db_list + file_list).sort_by { |_, version, _| version }.each do |status, version, name|
         puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
       end
       puts
@@ -115,22 +127,19 @@ db_namespace = namespace :db do
   desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n).'
   task :rollback => [:environment, :load_config] do
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-    ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_paths, step)
+    ActiveRecord::Migrator.rollback(ActiveRecord::Tasks::DatabaseTasks.migrations_paths, step)
     db_namespace['_dump'].invoke
   end
 
   # desc 'Pushes the schema to the next version (specify steps w/ STEP=n).'
   task :forward => [:environment, :load_config] do
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-    ActiveRecord::Migrator.forward(ActiveRecord::Migrator.migrations_paths, step)
+    ActiveRecord::Migrator.forward(ActiveRecord::Tasks::DatabaseTasks.migrations_paths, step)
     db_namespace['_dump'].invoke
   end
 
   # desc 'Drops and recreates the database from db/schema.rb for the current environment and loads the seeds.'
-  task :reset => [:environment, :load_config] do
-    db_namespace["drop"].invoke
-    db_namespace["setup"].invoke
-  end
+  task :reset => [ 'db:drop', 'db:setup' ]
 
   # desc "Retrieves the charset for the current environment's database"
   task :charset => [:environment, :load_config] do
@@ -152,29 +161,29 @@ db_namespace = namespace :db do
   end
 
   # desc "Raises an error if there are pending migrations"
-  task :abort_if_pending_migrations => :environment do
-    pending_migrations = ActiveRecord::Migrator.open(ActiveRecord::Migrator.migrations_paths).pending_migrations
+  task :abort_if_pending_migrations => [:environment, :load_config] do
+    pending_migrations = ActiveRecord::Migrator.open(ActiveRecord::Tasks::DatabaseTasks.migrations_paths).pending_migrations
 
     if pending_migrations.any?
       puts "You have #{pending_migrations.size} pending #{pending_migrations.size > 1 ? 'migrations:' : 'migration:'}"
       pending_migrations.each do |pending_migration|
         puts '  %4d %s' % [pending_migration.version, pending_migration.name]
       end
-      abort %{Run `rake db:migrate` to update your database then try again.}
+      abort %{Run `rails db:migrate` to update your database then try again.}
     end
   end
 
-  desc 'Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the database first)'
+  desc 'Creates the database, loads the schema, and initializes with the seed data (use db:reset to also drop the database first)'
   task :setup => ['db:schema:load_if_ruby', 'db:structure:load_if_sql', :seed]
 
-  desc 'Load the seed data from db/seeds.rb'
+  desc 'Loads the seed data from db/seeds.rb'
   task :seed do
     db_namespace['abort_if_pending_migrations'].invoke
     ActiveRecord::Tasks::DatabaseTasks.load_seed
   end
 
   namespace :fixtures do
-    desc "Load fixtures into the current environment's database. Load specific fixtures using FIXTURES=x,y. Load from subdirectory in test/fixtures using FIXTURES_DIR=z. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
+    desc "Loads fixtures into the current environment's database. Load specific fixtures using FIXTURES=x,y. Load from subdirectory in test/fixtures using FIXTURES_DIR=z. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
     task :load => [:environment, :load_config] do
       require 'active_record/fixtures'
 
@@ -222,7 +231,7 @@ db_namespace = namespace :db do
   end
 
   namespace :schema do
-    desc 'Create a db/schema.rb file that is portable against any DB supported by AR'
+    desc 'Creates a db/schema.rb file that is portable against any DB supported by Active Record'
     task :dump => [:environment, :load_config] do
       require 'active_record/schema_dumper'
       filename = ENV['SCHEMA'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'schema.rb')
@@ -232,7 +241,7 @@ db_namespace = namespace :db do
       db_namespace['schema:dump'].reenable
     end
 
-    desc 'Load a schema.rb file into the database'
+    desc 'Loads a schema.rb file into the database'
     task :load => [:environment, :load_config] do
       ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:ruby, ENV['SCHEMA'])
     end
@@ -242,17 +251,17 @@ db_namespace = namespace :db do
     end
 
     namespace :cache do
-      desc 'Create a db/schema_cache.dump file.'
+      desc 'Creates a db/schema_cache.dump file.'
       task :dump => [:environment, :load_config] do
         con = ActiveRecord::Base.connection
         filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.dump")
 
         con.schema_cache.clear!
-        con.tables.each { |table| con.schema_cache.add(table) }
+        con.data_sources.each { |table| con.schema_cache.add(table) }
         open(filename, 'wb') { |f| f.write(Marshal.dump(con.schema_cache)) }
       end
 
-      desc 'Clear a db/schema_cache.dump file.'
+      desc 'Clears a db/schema_cache.dump file.'
       task :clear => [:environment, :load_config] do
         filename = File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "schema_cache.dump")
         FileUtils.rm(filename) if File.exist?(filename)
@@ -262,9 +271,9 @@ db_namespace = namespace :db do
   end
 
   namespace :structure do
-    desc 'Dump the database structure to db/structure.sql. Specify another file with DB_STRUCTURE=db/my_structure.sql'
+    desc 'Dumps the database structure to db/structure.sql. Specify another file with SCHEMA=db/my_structure.sql'
     task :dump => [:environment, :load_config] do
-      filename = ENV['DB_STRUCTURE'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure.sql")
+      filename = ENV['SCHEMA'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure.sql")
       current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
       ActiveRecord::Tasks::DatabaseTasks.structure_dump(current_config, filename)
 
@@ -278,9 +287,9 @@ db_namespace = namespace :db do
       db_namespace['structure:dump'].reenable
     end
 
-    desc "Recreate the databases from the structure.sql file"
+    desc "Recreates the databases from the structure.sql file"
     task :load => [:load_config] do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql, ENV['DB_STRUCTURE'])
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql, ENV['SCHEMA'])
     end
 
     task :load_if_sql => ['db:create', :environment] do
@@ -312,7 +321,7 @@ db_namespace = namespace :db do
       begin
         should_reconnect = ActiveRecord::Base.connection_pool.active_connection?
         ActiveRecord::Schema.verbose = false
-        ActiveRecord::Tasks::DatabaseTasks.load_schema_for ActiveRecord::Base.configurations['test'], :ruby, ENV['SCHEMA']
+        ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations['test'], :ruby, ENV['SCHEMA']
       ensure
         if should_reconnect
           ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[ActiveRecord::Tasks::DatabaseTasks.env])
@@ -322,7 +331,7 @@ db_namespace = namespace :db do
 
     # desc "Recreate the test database from an existent structure.sql file"
     task :load_structure => %w(db:test:purge) do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema_for ActiveRecord::Base.configurations['test'], :sql, ENV['SCHEMA']
+      ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations['test'], :sql, ENV['SCHEMA']
     end
 
     # desc "Recreate the test database from a fresh schema"
@@ -346,7 +355,7 @@ db_namespace = namespace :db do
       ActiveRecord::Tasks::DatabaseTasks.purge ActiveRecord::Base.configurations['test']
     end
 
-    # desc 'Check for pending migrations and load the test schema'
+    # desc 'Load the test schema'
     task :prepare => %w(environment load_config) do
       unless ActiveRecord::Base.configurations.blank?
         db_namespace['test:load'].invoke
@@ -359,7 +368,7 @@ namespace :railties do
   namespace :install do
     # desc "Copies missing migrations from Railties (e.g. engines). You can specify Railties to use with FROM=railtie1,railtie2"
     task :migrations => :'db:load_config' do
-      to_load = ENV['FROM'].blank? ? :all : ENV['FROM'].split(",").map {|n| n.strip }
+      to_load = ENV['FROM'].blank? ? :all : ENV['FROM'].split(",").map(&:strip)
       railties = {}
       Rails.application.migration_railties.each do |railtie|
         next unless to_load == :all || to_load.include?(railtie.railtie_name)
@@ -377,7 +386,7 @@ namespace :railties do
         puts "Copied migration #{migration.basename} from #{name}"
       end
 
-      ActiveRecord::Migration.copy(ActiveRecord::Migrator.migrations_paths.first, railties,
+      ActiveRecord::Migration.copy(ActiveRecord::Tasks::DatabaseTasks.migrations_paths.first, railties,
                                     :on_skip => on_skip, :on_copy => on_copy)
     end
   end

data/lib/active_record/readonly_attributes.rb

@@ -11,7 +11,7 @@ module ActiveRecord
       # Attributes listed as readonly will be used to create a new record but update operations will
       # ignore these fields.
       def attr_readonly(*attributes)
-        self._attr_readonly = Set.new(attributes.map { |a| a.to_s }) + (self._attr_readonly || [])
+        self._attr_readonly = Set.new(attributes.map(&:to_s)) + (self._attr_readonly || [])
       end
 
       # Returns an array of all the attributes that have been specified as readonly.

data/lib/active_record/reflection.rb

@@ -7,8 +7,8 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_reflections, instance_writer: false
-      class_attribute :aggregate_reflections, instance_writer: false
+      class_attribute :_reflections
+      class_attribute :aggregate_reflections
       self._reflections = {}
       self.aggregate_reflections = {}
     end
@@ -40,9 +40,9 @@ module ActiveRecord
       ar.aggregate_reflections = ar.aggregate_reflections.merge(name.to_s => reflection)
     end
 
-    # \Reflection enables interrogating of Active Record classes and objects
-    # about their associations and aggregations. This information can,
-    # for example, be used in a form builder that takes an Active Record object
+    # \Reflection enables the ability to examine the associations and aggregations of
+    # Active Record classes and objects. This information, for example,
+    # can be used in a form builder that takes an Active Record object
     # and creates input fields for all of the attributes depending on their type
     # and displays the associations to other objects.
     #
@@ -62,20 +62,20 @@ module ActiveRecord
         aggregate_reflections[aggregation.to_s]
       end
 
-      # Returns a Hash of name of the reflection as the key and a AssociationReflection as the value.
+      # Returns a Hash of name of the reflection as the key and an AssociationReflection as the value.
       #
       #   Account.reflections # => {"balance" => AggregateReflection}
       #
-      # @api public
       def reflections
         @__reflections ||= begin
           ref = {}
 
           _reflections.each do |name, reflection|
-            parent_name, parent_reflection = reflection.parent_reflection
+            parent_reflection = reflection.parent_reflection
 
-            if parent_name
-              ref[parent_name] = parent_reflection
+            if parent_reflection
+              parent_name = parent_reflection.name
+              ref[parent_name.to_s] = parent_reflection
             else
               ref[name] = reflection
             end
@@ -95,10 +95,10 @@ module ActiveRecord
       #   Account.reflect_on_all_associations             # returns an array of all associations
       #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
       #
-      #   @api public
       def reflect_on_all_associations(macro = nil)
         association_reflections = reflections.values
-        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+        association_reflections.select! { |reflection| reflection.macro == macro } if macro
+        association_reflections
       end
 
       # Returns the AssociationReflection object for the +association+ (use the symbol).
@@ -106,24 +106,20 @@ module ActiveRecord
       #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
       #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
       #
-      #   @api public
       def reflect_on_association(association)
         reflections[association.to_s]
       end
 
-      #   @api private
       def _reflect_on_association(association) #:nodoc:
         _reflections[association.to_s]
       end
 
       # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
-      #
-      #   @api public
       def reflect_on_all_autosave_associations
         reflections.values.select { |reflection| reflection.options[:autosave] }
       end
 
-      def clear_reflections_cache #:nodoc:
+      def clear_reflections_cache # :nodoc:
         @__reflections = nil
       end
     end
@@ -159,17 +155,24 @@ module ActiveRecord
 
       JoinKeys = Struct.new(:key, :foreign_key) # :nodoc:
 
-      def join_keys(assoc_klass)
+      def join_keys(association_klass)
         JoinKeys.new(foreign_key, active_record_primary_key)
       end
 
-      def source_macro
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveRecord::Base.source_macro is deprecated and will be removed
-          without replacement.
-        MSG
+      def constraints
+        scope_chain.flatten
+      end
 
-        macro
+      def counter_cache_column
+        if belongs_to?
+          if options[:counter_cache] == true
+            "#{active_record.name.demodulize.underscore.pluralize}_count"
+          elsif options[:counter_cache]
+            options[:counter_cache].to_s
+          end
+        else
+          options[:counter_cache] ? options[:counter_cache].to_s : "#{name}_count"
+        end
       end
 
       def inverse_of
@@ -185,13 +188,54 @@ module ActiveRecord
           end
         end
       end
+
+      # This shit is nasty. We need to avoid the following situation:
+      #
+      #   * An associated record is deleted via record.destroy
+      #   * Hence the callbacks run, and they find a belongs_to on the record with a
+      #     :counter_cache options which points back at our owner. So they update the
+      #     counter cache.
+      #   * In which case, we must make sure to *not* update the counter cache, or else
+      #     it will be decremented twice.
+      #
+      # Hence this method.
+      def inverse_which_updates_counter_cache
+        return @inverse_which_updates_counter_cache if defined?(@inverse_which_updates_counter_cache)
+        @inverse_which_updates_counter_cache = klass.reflect_on_all_associations(:belongs_to).find do |inverse|
+          inverse.counter_cache_column == counter_cache_column
+        end
+      end
+      alias inverse_updates_counter_cache? inverse_which_updates_counter_cache
+
+      def inverse_updates_counter_in_memory?
+        inverse_of && inverse_which_updates_counter_cache == inverse_of
+      end
+
+      # Returns whether a counter cache should be used for this association.
+      #
+      # The counter_cache option must be given on either the owner or inverse
+      # association, and the column must be present on the owner.
+      def has_cached_counter?
+        options[:counter_cache] ||
+          inverse_which_updates_counter_cache && inverse_which_updates_counter_cache.options[:counter_cache] &&
+          !!active_record.columns_hash[counter_cache_column]
+      end
+
+      def counter_must_be_updated_by_has_many?
+        !inverse_updates_counter_in_memory? && has_cached_counter?
+      end
+
+      def alias_candidate(name)
+        "#{plural_name}_#{name}"
+      end
     end
+
     # Base class for AggregateReflection and AssociationReflection. Objects of
     # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
     #
     #   MacroReflection
+    #     AggregateReflection
     #     AssociationReflection
-    #       AggregateReflection
     #       HasManyReflection
     #       HasOneReflection
     #       BelongsToReflection
@@ -228,7 +272,7 @@ module ActiveRecord
       def autosave=(autosave)
         @automatic_inverse_of = false
         @options[:autosave] = autosave
-        _, parent_reflection = self.parent_reflection
+        parent_reflection = self.parent_reflection
         if parent_reflection
           parent_reflection.autosave = autosave
         end
@@ -296,7 +340,7 @@ module ActiveRecord
       end
 
       attr_reader :type, :foreign_type
-      attr_accessor :parent_reflection # [:name, Reflection]
+      attr_accessor :parent_reflection # Reflection
 
       def initialize(name, scope, options, active_record)
         super
@@ -343,14 +387,6 @@ module ActiveRecord
         @active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
       end
 
-      def counter_cache_column
-        if options[:counter_cache] == true
-          "#{active_record.name.demodulize.underscore.pluralize}_count"
-        elsif options[:counter_cache]
-          options[:counter_cache].to_s
-        end
-      end
-
       def check_validity!
         check_validity_of_inverse!
       end
@@ -359,13 +395,10 @@ module ActiveRecord
         return unless scope
 
         if scope.arity > 0
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          raise ArgumentError, <<-MSG.squish
             The association scope '#{name}' is instance dependent (the scope
-            block takes an argument). Preloading happens before the individual
-            instances are created. This means that there is no instance being
-            passed to the association scope. This will most likely result in
-            broken or incorrect behavior. Joining, Preloading and eager loading
-            of these associations is deprecated and will be removed in the future.
+            block takes an argument). Preloading instance dependent scopes is
+            not supported.
           MSG
         end
       end
@@ -389,6 +422,12 @@ module ActiveRecord
         [self]
       end
 
+      # This is for clearing cache on the reflection. Useful for tests that need to compare
+      # SQL queries on associations.
+      def clear_association_scope_cache # :nodoc:
+        @association_scope_cache.clear
+      end
+
       def nested?
         false
       end
@@ -611,8 +650,8 @@ module ActiveRecord
 
       def belongs_to?; true; end
 
-      def join_keys(assoc_klass)
-        key = polymorphic? ? association_primary_key(assoc_klass) : association_primary_key
+      def join_keys(association_klass)
+        key = polymorphic? ? association_primary_key(association_klass) : association_primary_key
         JoinKeys.new(key, foreign_key)
       end
 
@@ -707,13 +746,27 @@ module ActiveRecord
       def chain
         @chain ||= begin
           a = source_reflection.chain
-          b = through_reflection.chain
+          b = through_reflection.chain.map(&:dup)
+
+          if options[:source_type]
+            b[0] = PolymorphicReflection.new(b[0], self)
+          end
+
           chain = a + b
           chain[0] = self # Use self so we don't lose the information from :source_type
           chain
         end
       end
 
+      # This is for clearing cache on the reflection. Useful for tests that need to compare
+      # SQL queries on associations.
+      def clear_association_scope_cache # :nodoc:
+        @chain = nil
+        delegate_reflection.clear_association_scope_cache
+        source_reflection.clear_association_scope_cache
+        through_reflection.clear_association_scope_cache
+      end
+
       # Consider the following example:
       #
       #   class Person
@@ -755,18 +808,8 @@ module ActiveRecord
         end
       end
 
-      def join_keys(assoc_klass)
-        source_reflection.join_keys(assoc_klass)
-      end
-
-      # The macro used by the source association
-      def source_macro
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveRecord::Base.source_macro is deprecated and will be removed
-          without replacement.
-        MSG
-
-        source_reflection.source_macro
+      def join_keys(association_klass)
+        source_reflection.join_keys(association_klass)
       end
 
       # A through association is nested if there would be more than one join table
@@ -801,7 +844,7 @@ module ActiveRecord
       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 = [name.to_s.singularize, name].collect(&:to_sym).uniq
         names = names.find_all { |n|
           through_reflection.klass._reflect_on_association(n)
         }
@@ -865,6 +908,12 @@ module ActiveRecord
         check_validity_of_inverse!
       end
 
+      def constraints
+        scope_chain = source_reflection.constraints
+        scope_chain << scope if scope
+        scope_chain
+      end
+
       protected
 
         def actual_source_reflection # FIXME: this is a horrible name
@@ -889,5 +938,81 @@ module ActiveRecord
         delegate(*delegate_methods, to: :delegate_reflection)
 
     end
+
+    class PolymorphicReflection < ThroughReflection # :nodoc:
+      def initialize(reflection, previous_reflection)
+        @reflection = reflection
+        @previous_reflection = previous_reflection
+      end
+
+      def klass
+        @reflection.klass
+      end
+
+      def scope
+        @reflection.scope
+      end
+
+      def table_name
+        @reflection.table_name
+      end
+
+      def plural_name
+        @reflection.plural_name
+      end
+
+      def join_keys(association_klass)
+        @reflection.join_keys(association_klass)
+      end
+
+      def type
+        @reflection.type
+      end
+
+      def constraints
+        [source_type_info]
+      end
+
+      def source_type_info
+        type = @previous_reflection.foreign_type
+        source_type = @previous_reflection.options[:source_type]
+        lambda { |object| where(type => source_type) }
+      end
+    end
+
+    class RuntimeReflection < PolymorphicReflection # :nodoc:
+      attr_accessor :next
+
+      def initialize(reflection, association)
+        @reflection = reflection
+        @association = association
+      end
+
+      def klass
+        @association.klass
+      end
+
+      def table_name
+        klass.table_name
+      end
+
+      def constraints
+        @reflection.constraints
+      end
+
+      def source_type_info
+        @reflection.source_type_info
+      end
+
+      def alias_candidate(name)
+        "#{plural_name}_#{name}_join"
+      end
+
+      def alias_name
+        Arel::Table.new(table_name)
+      end
+
+      def all_includes; yield; end
+    end
   end
 end