activerecord 4.0.4 → 4.1.16

data/lib/active_record/persistence.rb

@@ -37,7 +37,7 @@ module ActiveRecord
       end
 
       # Given an attributes hash, +instantiate+ returns a new instance of
-      # the appropriate class.
+      # the appropriate class. Accepts only keys as strings.
       #
       # For example, +Post.all+ may return Comments, Messages, and Emails
       # by storing the record's subclass in a +type+ attribute. By calling
@@ -46,10 +46,10 @@ module ActiveRecord
       #
       # See +ActiveRecord::Inheritance#discriminate_class_for_record+ to see
       # how this "single-table" inheritance mapping is implemented.
-      def instantiate(record, column_types = {})
-        klass = discriminate_class_for_record(record)
+      def instantiate(attributes, column_types = {})
+        klass = discriminate_class_for_record(attributes)
         column_types = klass.decorate_columns(column_types.dup)
-        klass.allocate.init_with('attributes' => record, 'column_types' => column_types)
+        klass.allocate.init_with('attributes' => attributes, 'column_types' => column_types)
       end
 
       private
@@ -181,6 +181,8 @@ module ActiveRecord
       became = klass.new
       became.instance_variable_set("@attributes", @attributes)
       became.instance_variable_set("@attributes_cache", @attributes_cache)
+      changed_attributes = @changed_attributes if defined?(@changed_attributes)
+      became.instance_variable_set("@changed_attributes", changed_attributes || {})
       became.instance_variable_set("@new_record", new_record?)
       became.instance_variable_set("@destroyed", destroyed?)
       became.instance_variable_set("@errors", errors)
@@ -268,7 +270,7 @@ module ActiveRecord
     # This method raises an +ActiveRecord::ActiveRecordError+ when called on new
     # objects, or when at least one of the attributes is marked as readonly.
     def update_columns(attributes)
-      raise ActiveRecordError, "can not update on a new record object" unless persisted?
+      raise ActiveRecordError, "cannot update on a new record object" unless persisted?
 
       attributes.each_key do |key|
         verify_readonly_attribute(key.to_s)
@@ -346,7 +348,8 @@ module ActiveRecord
     #   # Account Load (1.2ms)  SELECT "accounts".* FROM "accounts" WHERE "accounts"."id" = $1 LIMIT 1  [["id", 1]]
     #   # => #<Account id: 1, email: 'account@example.com'>
     #
-    # Attributes are updated, and caches busted, in particular the associations cache.
+    # Attributes are reloaded from the database, and caches busted, in
+    # particular the associations cache.
     #
     # If the record no longer exists in the database <tt>ActiveRecord::RecordNotFound</tt>
     # is raised. Otherwise, in addition to the in-place modification the method
@@ -364,7 +367,7 @@ module ActiveRecord
     #   assert_equal 25, account.credit        # check it is updated in memory
     #   assert_equal 25, account.reload.credit # check it is also persisted
     #
-    # Another commom use case is optimistic locking handling:
+    # Another common use case is optimistic locking handling:
     #
     #   def with_optimistic_retry
     #     begin
@@ -397,12 +400,13 @@ module ActiveRecord
       @column_types           = self.class.column_types
       @column_types_override  = fresh_object.instance_variable_get('@column_types_override')
       @attributes_cache       = {}
+      @new_record             = false
       self
     end
 
     # Saves the record with the updated_at/on attributes set to the current time.
-    # Please note that no validation is performed and only the +after_touch+
-    # callback is executed.
+    # Please note that no validation is performed and only the +after_touch+,
+    # +after_commit+ and +after_rollback+ callbacks are executed.
     # If an attribute name is passed, that attribute is updated along with
     # updated_at/on attributes.
     #
@@ -429,7 +433,7 @@ module ActiveRecord
     #   ball.touch(:updated_at)   # => raises ActiveRecordError
     #
     def touch(name = nil)
-      raise ActiveRecordError, "can not touch on a new record object" unless persisted?
+      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
 
       attributes = timestamp_attributes_for_update_in_model
       attributes << name if name
@@ -445,9 +449,11 @@ module ActiveRecord
 
         changes[self.class.locking_column] = increment_lock if locking_enabled?
 
-        @changed_attributes.except!(*changes.keys)
+        changed_attributes.except!(*changes.keys)
         primary_key = self.class.primary_key
         self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
+      else
+        true
       end
     end
 
@@ -475,36 +481,24 @@ module ActiveRecord
 
     def create_or_update
       raise ReadOnlyRecord if readonly?
-      result = new_record? ? create_record : update_record
+      result = new_record? ? _create_record : _update_record
       result != false
     end
 
     # Updates the associated record with values matching those of the instance attributes.
     # Returns the number of affected rows.
-    def update_record(attribute_names = @attributes.keys)
-      attributes_with_values = arel_attributes_with_values_for_update(attribute_names)
-      if attributes_with_values.empty?
+    def _update_record(attribute_names = @attributes.keys)
+      attributes_values = arel_attributes_with_values_for_update(attribute_names)
+      if attributes_values.empty?
         0
       else
-        klass = self.class
-        column_hash = klass.connection.schema_cache.columns_hash klass.table_name
-        db_columns_with_values = attributes_with_values.map { |attr,value|
-          real_column = column_hash[attr.name]
-          [real_column, value]
-        }
-        bind_attrs = attributes_with_values.dup
-        bind_attrs.keys.each_with_index do |column, i|
-          real_column = db_columns_with_values[i].first
-          bind_attrs[column] = klass.connection.substitute_at(real_column, i)
-        end
-        stmt = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id_was || id)).arel.compile_update(bind_attrs)
-        klass.connection.update stmt, 'SQL', db_columns_with_values
+        self.class.unscoped._update_record attributes_values, id, id_was
       end
     end
 
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
-    def create_record(attribute_names = @attributes.keys)
+    def _create_record(attribute_names = @attributes.keys)
       attributes_values = arel_attributes_with_values_for_create(attribute_names)
 
       new_id = self.class.unscoped.insert attributes_values

data/lib/active_record/querying.rb

@@ -1,20 +1,22 @@
 module ActiveRecord
   module Querying
-    delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, :to => :all
-    delegate :first_or_create, :first_or_create!, :first_or_initialize, :to => :all
-    delegate :find_or_create_by, :find_or_create_by!, :find_or_initialize_by, :to => :all
-    delegate :find_by, :find_by!, :to => :all
-    delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, :to => :all
-    delegate :find_each, :find_in_batches, :to => :all
+    delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, to: :all
+    delegate :second, :second!, :third, :third!, :fourth, :fourth!, :fifth, :fifth!, :forty_two, :forty_two!, to: :all
+    delegate :first_or_create, :first_or_create!, :first_or_initialize, to: :all
+    delegate :find_or_create_by, :find_or_create_by!, :find_or_initialize_by, to: :all
+    delegate :find_by, :find_by!, to: :all
+    delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, to: :all
+    delegate :find_each, :find_in_batches, to: :all
     delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins,
-             :where, :preload, :eager_load, :includes, :from, :lock, :readonly,
-             :having, :create_with, :uniq, :distinct, :references, :none, :unscope, :to => :all
-    delegate :count, :average, :minimum, :maximum, :sum, :calculate, :pluck, :ids, :to => :all
+             :where, :rewhere, :preload, :eager_load, :includes, :from, :lock, :readonly,
+             :having, :create_with, :uniq, :distinct, :references, :none, :unscope, to: :all
+    delegate :count, :average, :minimum, :maximum, :sum, :calculate, to: :all
+    delegate :pluck, :ids, to: :all
 
     # Executes a custom SQL query against your database and returns all the results. The results will
     # be returned as an array with columns requested encapsulated as attributes of the model you call
     # this method from. If you call <tt>Product.find_by_sql</tt> then the results will be returned in
-    # a Product object with the attributes you specified in the SQL query.
+    # a +Product+ object with the attributes you specified in the SQL query.
     #
     # If you call a complicated SQL query which spans multiple tables the columns specified by the
     # SELECT will be attributes of the model, whether or not they are columns of the corresponding
@@ -29,9 +31,10 @@ module ActiveRecord
     #   Post.find_by_sql "SELECT p.title, c.author FROM posts p, comments c WHERE p.id = c.post_id"
     #   # => [#<Post:0x36bff9c @attributes={"title"=>"Ruby Meetup", "first_name"=>"Quentin"}>, ...]
     #
-    #   # You can use the same string replacement techniques as you can with ActiveRecord#find
+    # You can use the same string replacement techniques as you can with <tt>ActiveRecord::QueryMethods#where</tt>:
+    #
     #   Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date]
-    #   # => [#<Post:0x36bff9c @attributes={"title"=>"The Cheap Man Buys Twice"}>, ...]
+    #   Post.find_by_sql ["SELECT body FROM comments WHERE author = :user_id OR approved_by = :user_id", { :user_id => user_id }]
     def find_by_sql(sql, binds = [])
       result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds)
       column_types = {}

data/lib/active_record/railtie.rb

@@ -31,22 +31,14 @@ module ActiveRecord
 
 
     config.active_record.use_schema_cache_dump = true
+    config.active_record.maintain_test_schema = true
 
     config.eager_load_namespaces << ActiveRecord
 
     rake_tasks do
-      require "active_record/base"
-
-      ActiveRecord::Tasks::DatabaseTasks.seed_loader = Rails.application
-      ActiveRecord::Tasks::DatabaseTasks.env = Rails.env
-
       namespace :db do
         task :load_config do
-          ActiveRecord::Tasks::DatabaseTasks.db_dir = Rails.application.config.paths["db"].first
           ActiveRecord::Tasks::DatabaseTasks.database_configuration = Rails.application.config.database_configuration
-          ActiveRecord::Tasks::DatabaseTasks.migrations_paths = Rails.application.paths['db/migrate'].to_a
-          ActiveRecord::Tasks::DatabaseTasks.fixtures_path = File.join Rails.root, 'test', 'fixtures'
-          ActiveRecord::Tasks::DatabaseTasks.root = Rails.root
 
           if defined?(ENGINE_PATH) && engine = Rails::Engine.find(ENGINE_PATH)
             if engine.paths['db/migrate'].existent
@@ -112,56 +104,6 @@ module ActiveRecord
 
     initializer "active_record.set_configs" do |app|
       ActiveSupport.on_load(:active_record) do
-        begin
-          old_behavior, ActiveSupport::Deprecation.behavior = ActiveSupport::Deprecation.behavior, :stderr
-          whitelist_attributes = app.config.active_record.delete(:whitelist_attributes)
-
-          if respond_to?(:mass_assignment_sanitizer=)
-            mass_assignment_sanitizer = nil
-          else
-            mass_assignment_sanitizer = app.config.active_record.delete(:mass_assignment_sanitizer)
-          end
-
-          unless whitelist_attributes.nil? && mass_assignment_sanitizer.nil?
-            ActiveSupport::Deprecation.warn <<-EOF.strip_heredoc, []
-              Model based mass assignment security has been extracted
-              out of Rails into a gem. Please use the new recommended protection model for
-              params or add `protected_attributes` to your Gemfile to use the old one.
-
-              To disable this message remove the `whitelist_attributes` option from your
-              `config/application.rb` file and any `mass_assignment_sanitizer` options
-              from your `config/environments/*.rb` files.
-
-              See http://guides.rubyonrails.org/security.html#mass-assignment for more information.
-            EOF
-          end
-
-          unless app.config.active_record.delete(:auto_explain_threshold_in_seconds).nil?
-            ActiveSupport::Deprecation.warn <<-EOF.strip_heredoc, []
-              The Active Record auto explain feature has been removed.
-
-              To disable this message remove the `active_record.auto_explain_threshold_in_seconds`
-              option from the `config/environments/*.rb` config file.
-
-              See http://guides.rubyonrails.org/4_0_release_notes.html for more information.
-            EOF
-          end
-
-          unless app.config.active_record.delete(:observers).nil?
-            ActiveSupport::Deprecation.warn <<-EOF.strip_heredoc, []
-              Active Record Observers has been extracted out of Rails into a gem.
-              Please use callbacks or add `rails-observers` to your Gemfile to use observers.
-
-              To disable this message remove the `observers` option from your
-              `config/application.rb` or from your initializers.
-
-              See http://guides.rubyonrails.org/4_0_release_notes.html for more information.
-            EOF
-          end
-        ensure
-          ActiveSupport::Deprecation.behavior = old_behavior
-        end
-
         app.config.active_record.each do |k,v|
           send "#{k}=", v
         end
@@ -172,7 +114,16 @@ module ActiveRecord
     # and then establishes the connection.
     initializer "active_record.initialize_database" do |app|
       ActiveSupport.on_load(:active_record) do
-        self.configurations = app.config.database_configuration || {}
+
+        class ActiveRecord::NoDatabaseError
+          remove_possible_method :extend_message
+          def extend_message(message)
+            message << "Run `$ bin/rake db:create db:migrate` to create your database"
+            message
+          end
+        end
+
+        self.configurations = Rails.application.config.database_configuration
         establish_connection
       end
     end
@@ -191,8 +142,8 @@ module ActiveRecord
       ActiveSupport.on_load(:active_record) do
         ActionDispatch::Reloader.send(hook) do
           if ActiveRecord::Base.connected?
-            ActiveRecord::Base.clear_reloadable_connections!
             ActiveRecord::Base.clear_cache!
+            ActiveRecord::Base.clear_reloadable_connections!
           end
         end
       end

data/lib/active_record/railties/databases.rake

@@ -2,7 +2,7 @@ require 'active_record'
 
 db_namespace = namespace :db do
   task :load_config do
-    ActiveRecord::Base.configurations = ActiveRecord::Tasks::DatabaseTasks.database_configuration || {}
+    ActiveRecord::Base.configurations       = ActiveRecord::Tasks::DatabaseTasks.database_configuration || {}
     ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
   end
 
@@ -12,13 +12,9 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Create the database from DATABASE_URL or config/database.yml for the current Rails.env (use db:create:all to create all dbs in the config)'
+  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
-    if ENV['DATABASE_URL']
-      ActiveRecord::Tasks::DatabaseTasks.create_database_url
-    else
-      ActiveRecord::Tasks::DatabaseTasks.create_current
-    end
+    ActiveRecord::Tasks::DatabaseTasks.create_current
   end
 
   namespace :drop do
@@ -27,13 +23,9 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Drops the database using DATABASE_URL or the current Rails.env (use db:drop:all to drop all 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
-    if ENV['DATABASE_URL']
-      ActiveRecord::Tasks::DatabaseTasks.drop_database_url
-    else
-      ActiveRecord::Tasks::DatabaseTasks.drop_current
-    end
+    ActiveRecord::Tasks::DatabaseTasks.drop_current
   end
 
   desc "Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)."
@@ -42,7 +34,7 @@ db_namespace = namespace :db do
     ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil) do |migration|
       ENV["SCOPE"].blank? || (ENV["SCOPE"] == migration.scope)
     end
-    db_namespace['_dump'].invoke
+    db_namespace['_dump'].invoke if ActiveRecord::Base.dump_schema_after_migration
   end
 
   task :_dump do
@@ -83,7 +75,7 @@ db_namespace = namespace :db do
     # desc 'Runs the "down" for a given migration VERSION.'
     task :down => [:environment, :load_config] do
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required' unless version
+      raise 'VERSION is required - To go down one migration, run db:rollback' unless version
       ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
@@ -95,14 +87,15 @@ db_namespace = namespace :db do
         next  # means "return" for rake task
       end
       db_list = ActiveRecord::Base.connection.select_values("SELECT version FROM #{ActiveRecord::Migrator.schema_migrations_table_name}")
-      db_list.map! { |version| "%.3d" % version }
+      db_list.map! { |version| ActiveRecord::SchemaMigration.normalize_migration_number(version) }
       file_list = []
       ActiveRecord::Migrator.migrations_paths.each do |path|
         Dir.foreach(path) do |file|
           # match "20091231235959_some_name.rb" and "001_some_name.rb" pattern
           if match_data = /^(\d{3,})_(.+)\.rb$/.match(file)
-            status = db_list.delete(match_data[1]) ? 'up' : 'down'
-            file_list << [status, match_data[1], match_data[2].humanize]
+            version = ActiveRecord::SchemaMigration.normalize_migration_number(match_data[1])
+            status = db_list.delete(version) ? 'up' : 'down'
+            file_list << [status, version, match_data[2].humanize]
           end
         end
       end
@@ -172,7 +165,7 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)'
+  desc 'Create the database, load the schema, and initialize 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'
@@ -187,9 +180,6 @@ db_namespace = namespace :db do
       require 'active_record/fixtures'
 
       base_dir = if ENV['FIXTURES_PATH']
-        STDERR.puts "Using FIXTURES_PATH env variable is deprecated, please use " +
-                    "ActiveRecord::Tasks::DatabaseTasks.fixtures_path = '/path/to/fixtures' " +
-                    "instead."
         File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
       else
         ActiveRecord::Tasks::DatabaseTasks.fixtures_path
@@ -197,7 +187,7 @@ db_namespace = namespace :db do
 
       fixtures_dir = File.join [base_dir, ENV['FIXTURES_DIR']].compact
 
-      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir["#{fixtures_dir}/**/*.yml"].map {|f| f[(fixtures_dir.size + 1)..-5] }).each do |fixture_file|
+      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(',') : Dir["#{fixtures_dir}/**/*.yml"].map {|f| f[(fixtures_dir.size + 1)..-5] }).each do |fixture_file|
         ActiveRecord::FixtureSet.create_fixtures(fixtures_dir, fixture_file)
       end
     end
@@ -212,9 +202,6 @@ db_namespace = namespace :db do
       puts %Q(The fixture ID for "#{label}" is #{ActiveRecord::FixtureSet.identify(label)}.) if label
 
       base_dir = if ENV['FIXTURES_PATH']
-        STDERR.puts "Using FIXTURES_PATH env variable is deprecated, please use " +
-                    "ActiveRecord::Tasks::DatabaseTasks.fixtures_path = '/path/to/fixtures' " +
-                    "instead."
         File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
       else
         ActiveRecord::Tasks::DatabaseTasks.fixtures_path
@@ -236,7 +223,7 @@ db_namespace = namespace :db do
   end
 
   namespace :schema do
-    desc 'Create a db/schema.rb file that can be portably used against any DB supported by AR'
+    desc 'Create a db/schema.rb file that is portable against any DB supported by AR'
     task :dump => [:environment, :load_config] do
       require 'active_record/schema_dumper'
       filename = ENV['SCHEMA'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'schema.rb')
@@ -248,12 +235,7 @@ db_namespace = namespace :db do
 
     desc 'Load a schema.rb file into the database'
     task :load => [:environment, :load_config] do
-      file = ENV['SCHEMA'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'schema.rb')
-      if File.exist?(file)
-        load(file)
-      else
-        abort %{#{file} doesn't exist yet. Run `rake db:migrate` to create it, then try again. If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.}
-      end
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:ruby, ENV['SCHEMA'])
     end
 
     task :load_if_ruby => ['db:create', :environment] do
@@ -287,9 +269,11 @@ db_namespace = namespace :db do
       current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
       ActiveRecord::Tasks::DatabaseTasks.structure_dump(current_config, filename)
 
-      if ActiveRecord::Base.connection.supports_migrations?
+      if ActiveRecord::Base.connection.supports_migrations? &&
+          ActiveRecord::SchemaMigration.table_exists?
         File.open(filename, "a") do |f|
           f.puts ActiveRecord::Base.connection.dump_schema_information
+          f.print "\n"
         end
       end
       db_namespace['structure:dump'].reenable
@@ -297,9 +281,7 @@ db_namespace = namespace :db do
 
     # desc "Recreate the databases from the structure.sql file"
     task :load => [:environment, :load_config] do
-      filename = ENV['DB_STRUCTURE'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure.sql")
-      current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
-      ActiveRecord::Tasks::DatabaseTasks.structure_load(current_config, filename)
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql, ENV['DB_STRUCTURE'])
     end
 
     task :load_if_sql => ['db:create', :environment] do
@@ -309,8 +291,15 @@ db_namespace = namespace :db do
 
   namespace :test do
 
+    task :deprecated do
+      Rake.application.top_level_tasks.grep(/^db:test:/).each do |task|
+        $stderr.puts "WARNING: #{task} is deprecated. The Rails test helper now maintains " \
+                     "your test schema automatically, see the release notes for details."
+      end
+    end
+
     # desc "Recreate the test database from the current schema"
-    task :load => 'db:test:purge' do
+    task :load => %w(db:test:purge) do
       case ActiveRecord::Base.schema_format
         when :ruby
           db_namespace["test:load_schema"].invoke
@@ -320,12 +309,11 @@ db_namespace = namespace :db do
     end
 
     # desc "Recreate the test database from an existent schema.rb file"
-    task :load_schema => 'db:test:purge' do
+    task :load_schema => %w(db:test:purge) do
       begin
         should_reconnect = ActiveRecord::Base.connection_pool.active_connection?
-        ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
         ActiveRecord::Schema.verbose = false
-        db_namespace["schema:load"].invoke
+        ActiveRecord::Tasks::DatabaseTasks.load_schema_for ActiveRecord::Base.configurations['test'], :ruby, ENV['SCHEMA']
       ensure
         if should_reconnect
           ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[ActiveRecord::Tasks::DatabaseTasks.env])
@@ -334,17 +322,12 @@ db_namespace = namespace :db do
     end
 
     # desc "Recreate the test database from an existent structure.sql file"
-    task :load_structure => 'db:test:purge' do
-      begin
-        ActiveRecord::Tasks::DatabaseTasks.current_config(:config => ActiveRecord::Base.configurations['test'])
-        db_namespace["structure:load"].invoke
-      ensure
-        ActiveRecord::Tasks::DatabaseTasks.current_config(:config => nil)
-      end
+    task :load_structure => %w(db:test:purge) do
+      ActiveRecord::Tasks::DatabaseTasks.load_schema_for ActiveRecord::Base.configurations['test'], :sql, ENV['SCHEMA']
     end
 
     # desc "Recreate the test database from a fresh schema"
-    task :clone => :environment do
+    task :clone => %w(db:test:deprecated environment) do
       case ActiveRecord::Base.schema_format
         when :ruby
           db_namespace["test:clone_schema"].invoke
@@ -354,18 +337,18 @@ db_namespace = namespace :db do
     end
 
     # desc "Recreate the test database from a fresh schema.rb file"
-    task :clone_schema => ["db:schema:dump", "db:test:load_schema"]
+    task :clone_schema => %w(db:test:deprecated db:schema:dump db:test:load_schema)
 
     # desc "Recreate the test database from a fresh structure.sql file"
-    task :clone_structure => [ "db:structure:dump", "db:test:load_structure" ]
+    task :clone_structure => %w(db:test:deprecated db:structure:dump db:test:load_structure)
 
     # desc "Empty the test database"
-    task :purge => [:environment, :load_config] do
+    task :purge => %w(environment load_config) do
       ActiveRecord::Tasks::DatabaseTasks.purge ActiveRecord::Base.configurations['test']
     end
 
     # desc 'Check for pending migrations and load the test schema'
-    task :prepare => [:environment, :load_config] do
+    task :prepare => %w(environment load_config) do
       unless ActiveRecord::Base.configurations.blank?
         db_namespace['test:load'].invoke
       end
@@ -379,7 +362,7 @@ namespace :railties do
     task :migrations => :'db:load_config' do
       to_load = ENV['FROM'].blank? ? :all : ENV['FROM'].split(",").map {|n| n.strip }
       railties = {}
-      Rails.application.railties.each do |railtie|
+      Rails.application.migration_railties.each do |railtie|
         next unless to_load == :all || to_load.include?(railtie.railtie_name)
 
         if railtie.respond_to?(:paths) && (path = railtie.paths['db/migrate'].first)
@@ -400,5 +383,3 @@ namespace :railties do
     end
   end
 end
-
-task 'test:prepare' => ['db:test:prepare', 'db:test:load', 'db:abort_if_pending_migrations']

data/lib/active_record/readonly_attributes.rb

@@ -20,11 +20,5 @@ module ActiveRecord
         self._attr_readonly
       end
     end
-
-    def _attr_readonly
-      message = "Instance level _attr_readonly method is deprecated, please use class level method."
-      ActiveSupport::Deprecation.warn message
-      defined?(@_attr_readonly) ? @_attr_readonly : self.class._attr_readonly
-    end
   end
 end