Merge pull request #316 from arunagw/jdbc_postgresql.

Re-factored database.rake to allow Jdbcpostgresql. #jruby

activerecord/lib/active_record/railties/databases.rake

@@ -4,11 +4,11 @@ db_namespace = namespace :db do
   task :load_config => :rails_env do
     require 'active_record'
     ActiveRecord::Base.configurations = Rails.application.config.database_configuration
-    ActiveRecord::Migrator.migrations_paths = Rails.application.paths["db/migrate"].to_a
+    ActiveRecord::Migrator.migrations_paths = Rails.application.paths['db/migrate'].to_a
 
     if defined?(ENGINE_PATH) && engine = Rails::Engine.find(ENGINE_PATH)
-      if engine.paths["db/migrate"].existent
+      if engine.paths['db/migrate'].existent
-        ActiveRecord::Migrator.migrations_paths += engine.paths["db/migrate"].to_a
+        ActiveRecord::Migrator.migrations_paths += engine.paths['db/migrate'].to_a
       end
     end
   end
@@ -143,7 +143,7 @@ db_namespace = namespace :db do
   end
 
   def local_database?(config, &block)
-    if config['host'].in?(["127.0.0.1", "localhost"]) || config['host'].blank?
+    if config['host'].in?(['127.0.0.1', 'localhost']) || config['host'].blank?
       yield
     else
       $stderr.puts "This task only modifies local databases. #{config['database']} is on a remote host."
@@ -161,35 +161,35 @@ 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
-      if ENV["VERSION"]
+      if ENV['VERSION']
-        db_namespace["migrate:down"].invoke
+        db_namespace['migrate:down'].invoke
-        db_namespace["migrate:up"].invoke
+        db_namespace['migrate:up'].invoke
       else
-        db_namespace["rollback"].invoke
+        db_namespace['rollback'].invoke
-        db_namespace["migrate"].invoke
+        db_namespace['migrate'].invoke
       end
     end
 
     # desc 'Resets your database using your migrations for the current environment'
-    task :reset => ["db:drop", "db:create", "db:migrate"]
+    task :reset => ['db:drop', 'db:create', 'db:migrate']
 
     # desc 'Runs the "up" for a given migration VERSION.'
     task :up => [:environment, :load_config] do
-      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise "VERSION is required" unless version
+      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['schema:dump'].invoke if ActiveRecord::Base.schema_format == :ruby
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
     task :down => [:environment, :load_config] do
-      version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise "VERSION is required" unless version
+      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['schema:dump'].invoke if ActiveRecord::Base.schema_format == :ruby
     end
 
-    desc "Display status of migrations"
+    desc 'Display status of migrations'
     task :status => [:environment, :load_config] do
       config = ActiveRecord::Base.configurations[Rails.env || 'development']
       ActiveRecord::Base.establish_connection(config)
@@ -208,7 +208,7 @@ db_namespace = namespace :db do
       end
       # output
       puts "\ndatabase: #{config['database']}\n\n"
-      puts "#{"Status".center(8)}  #{"Migration ID".ljust(14)}  Migration Name"
+      puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
       puts "-" * 50
       file_list.each do |file|
         puts "#{file[0].center(8)}  #{file[1].ljust(14)}  #{file[2].humanize}"
@@ -224,14 +224,14 @@ 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['schema:dump'].invoke if ActiveRecord::Base.schema_format == :ruby
   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['schema:dump'].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
   # desc 'Drops and recreates the database from db/schema.rb for the current environment and loads the seeds.'
@@ -244,10 +244,10 @@ db_namespace = namespace :db do
     when /mysql/
       ActiveRecord::Base.establish_connection(config)
       puts ActiveRecord::Base.connection.charset
-    when 'postgresql'
+    when /postgresql/
       ActiveRecord::Base.establish_connection(config)
       puts ActiveRecord::Base.connection.encoding
-    when 'sqlite3'
+    when /sqlite/
       ActiveRecord::Base.establish_connection(config)
       puts ActiveRecord::Base.connection.encoding
     else
@@ -267,7 +267,7 @@ db_namespace = namespace :db do
     end
   end
 
-  desc "Retrieves the current schema version number"
+  desc 'Retrieves the current schema version number'
   task :version => :environment do
     puts "Current version: #{ActiveRecord::Migrator.current_version}"
   end
@@ -313,8 +313,8 @@ db_namespace = namespace :db do
     task :identify => :environment do
       require 'active_record/fixtures'
 
-      label, id = ENV["LABEL"], ENV["ID"]
+      label, id = ENV['LABEL'], ENV['ID']
-      raise "LABEL or ID required" if label.blank? && id.blank?
+      raise 'LABEL or ID required' if label.blank? && id.blank?
 
       puts %Q(The fixture ID for "#{label}" is #{Fixtures.identify(label)}.) if label
 
@@ -334,16 +334,16 @@ 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 can be portably used against any DB supported by AR'
     task :dump => :load_config do
       require 'active_record/schema_dumper'
       File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb", "w") do |file|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
       end
-      db_namespace["schema:dump"].reenable
+      db_namespace['schema:dump'].reenable
     end
 
-    desc "Load a schema.rb file into the database"
+    desc 'Load a schema.rb file into the database'
     task :load => :environment do
       file = ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb"
       if File.exists?(file)
@@ -355,29 +355,29 @@ db_namespace = namespace :db do
   end
 
   namespace :structure do
-    desc "Dump the database structure to an SQL file"
+    desc 'Dump the database structure to an SQL file'
     task :dump => :environment do
       abcs = ActiveRecord::Base.configurations
-      case abcs[Rails.env]["adapter"]
+      case abcs[Rails.env]['adapter']
-      when /mysql/, "oci", "oracle"
+      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 }
-      when "postgresql"
+      when /postgresql/
-        ENV['PGHOST']     = abcs[Rails.env]["host"] if abcs[Rails.env]["host"]
+        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['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"]
+        ENV['PGPASSWORD'] = abcs[Rails.env]['password'].to_s if abcs[Rails.env]['password']
-        search_path = abcs[Rails.env]["schema_search_path"]
+        search_path = abcs[Rails.env]['schema_search_path']
         unless search_path.blank?
           search_path = search_path.split(",").map{|search_path| "--schema=#{search_path.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 -U "#{abcs[Rails.env]['username']}" -s -x -O -f db/#{Rails.env}_structure.sql #{search_path} #{abcs[Rails.env]['database']}`
-        raise "Error dumping database" if $?.exitstatus == 1
+        raise 'Error dumping database' if $?.exitstatus == 1
-      when "sqlite", "sqlite3"
+      when /sqlite/
-        dbfile = abcs[Rails.env]["database"] || abcs[Rails.env]["dbfile"]
+        dbfile = abcs[Rails.env]['database'] || abcs[Rails.env]['dbfile']
-        `#{abcs[Rails.env]["adapter"]} #{dbfile} .schema > db/#{Rails.env}_structure.sql`
+        `sqlite3 #{dbfile} .schema > db/#{Rails.env}_structure.sql`
-      when "sqlserver"
+      when 'sqlserver'
-        `scptxfr /s #{abcs[Rails.env]["host"]} /d #{abcs[Rails.env]["database"]} /I /f db\\#{Rails.env}_structure.sql /q /A /r`
+        `scptxfr /s #{abcs[Rails.env]['host']} /d #{abcs[Rails.env]['database']} /I /f db\\#{Rails.env}_structure.sql /q /A /r`
-        `scptxfr /s #{abcs[Rails.env]["host"]} /d #{abcs[Rails.env]["database"]} /I /F db\ /q /A /r`
+        `scptxfr /s #{abcs[Rails.env]['host']} /d #{abcs[Rails.env]['database']} /I /F db\ /q /A /r`
       when "firebird"
         set_firebird_env(abcs[Rails.env])
         db_string = firebird_db_string(abcs[Rails.env])
@@ -397,81 +397,81 @@ db_namespace = namespace :db do
     task :load => 'db:test:purge' do
       ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
       ActiveRecord::Schema.verbose = false
-      db_namespace["schema:load"].invoke
+      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
+    task :clone_structure => [ 'db:structure:dump', 'db:test:purge' ] do
       abcs = ActiveRecord::Base.configurations
-      case abcs["test"]["adapter"]
+      case abcs['test']['adapter']
       when /mysql/
         ActiveRecord::Base.establish_connection(:test)
         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|
           ActiveRecord::Base.connection.execute(table)
         end
-      when "postgresql"
+      when /postgresql/
-        ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+        ENV['PGHOST']     = abcs['test']['host'] if abcs['test']['host']
-        ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+        ENV['PGPORT']     = abcs['test']['port'].to_s if abcs['test']['port']
-        ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+        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"]}`
+        `psql -U "#{abcs['test']['username']}" -f #{Rails.root}/db/#{Rails.env}_structure.sql #{abcs['test']['database']} #{abcs['test']['template']}`
-      when "sqlite", "sqlite3"
+      when /sqlite/
-        dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+        dbfile = abcs['test']['database'] || abcs['test']['dbfile']
-        `#{abcs["test"]["adapter"]} #{dbfile} < #{Rails.root}/db/#{Rails.env}_structure.sql`
+        `sqlite3 #{dbfile} < #{Rails.root}/db/#{Rails.env}_structure.sql`
-      when "sqlserver"
+      when 'sqlserver'
-        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{Rails.env}_structure.sql`
+        `osql -E -S #{abcs['test']['host']} -d #{abcs['test']['database']} -i db\\#{Rails.env}_structure.sql`
-      when "oci", "oracle"
+      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.connection.execute(ddl)
         end
-      when "firebird"
+      when 'firebird'
-        set_firebird_env(abcs["test"])
+        set_firebird_env(abcs['test'])
-        db_string = firebird_db_string(abcs["test"])
+        db_string = firebird_db_string(abcs['test'])
         sh "isql -i #{Rails.root}/db/#{Rails.env}_structure.sql #{db_string}"
       else
-        raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+        raise "Task not supported by '#{abcs['test']['adapter']}'"
       end
     end
 
     # desc "Empty the test database"
     task :purge => :environment do
       abcs = ActiveRecord::Base.configurations
-      case abcs["test"]["adapter"]
+      case abcs['test']['adapter']
       when /mysql/
         ActiveRecord::Base.establish_connection(:test)
-        ActiveRecord::Base.connection.recreate_database(abcs["test"]["database"], abcs["test"])
+        ActiveRecord::Base.connection.recreate_database(abcs['test']['database'], abcs['test'])
-      when "postgresql"
+      when /postgresql/
         ActiveRecord::Base.clear_active_connections!
         drop_database(abcs['test'])
         create_database(abcs['test'])
-      when "sqlite","sqlite3"
+      when /sqlite/
-        dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+        dbfile = abcs['test']['database'] || abcs['test']['dbfile']
         File.delete(dbfile) if File.exist?(dbfile)
-      when "sqlserver"
+      when 'sqlserver'
-        dropfkscript = "#{abcs["test"]["host"]}.#{abcs["test"]["database"]}.DP1".gsub(/\\/,'-')
+        dropfkscript = "#{abcs['test']['host']}.#{abcs['test']['database']}.DP1".gsub(/\\/,'-')
-        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{dropfkscript}`
+        `osql -E -S #{abcs['test']['host']} -d #{abcs['test']['database']} -i db\\#{dropfkscript}`
-        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{Rails.env}_structure.sql`
+        `osql -E -S #{abcs['test']['host']} -d #{abcs['test']['database']} -i db\\#{Rails.env}_structure.sql`
       when "oci", "oracle"
         ActiveRecord::Base.establish_connection(:test)
         ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
           ActiveRecord::Base.connection.execute(ddl)
         end
-      when "firebird"
+      when 'firebird'
         ActiveRecord::Base.establish_connection(:test)
         ActiveRecord::Base.connection.recreate_database!
       else
-        raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+        raise "Task not supported by '#{abcs['test']['adapter']}'"
       end
     end
 
     # 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?
-        db_namespace[{ :sql  => "test:clone_structure", :ruby => "test:load" }[ActiveRecord::Base.schema_format]].invoke
+        db_namespace[{ :sql  => 'test:clone_structure', :ruby => 'test:load' }[ActiveRecord::Base.schema_format]].invoke
       end
     end
   end
@@ -479,11 +479,11 @@ db_namespace = namespace :db do
   namespace :sessions do
     # desc "Creates a sessions migration for use with ActiveRecord::SessionStore"
     task :create => :environment do
-      raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
+      raise 'Task unavailable to this database (no migration support)' unless ActiveRecord::Base.connection.supports_migrations?
       require 'rails/generators'
       Rails::Generators.configure!
       require 'rails/generators/rails/session_migration/session_migration_generator'
-      Rails::Generators::SessionMigrationGenerator.start [ ENV["MIGRATION"] || "add_sessions_table" ]
+      Rails::Generators::SessionMigrationGenerator.start [ ENV['MIGRATION'] || 'add_sessions_table' ]
     end
 
     # desc "Clear the sessions table"
@@ -496,13 +496,13 @@ end
 namespace :railties do
   namespace :install do
     # desc "Copies missing migrations from Railties (e.g. plugins, engines). You can specify Railties to use with FROM=railtie1,railtie2"
-    task :migrations => :"db:load_config" do
+    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 {|n| n.strip }
       railties = {}
       Rails.application.railties.all do |railtie|
         next unless to_load == :all || to_load.include?(railtie.railtie_name)
 
-        if railtie.respond_to?(:paths) && (path = railtie.paths["db/migrate"].first)
+        if railtie.respond_to?(:paths) && (path = railtie.paths['db/migrate'].first)
           railties[railtie.railtie_name] = path
         end
       end
@@ -528,13 +528,13 @@ def drop_database(config)
   when /mysql/
     ActiveRecord::Base.establish_connection(config)
     ActiveRecord::Base.connection.drop_database config['database']
-  when /^sqlite/
+  when /sqlite/
     require 'pathname'
     path = Pathname.new(config['database'])
     file = path.absolute? ? path.to_s : File.join(Rails.root, path)
 
     FileUtils.rm(file)
-  when 'postgresql'
+  when /postgresql/
     ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
     ActiveRecord::Base.connection.drop_database config['database']
   end
@@ -545,8 +545,8 @@ def session_table_name
 end
 
 def set_firebird_env(config)
-  ENV["ISC_USER"]     = config["username"].to_s if config["username"]
+  ENV['ISC_USER']     = config['username'].to_s if config['username']
-  ENV["ISC_PASSWORD"] = config["password"].to_s if config["password"]
+  ENV['ISC_PASSWORD'] = config['password'].to_s if config['password']
 end
 
 def firebird_db_string(config)