activerecord 3.1.9 → 3.2.12

data/lib/active_record/railties/databases.rake

@@ -1,8 +1,27 @@
 require 'active_support/core_ext/object/inclusion'
+require 'active_record'
 
 db_namespace = namespace :db do
-  task :load_config => :rails_env do
-    require 'active_record'
+  def database_url_config
+    @database_url_config ||=
+        ActiveRecord::Base::ConnectionSpecification::Resolver.new(ENV["DATABASE_URL"], {}).spec.config.stringify_keys
+  end
+
+  def current_config(options = {})
+    options = { :env => Rails.env }.merge! options
+
+    if options[:config]
+      @current_config = options[:config]
+    else
+      @current_config ||= if ENV['DATABASE_URL']
+                            database_url_config
+                          else
+                            ActiveRecord::Base.configurations[options[:env]]
+                          end
+    end
+  end
+
+  task :load_config do
     ActiveRecord::Base.configurations = Rails.application.config.database_configuration
     ActiveRecord::Migrator.migrations_paths = Rails.application.paths['db/migrate'].to_a
 
@@ -27,7 +46,7 @@ db_namespace = namespace :db do
         #
         #  development:
         #    database: blog_development
-        #    <<: *defaults
+        #    *defaults
         next unless config['database']
         # Only connect to local databases
         local_database?(config) { create_database(config) }
@@ -35,19 +54,20 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Create the database from config/database.yml for the current Rails.env (use db:create:all to create all dbs in the config)'
-  task :create => :load_config do
-    # Make the test database at the same time as the development one, if it exists
-    if Rails.env.development? && ActiveRecord::Base.configurations['test']
-      create_database(ActiveRecord::Base.configurations['test'])
+  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)'
+  task :create => [:load_config, :rails_env] do
+    if ENV['DATABASE_URL']
+      create_database(database_url_config)
+    else
+      configs_for_environment.each { |config| create_database(config) }
+      ActiveRecord::Base.establish_connection(configs_for_environment.first)
     end
-    create_database(ActiveRecord::Base.configurations[Rails.env])
   end
 
   def mysql_creation_options(config)
     @charset   = ENV['CHARSET']   || 'utf8'
     @collation = ENV['COLLATION'] || 'utf8_unicode_ci'
-    {:charset => (config['charset'] || @charset), :collation => (config['collation'] || @collation)}
+    {:charset => (config['encoding'] || @charset), :collation => (config['collation'] || @collation)}
   end
 
   def create_database(config)
@@ -99,8 +119,8 @@ db_namespace = namespace :db do
             ActiveRecord::Base.establish_connection(config)
           else
             $stderr.puts sqlerr.error
-            $stderr.puts "Couldn't create database for #{config.inspect}, charset: #{config['charset'] || @charset}, collation: #{config['collation'] || @collation}"
-            $stderr.puts "(if you set the charset manually, make sure you have a matching collation)" if config['charset']
+            $stderr.puts "Couldn't create database for #{config.inspect}, charset: #{config['encoding'] || @charset}, collation: #{config['collation'] || @collation}"
+            $stderr.puts "(if you set the charset manually, make sure you have a matching collation)" if config['encoding']
           end
         end
       when /postgresql/
@@ -136,13 +156,12 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Drops the database for the current Rails.env (use db:drop:all to drop all databases)'
-  task :drop => :load_config do
-    config = ActiveRecord::Base.configurations[Rails.env || 'development']
-    begin
-      drop_database(config)
-    rescue Exception => e
-      $stderr.puts "Couldn't drop #{config['database']} : #{e.inspect}"
+  desc 'Drops the database using DATABASE_URL or the current Rails.env (use db:drop:all to drop all databases)'
+  task :drop => [:load_config, :rails_env] do
+    if ENV['DATABASE_URL']
+      drop_database_and_rescue(database_url_config)
+    else
+      configs_for_environment.each { |config| drop_database_and_rescue(config) }
     end
   end
 
@@ -154,12 +173,25 @@ db_namespace = namespace :db do
     end
   end
 
-
   desc "Migrate the database (options: VERSION=x, VERBOSE=false)."
   task :migrate => [:environment, :load_config] do
     ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
-    ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
-    db_namespace["schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    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
+  end
+
+  task :_dump do
+    case ActiveRecord::Base.schema_format
+    when :ruby then db_namespace["schema:dump"].invoke
+    when :sql  then db_namespace["structure:dump"].invoke
+    else
+      raise "unknown schema format #{ActiveRecord::Base.schema_format}"
+    end
+    # Allow this task to be called as many times as required. An example is the
+    # migrate:redo task, which calls other two internally that depend on this one.
+    db_namespace['_dump'].reenable
   end
 
   namespace :migrate do
@@ -182,7 +214,7 @@ db_namespace = namespace :db do
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
       raise 'VERSION is required' unless version
       ActiveRecord::Migrator.run(:up, ActiveRecord::Migrator.migrations_paths, version)
-      db_namespace['schema:dump'].invoke if ActiveRecord::Base.schema_format == :ruby
+      db_namespace['_dump'].invoke
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
@@ -190,13 +222,11 @@ db_namespace = namespace :db do
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
       raise 'VERSION is required' unless version
       ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_paths, version)
-      db_namespace['schema:dump'].invoke if ActiveRecord::Base.schema_format == :ruby
+      db_namespace['_dump'].invoke
     end
 
     desc 'Display status of migrations'
     task :status => [:environment, :load_config] do
-      config = ActiveRecord::Base.configurations[Rails.env || 'development']
-      ActiveRecord::Base.establish_connection(config)
       unless ActiveRecord::Base.connection.table_exists?(ActiveRecord::Migrator.schema_migrations_table_name)
         puts 'Schema migrations table does not exist yet.'
         next  # means "return" for rake task
@@ -216,7 +246,7 @@ db_namespace = namespace :db do
         ['up', version, '********** NO FILE **********']
       end
       # output
-      puts "\ndatabase: #{config['database']}\n\n"
+      puts "\ndatabase: #{ActiveRecord::Base.connection_config[:database]}\n\n"
       puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
       puts "-" * 50
       (db_list + file_list).sort_by {|migration| migration[1]}.each do |migration|
@@ -230,22 +260,25 @@ db_namespace = namespace :db do
   task :rollback => [:environment, :load_config] do
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
     ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_paths, step)
-    db_namespace['schema:dump'].invoke if ActiveRecord::Base.schema_format == :ruby
+    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)
-    db_namespace['schema:dump'].invoke if ActiveRecord::Base.schema_format == :ruby
+    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 => [ 'db:drop', 'db:setup' ]
+  task :reset => [:environment, :load_config] do
+    db_namespace["drop"].invoke
+    db_namespace["setup"].invoke
+  end
 
   # desc "Retrieves the charset for the current environment's database"
-  task :charset => :environment do
-    config = ActiveRecord::Base.configurations[Rails.env || 'development']
+  task :charset => [:environment, :load_config] do
+    config = ActiveRecord::Base.configurations[Rails.env]
     case config['adapter']
     when /mysql/
       ActiveRecord::Base.establish_connection(config)
@@ -262,8 +295,8 @@ db_namespace = namespace :db do
   end
 
   # desc "Retrieves the collation for the current environment's database"
-  task :collation => :environment do
-    config = ActiveRecord::Base.configurations[Rails.env || 'development']
+  task :collation => [:environment, :load_config] do
+    config = ActiveRecord::Base.configurations[Rails.env]
     case config['adapter']
     when /mysql/
       ActiveRecord::Base.establish_connection(config)
@@ -274,39 +307,37 @@ db_namespace = namespace :db do
   end
 
   desc 'Retrieves the current schema version number'
-  task :version => :environment do
+  task :version => [:environment, :load_config] do
     puts "Current version: #{ActiveRecord::Migrator.current_version}"
   end
 
   # desc "Raises an error if there are pending migrations"
-  task :abort_if_pending_migrations => :environment do
-    if defined? ActiveRecord
-      pending_migrations = ActiveRecord::Migrator.new(:up, ActiveRecord::Migrator.migrations_paths).pending_migrations
-
-      if pending_migrations.any?
-        puts "You have #{pending_migrations.size} pending migrations:"
-        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.}
+  task :abort_if_pending_migrations => [:environment, :load_config] do
+    pending_migrations = ActiveRecord::Migrator.new(:up, ActiveRecord::Migrator.migrations_paths).pending_migrations
+
+    if pending_migrations.any?
+      puts "You have #{pending_migrations.size} pending migrations:"
+      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.}
     end
   end
 
   desc 'Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)'
-  task :setup => [ 'db:create', 'db:schema:load', 'db:seed' ]
+  task :setup => ['db:schema:load_if_ruby', 'db:structure:load_if_sql', :seed]
 
   desc 'Load the seed data from db/seeds.rb'
-  task :seed => 'db:abort_if_pending_migrations' do
+  task :seed do
+    db_namespace['abort_if_pending_migrations'].invoke
     Rails.application.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."
-    task :load => :environment 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."
+    task :load => [:environment, :load_config] do
       require 'active_record/fixtures'
 
-      ActiveRecord::Base.establish_connection(Rails.env)
       base_dir     = File.join [Rails.root, ENV['FIXTURES_PATH'] || %w{test fixtures}].flatten
       fixtures_dir = File.join [base_dir, ENV['FIXTURES_DIR']].compact
 
@@ -316,7 +347,7 @@ db_namespace = namespace :db do
     end
 
     # desc "Search for a fixture given a LABEL or ID. Specify an alternative path (eg. spec/fixtures) using FIXTURES_PATH=spec/fixtures."
-    task :identify => :environment do
+    task :identify => [:environment, :load_config] do
       require 'active_record/fixtures'
 
       label, id = ENV['LABEL'], ENV['ID']
@@ -345,107 +376,137 @@ db_namespace = namespace :db do
       require 'active_record/schema_dumper'
       filename = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
       File.open(filename, "w:utf-8") do |file|
-        ActiveRecord::Base.establish_connection(Rails.env)
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
       end
       db_namespace['schema:dump'].reenable
     end
 
     desc 'Load a schema.rb file into the database'
-    task :load => :environment do
+    task :load => [:environment, :load_config] do
       file = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
       if File.exists?(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}
+        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
     end
+
+    task :load_if_ruby => ['db:create', :environment] do
+      db_namespace["schema:load"].invoke if ActiveRecord::Base.schema_format == :ruby
+    end
   end
 
   namespace :structure do
-    desc 'Dump the database structure to an SQL file'
-    task :dump => :environment do
-      abcs = ActiveRecord::Base.configurations
-      case abcs[Rails.env]['adapter']
+    desc 'Dump the database structure to db/structure.sql. Specify another file with DB_STRUCTURE=db/my_structure.sql'
+    task :dump => [:environment, :load_config] do
+      config = current_config
+      filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, "db", "structure.sql")
+      case config['adapter']
       when /mysql/, 'oci', 'oracle'
-        ActiveRecord::Base.establish_connection(abcs[Rails.env])
-        File.open("#{Rails.root}/db/#{Rails.env}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+        ActiveRecord::Base.establish_connection(config)
+        File.open(filename, "w:utf-8") { |f| f << ActiveRecord::Base.connection.structure_dump }
       when /postgresql/
-        ENV['PGHOST']     = abcs[Rails.env]['host'] if abcs[Rails.env]['host']
-        ENV['PGPORT']     = abcs[Rails.env]["port"].to_s if abcs[Rails.env]['port']
-        ENV['PGPASSWORD'] = abcs[Rails.env]['password'].to_s if abcs[Rails.env]['password']
-        search_path = abcs[Rails.env]['schema_search_path']
+        set_psql_env(config)
+        search_path = config['schema_search_path']
         unless search_path.blank?
-          search_path = search_path.split(",").map{|search_path| "--schema=#{search_path.strip}" }.join(" ")
+          search_path = search_path.split(",").map{|search_path_part| "--schema=#{Shellwords.escape(search_path_part.strip)}" }.join(" ")
         end
-        `pg_dump -i -U "#{abcs[Rails.env]['username']}" -s -x -O -f db/#{Rails.env}_structure.sql #{search_path} #{abcs[Rails.env]['database']}`
+        `pg_dump -i -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(config['database'])}`
         raise 'Error dumping database' if $?.exitstatus == 1
       when /sqlite/
-        dbfile = abcs[Rails.env]['database'] || abcs[Rails.env]['dbfile']
-        `sqlite3 #{dbfile} .schema > db/#{Rails.env}_structure.sql`
+        dbfile = config['database']
+        `sqlite3 #{dbfile} .schema > #{filename}`
       when 'sqlserver'
-        `smoscript -s #{abcs[Rails.env]['host']} -d #{abcs[Rails.env]['database']} -u #{abcs[Rails.env]['username']} -p #{abcs[Rails.env]['password']} -f db\\#{Rails.env}_structure.sql -A -U`
+        `smoscript -s #{config['host']} -d #{config['database']} -u #{config['username']} -p #{config['password']} -f #{filename} -A -U`
       when "firebird"
         set_firebird_env(abcs[Rails.env])
         db_string = firebird_db_string(abcs[Rails.env])
-        sh "isql -a #{db_string} > #{Rails.root}/db/#{Rails.env}_structure.sql"
+        sh "isql -a #{db_string} > #{filename}"
       else
         raise "Task not supported by '#{abcs[Rails.env]["adapter"]}'"
       end
 
       if ActiveRecord::Base.connection.supports_migrations?
-        File.open("#{Rails.root}/db/#{Rails.env}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+        File.open(filename, "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
       end
+      db_namespace['structure:dump'].reenable
     end
-  end
-
-  namespace :test do
-    # desc "Recreate the test database from the current schema.rb"
-    task :load => 'db:test:purge' do
-      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
-      ActiveRecord::Schema.verbose = false
-      db_namespace['schema:load'].invoke
-    end
-
-    # desc "Recreate the test database from the current environment's database schema"
-    task :clone => %w(db:schema:dump db:test:load)
 
-    # desc "Recreate the test databases from the development structure"
-    task :clone_structure => [ 'db:structure:dump', 'db:test:purge' ] do
-      abcs = ActiveRecord::Base.configurations
-      case abcs['test']['adapter']
+    # desc "Recreate the databases from the structure.sql file"
+    task :load => [:environment, :load_config] do
+      config = current_config
+      filename = ENV['DB_STRUCTURE'] || File.join(Rails.root, "db", "structure.sql")
+      case config['adapter']
       when /mysql/
-        ActiveRecord::Base.establish_connection(:test)
+        ActiveRecord::Base.establish_connection(config)
         ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
-        IO.readlines("#{Rails.root}/db/#{Rails.env}_structure.sql").join.split("\n\n").each do |table|
+        IO.read(filename).split("\n\n").each do |table|
           ActiveRecord::Base.connection.execute(table)
         end
       when /postgresql/
-        ENV['PGHOST']     = abcs['test']['host'] if abcs['test']['host']
-        ENV['PGPORT']     = abcs['test']['port'].to_s if abcs['test']['port']
-        ENV['PGPASSWORD'] = abcs['test']['password'].to_s if abcs['test']['password']
-        `psql -U "#{abcs['test']['username']}" -f "#{Rails.root}/db/#{Rails.env}_structure.sql" #{abcs['test']['database']} #{abcs['test']['template']}`
+        set_psql_env(config)
+        `psql -f "#{filename}" #{config['database']}`
       when /sqlite/
-        dbfile = abcs['test']['database'] || abcs['test']['dbfile']
-        `sqlite3 #{dbfile} < "#{Rails.root}/db/#{Rails.env}_structure.sql"`
+        dbfile = config['database']
+        `sqlite3 #{dbfile} < "#{filename}"`
       when 'sqlserver'
-        `sqlcmd -S #{abcs['test']['host']} -d #{abcs['test']['database']} -U #{abcs['test']['username']} -P #{abcs['test']['password']} -i db\\#{Rails.env}_structure.sql`
+        `sqlcmd -S #{config['host']} -d #{config['database']} -U #{config['username']} -P #{config['password']} -i #{filename}`
       when 'oci', 'oracle'
-        ActiveRecord::Base.establish_connection(:test)
-        IO.readlines("#{Rails.root}/db/#{Rails.env}_structure.sql").join.split(";\n\n").each do |ddl|
+        ActiveRecord::Base.establish_connection(config)
+        IO.read(filename).split(";\n\n").each do |ddl|
           ActiveRecord::Base.connection.execute(ddl)
         end
       when 'firebird'
-        set_firebird_env(abcs['test'])
-        db_string = firebird_db_string(abcs['test'])
-        sh "isql -i #{Rails.root}/db/#{Rails.env}_structure.sql #{db_string}"
+        set_firebird_env(config)
+        db_string = firebird_db_string(config)
+        sh "isql -i #{filename} #{db_string}"
       else
-        raise "Task not supported by '#{abcs['test']['adapter']}'"
+        raise "Task not supported by '#{config['adapter']}'"
+      end
+    end
+
+    task :load_if_sql => ['db:create', :environment] do
+      db_namespace["structure:load"].invoke if ActiveRecord::Base.schema_format == :sql
+    end
+  end
+
+  namespace :test do
+
+    # desc "Recreate the test database from the current schema"
+    task :load => 'db:test:purge' do
+      case ActiveRecord::Base.schema_format
+        when :ruby
+          db_namespace["test:load_schema"].invoke
+        when :sql
+          db_namespace["test:load_structure"].invoke
       end
     end
 
+    # desc "Recreate the test database from an existent structure.sql file"
+    task :load_structure => 'db:test:purge' do
+      begin
+        current_config(:config => ActiveRecord::Base.configurations['test'])
+        db_namespace["structure:load"].invoke
+      ensure
+        current_config(:config => nil)
+      end
+    end
+
+    # desc "Recreate the test database from an existent schema.rb file"
+    task :load_schema => 'db:test:purge' do
+      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+      ActiveRecord::Schema.verbose = false
+      db_namespace["schema:load"].invoke
+    end
+
+    # desc "Recreate the test database from a fresh schema.rb file"
+    task :clone => %w(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" ]
+
     # desc "Empty the test database"
-    task :purge => :environment do
+    task :purge => [:environment, :load_config] do
       abcs = ActiveRecord::Base.configurations
       case abcs['test']['adapter']
       when /mysql/
@@ -456,7 +517,7 @@ db_namespace = namespace :db do
         drop_database(abcs['test'])
         create_database(abcs['test'])
       when /sqlite/
-        dbfile = abcs['test']['database'] || abcs['test']['dbfile']
+        dbfile = abcs['test']['database']
         File.delete(dbfile) if File.exist?(dbfile)
       when 'sqlserver'
         test = abcs.deep_dup['test']
@@ -479,7 +540,7 @@ db_namespace = namespace :db do
 
     # desc 'Check for pending migrations and load the test schema'
     task :prepare => 'db:abort_if_pending_migrations' do
-      if defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
+      unless ActiveRecord::Base.configurations.blank?
         db_namespace[{ :sql  => 'test:clone_structure', :ruby => 'test:load' }[ActiveRecord::Base.schema_format]].invoke
       end
     end
@@ -487,16 +548,15 @@ db_namespace = namespace :db do
 
   namespace :sessions do
     # desc "Creates a sessions migration for use with ActiveRecord::SessionStore"
-    task :create => :environment do
+    task :create => [:environment, :load_config] do
       raise 'Task unavailable to this database (no migration support)' unless ActiveRecord::Base.connection.supports_migrations?
-      require 'rails/generators'
-      Rails::Generators.configure!
+      Rails.application.load_generators
       require 'rails/generators/rails/session_migration/session_migration_generator'
       Rails::Generators::SessionMigrationGenerator.start [ ENV['MIGRATION'] || 'add_sessions_table' ]
     end
 
     # desc "Clear the sessions table"
-    task :clear => :environment do
+    task :clear => [:environment, :load_config] do
       ActiveRecord::Base.connection.execute "DELETE FROM #{session_table_name}"
     end
   end
@@ -524,7 +584,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::Migrator.migrations_paths.first, railties,
                                     :on_skip => on_skip, :on_copy => on_copy)
     end
   end
@@ -549,6 +609,20 @@ def drop_database(config)
   end
 end
 
+def drop_database_and_rescue(config)
+  begin
+    drop_database(config)
+  rescue Exception => e
+    $stderr.puts "Couldn't drop #{config['database']} : #{e.inspect}"
+  end
+end
+
+def configs_for_environment
+  environments = [Rails.env]
+  environments << 'test' if Rails.env.development?
+  ActiveRecord::Base.configurations.values_at(*environments).compact.reject { |config| config['database'].blank? }
+end
+
 def session_table_name
   ActiveRecord::SessionStore::Session.table_name
 end
@@ -561,3 +635,10 @@ end
 def firebird_db_string(config)
   FireRuby::Database.db_string_for(config.symbolize_keys)
 end
+
+def set_psql_env(config)
+  ENV['PGHOST']     = config['host']          if config['host']
+  ENV['PGPORT']     = config['port'].to_s     if config['port']
+  ENV['PGPASSWORD'] = config['password'].to_s if config['password']
+  ENV['PGUSER']     = config['username'].to_s if config['username']
+end

data/lib/active_record/railties/jdbcmysql_error.rb

@@ -1,5 +1,5 @@
 #FIXME Remove if ArJdbcMysql will give.
-module ArJdbcMySQL
+module ArJdbcMySQL #:nodoc:
   class Error < StandardError
     attr_accessor :error_number, :sql_state
 

data/lib/active_record/readonly_attributes.rb

@@ -0,0 +1,26 @@
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute'
+
+module ActiveRecord
+  module ReadonlyAttributes
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_attr_readonly, :instance_writer => false
+      self._attr_readonly = []
+    end
+
+    module ClassMethods
+      # 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 || [])
+      end
+
+      # Returns an array of all the attributes that have been specified as readonly.
+      def readonly_attributes
+        self._attr_readonly
+      end
+    end
+  end
+end

data/lib/active_record/reflection.rb

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/module/deprecation'
 require 'active_support/core_ext/object/inclusion'
 
 module ActiveRecord
@@ -125,7 +124,7 @@ module ActiveRecord
       # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
       # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
       def class_name
-        @class_name ||= options[:class_name] || derive_class_name
+        @class_name ||= (options[:class_name] || derive_class_name).to_s
       end
 
       # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
@@ -178,15 +177,9 @@ module ActiveRecord
         @collection = macro.in?([:has_many, :has_and_belongs_to_many])
       end
 
-      # This is a hack so that we can tell if build_association was overridden, in order to
-      # provide an appropriate deprecation if the overridden method ignored the &block. Please
-      # see Association#build_record for details.
-      attr_accessor :original_build_association_called # :nodoc
-
       # Returns a new, unsaved instance of the associated class. +options+ will
       # be passed to the class's constructor.
       def build_association(*options, &block)
-        @original_build_association_called = true
         klass.new(*options, &block)
       end
 
@@ -202,11 +195,6 @@ module ActiveRecord
         @foreign_key ||= options[:foreign_key] || derive_foreign_key
       end
 
-      def primary_key_name
-        foreign_key
-      end
-      deprecate :primary_key_name => :foreign_key
-
       def foreign_type
         @foreign_type ||= options[:foreign_type] || "#{name}_type"
       end
@@ -274,6 +262,10 @@ module ActiveRecord
         [self]
       end
 
+      def nested?
+        false
+      end
+
       # An array of arrays of conditions. Each item in the outside array corresponds to a reflection
       # in the #chain. The inside arrays are simply conditions (and each condition may itself be
       # a hash, array, arel predicate, etc...)
@@ -381,7 +373,7 @@ module ActiveRecord
       delegate :foreign_key, :foreign_type, :association_foreign_key,
                :active_record_primary_key, :type, :to => :source_reflection
 
-      # Gets the source of the through reflection.  It checks both a singularized
+      # Gets the source of the through reflection. It checks both a singularized
       # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
       #
       #   class Post < ActiveRecord::Base
@@ -469,7 +461,7 @@ module ActiveRecord
         source_reflection.source_macro
       end
 
-      # A through association is nested iff there would be more than one join table
+      # A through association is nested if there would be more than one join table
       def nested?
         chain.length > 2 || through_reflection.macro == :has_and_belongs_to_many
       end

data/lib/active_record/relation/batches.rb

@@ -66,11 +66,14 @@ module ActiveRecord
       records = relation.where(table[primary_key].gteq(start)).all
 
       while records.any?
+        records_size = records.size
+        primary_key_offset = records.last.id
+
         yield records
 
-        break if records.size < batch_size
+        break if records_size < batch_size
 
-        if primary_key_offset = records.last.id
+        if primary_key_offset
           records = relation.where(table[primary_key].gt(primary_key_offset)).to_a
         else
           raise "Primary key not included in the custom select clause"