activerecord 3.2.19 → 5.0.0

data/lib/active_record/tasks/database_tasks.rb

@@ -0,0 +1,313 @@
+require 'active_support/core_ext/string/filters'
+
+module ActiveRecord
+  module Tasks # :nodoc:
+    class DatabaseAlreadyExists < StandardError; end # :nodoc:
+    class DatabaseNotSupported < StandardError; end # :nodoc:
+
+    # ActiveRecord::Tasks::DatabaseTasks is a utility class, which encapsulates
+    # logic behind common tasks used to manage database and migrations.
+    #
+    # The tasks defined here are used with Rake tasks provided by Active Record.
+    #
+    # In order to use DatabaseTasks, a few config values need to be set. All the needed
+    # config values are set by Rails already, so it's necessary to do it only if you
+    # want to change the defaults or when you want to use Active Record outside of Rails
+    # (in such case after configuring the database tasks, you can also use the rake tasks
+    # defined in Active Record).
+    #
+    # The possible config values are:
+    #
+    # * +env+: current environment (like Rails.env).
+    # * +database_configuration+: configuration of your databases (as in +config/database.yml+).
+    # * +db_dir+: your +db+ directory.
+    # * +fixtures_path+: a path to fixtures directory.
+    # * +migrations_paths+: a list of paths to directories with migrations.
+    # * +seed_loader+: an object which will load seeds, it needs to respond to the +load_seed+ method.
+    # * +root+: a path to the root of the application.
+    #
+    # Example usage of DatabaseTasks outside Rails could look as such:
+    #
+    #   include ActiveRecord::Tasks
+    #   DatabaseTasks.database_configuration = YAML.load_file('my_database_config.yml')
+    #   DatabaseTasks.db_dir = 'db'
+    #   # other settings...
+    #
+    #   DatabaseTasks.create_current('production')
+    module DatabaseTasks
+      extend self
+
+      attr_writer :current_config, :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
+      attr_accessor :database_configuration
+
+      LOCAL_HOSTS    = ['127.0.0.1', 'localhost']
+
+      def check_protected_environments!
+        unless ENV['DISABLE_DATABASE_ENVIRONMENT_CHECK']
+          current = ActiveRecord::Migrator.current_environment
+          stored  = ActiveRecord::Migrator.last_stored_environment
+
+          if ActiveRecord::Migrator.protected_environment?
+            raise ActiveRecord::ProtectedEnvironmentError.new(stored)
+          end
+
+          if stored && stored != current
+            raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
+          end
+        end
+      rescue ActiveRecord::NoDatabaseError
+      end
+
+      def register_task(pattern, task)
+        @tasks ||= {}
+        @tasks[pattern] = task
+      end
+
+      register_task(/mysql/,        ActiveRecord::Tasks::MySQLDatabaseTasks)
+      register_task(/postgresql/,   ActiveRecord::Tasks::PostgreSQLDatabaseTasks)
+      register_task(/sqlite/,       ActiveRecord::Tasks::SQLiteDatabaseTasks)
+
+      def db_dir
+        @db_dir ||= Rails.application.config.paths["db"].first
+      end
+
+      def migrations_paths
+        @migrations_paths ||= Rails.application.paths['db/migrate'].to_a
+      end
+
+      def fixtures_path
+        @fixtures_path ||= if ENV['FIXTURES_PATH']
+                             File.join(root, ENV['FIXTURES_PATH'])
+                           else
+                             File.join(root, 'test', 'fixtures')
+                           end
+      end
+
+      def root
+        @root ||= Rails.root
+      end
+
+      def env
+        @env ||= Rails.env
+      end
+
+      def seed_loader
+        @seed_loader ||= Rails.application
+      end
+
+      def current_config(options = {})
+        options.reverse_merge! :env => env
+        if options.has_key?(:config)
+          @current_config = options[:config]
+        else
+          @current_config ||= ActiveRecord::Base.configurations[options[:env]]
+        end
+      end
+
+      def create(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration['adapter']).new(*arguments).create
+        $stdout.puts "Created database '#{configuration['database']}'"
+      rescue DatabaseAlreadyExists
+        $stderr.puts "Database '#{configuration['database']}' already exists"
+      rescue Exception => error
+        $stderr.puts error
+        $stderr.puts "Couldn't create database for #{configuration.inspect}"
+        raise
+      end
+
+      def create_all
+        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
+        each_local_configuration { |configuration| create configuration }
+        if old_pool
+          ActiveRecord::Base.connection_handler.establish_connection(old_pool.spec)
+        end
+      end
+
+      def create_current(environment = env)
+        each_current_configuration(environment) { |configuration|
+          create configuration
+        }
+        ActiveRecord::Base.establish_connection(environment.to_sym)
+      end
+
+      def drop(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration['adapter']).new(*arguments).drop
+        $stdout.puts "Dropped database '#{configuration['database']}'"
+      rescue ActiveRecord::NoDatabaseError
+        $stderr.puts "Database '#{configuration['database']}' does not exist"
+      rescue Exception => error
+        $stderr.puts error
+        $stderr.puts "Couldn't drop database '#{configuration['database']}'"
+        raise
+      end
+
+      def drop_all
+        each_local_configuration { |configuration| drop configuration }
+      end
+
+      def drop_current(environment = env)
+        each_current_configuration(environment) { |configuration|
+          drop configuration
+        }
+      end
+
+      def migrate
+        verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+        scope   = ENV['SCOPE']
+        verbose_was, Migration.verbose = Migration.verbose, verbose
+        Migrator.migrate(migrations_paths, version) do |migration|
+          scope.blank? || scope == migration.scope
+        end
+        ActiveRecord::Base.clear_cache!
+      ensure
+        Migration.verbose = verbose_was
+      end
+
+      def charset_current(environment = env)
+        charset ActiveRecord::Base.configurations[environment]
+      end
+
+      def charset(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration['adapter']).new(*arguments).charset
+      end
+
+      def collation_current(environment = env)
+        collation ActiveRecord::Base.configurations[environment]
+      end
+
+      def collation(*arguments)
+        configuration = arguments.first
+        class_for_adapter(configuration['adapter']).new(*arguments).collation
+      end
+
+      def purge(configuration)
+        class_for_adapter(configuration['adapter']).new(configuration).purge
+      end
+
+      def purge_all
+        each_local_configuration { |configuration|
+          purge configuration
+        }
+      end
+
+      def purge_current(environment = env)
+        each_current_configuration(environment) { |configuration|
+          purge configuration
+        }
+        ActiveRecord::Base.establish_connection(environment.to_sym)
+      end
+
+      def structure_dump(*arguments)
+        configuration = arguments.first
+        filename = arguments.delete_at 1
+        class_for_adapter(configuration['adapter']).new(*arguments).structure_dump(filename)
+      end
+
+      def structure_load(*arguments)
+        configuration = arguments.first
+        filename = arguments.delete_at 1
+        class_for_adapter(configuration['adapter']).new(*arguments).structure_load(filename)
+      end
+
+      def load_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+        file ||= schema_file(format)
+
+        case format
+        when :ruby
+          check_schema_file(file)
+          ActiveRecord::Base.establish_connection(configuration)
+          load(file)
+        when :sql
+          check_schema_file(file)
+          structure_load(configuration, file)
+        else
+          raise ArgumentError, "unknown format #{format.inspect}"
+        end
+        ActiveRecord::InternalMetadata.create_table
+        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+      end
+
+      def load_schema_for(*args)
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          This method was renamed to `#load_schema` and will be removed in the future.
+          Use `#load_schema` instead.
+        MSG
+        load_schema(*args)
+      end
+
+      def schema_file(format = ActiveRecord::Base.schema_format)
+        case format
+        when :ruby
+          File.join(db_dir, "schema.rb")
+        when :sql
+          File.join(db_dir, "structure.sql")
+        end
+      end
+
+      def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
+        each_current_configuration(environment) { |configuration|
+          load_schema configuration, format, file
+        }
+        ActiveRecord::Base.establish_connection(environment.to_sym)
+      end
+
+      def check_schema_file(filename)
+        unless File.exist?(filename)
+          message = %{#{filename} doesn't exist yet. Run `rails db:migrate` to create it, then try again.}
+          message << %{ 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.} if defined?(::Rails)
+          Kernel.abort message
+        end
+      end
+
+      def load_seed
+        if seed_loader
+          seed_loader.load_seed
+        else
+          raise "You tried to load seed data, but no seed loader is specified. Please specify seed " +
+                "loader with ActiveRecord::Tasks::DatabaseTasks.seed_loader = your_seed_loader\n" +
+                "Seed loader should respond to load_seed method"
+        end
+      end
+
+      private
+
+      def class_for_adapter(adapter)
+        key = @tasks.keys.detect { |pattern| adapter[pattern] }
+        unless key
+          raise DatabaseNotSupported, "Rake tasks not supported by '#{adapter}' adapter"
+        end
+        @tasks[key]
+      end
+
+      def each_current_configuration(environment)
+        environments = [environment]
+        environments << 'test' if environment == 'development'
+
+        configurations = ActiveRecord::Base.configurations.values_at(*environments)
+        configurations.compact.each do |configuration|
+          yield configuration unless configuration['database'].blank?
+        end
+      end
+
+      def each_local_configuration
+        ActiveRecord::Base.configurations.each_value do |configuration|
+          next unless configuration['database']
+
+          if local_database?(configuration)
+            yield configuration
+          else
+            $stderr.puts "This task only modifies local databases. #{configuration['database']} is on a remote host."
+          end
+        end
+      end
+
+      def local_database?(configuration)
+        configuration['host'].blank? || LOCAL_HOSTS.include?(configuration['host'])
+      end
+    end
+  end
+end

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -0,0 +1,151 @@
+module ActiveRecord
+  module Tasks # :nodoc:
+    class MySQLDatabaseTasks # :nodoc:
+      ACCESS_DENIED_ERROR = 1045
+
+      delegate :connection, :establish_connection, to: ActiveRecord::Base
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def create
+        establish_connection configuration_without_database
+        connection.create_database configuration['database'], creation_options
+        establish_connection configuration
+      rescue ActiveRecord::StatementInvalid => error
+        if /database exists/ === error.message
+          raise DatabaseAlreadyExists
+        else
+          raise
+        end
+      rescue error_class => error
+        if error.respond_to?(:errno) && error.errno == ACCESS_DENIED_ERROR
+          $stdout.print error.message
+          establish_connection root_configuration_without_database
+          connection.create_database configuration['database'], creation_options
+          if configuration['username'] != 'root'
+            connection.execute grant_statement.gsub(/\s+/, ' ').strip
+          end
+          establish_connection configuration
+        else
+          $stderr.puts error.inspect
+          $stderr.puts "Couldn't create database for #{configuration.inspect}, #{creation_options.inspect}"
+          $stderr.puts "(If you set the charset manually, make sure you have a matching collation)" if configuration['encoding']
+        end
+      end
+
+      def drop
+        establish_connection configuration
+        connection.drop_database configuration['database']
+      end
+
+      def purge
+        establish_connection configuration
+        connection.recreate_database configuration['database'], creation_options
+      end
+
+      def charset
+        connection.charset
+      end
+
+      def collation
+        connection.collation
+      end
+
+      def structure_dump(filename)
+        args = prepare_command_options
+        args.concat(["--result-file", "#{filename}"])
+        args.concat(["--no-data"])
+        args.concat(["--routines"])
+        args.concat(["#{configuration['database']}"])
+
+        run_cmd('mysqldump', args, 'dumping')
+      end
+
+      def structure_load(filename)
+        args = prepare_command_options
+        args.concat(['--execute', %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}])
+        args.concat(["--database", "#{configuration['database']}"])
+
+        run_cmd('mysql', args, 'loading')
+      end
+
+      private
+
+      def configuration
+        @configuration
+      end
+
+      def configuration_without_database
+        configuration.merge('database' => nil)
+      end
+
+      def creation_options
+        Hash.new.tap do |options|
+          options[:charset]     = configuration['encoding']   if configuration.include? 'encoding'
+          options[:collation]   = configuration['collation']  if configuration.include? 'collation'
+        end
+      end
+
+      def error_class
+        if configuration['adapter'] =~ /jdbc/
+          require 'active_record/railties/jdbcmysql_error'
+          ArJdbcMySQL::Error
+        elsif defined?(Mysql2)
+          Mysql2::Error
+        else
+          StandardError
+        end
+      end
+
+      def grant_statement
+        <<-SQL
+GRANT ALL PRIVILEGES ON #{configuration['database']}.*
+  TO '#{configuration['username']}'@'localhost'
+IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
+        SQL
+      end
+
+      def root_configuration_without_database
+        configuration_without_database.merge(
+          'username' => 'root',
+          'password' => root_password
+        )
+      end
+
+      def root_password
+        $stdout.print "Please provide the root password for your MySQL installation\n>"
+        $stdin.gets.strip
+      end
+
+      def prepare_command_options
+        args = {
+          'host'      => '--host',
+          'port'      => '--port',
+          'socket'    => '--socket',
+          'username'  => '--user',
+          'password'  => '--password',
+          'encoding'  => '--default-character-set',
+          'sslca'     => '--ssl-ca',
+          'sslcert'   => '--ssl-cert',
+          'sslcapath' => '--ssl-capath',
+          'sslcipher' => '--ssl-cipher',
+          'sslkey'    => '--ssl-key'
+        }.map { |opt, arg| "#{arg}=#{configuration[opt]}" if configuration[opt] }.compact
+
+        args
+      end
+
+      def run_cmd(cmd, args, action)
+        fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+      end
+
+      def run_cmd_error(cmd, args, action)
+        msg = "failed to execute: `#{cmd}`\n"
+        msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+        msg
+      end
+    end
+  end
+end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -0,0 +1,110 @@
+module ActiveRecord
+  module Tasks # :nodoc:
+    class PostgreSQLDatabaseTasks # :nodoc:
+      DEFAULT_ENCODING = ENV['CHARSET'] || 'utf8'
+
+      delegate :connection, :establish_connection, :clear_active_connections!,
+        to: ActiveRecord::Base
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def create(master_established = false)
+        establish_master_connection unless master_established
+        connection.create_database configuration['database'],
+          configuration.merge('encoding' => encoding)
+        establish_connection configuration
+      rescue ActiveRecord::StatementInvalid => error
+        if /database .* already exists/ === error.message
+          raise DatabaseAlreadyExists
+        else
+          raise
+        end
+      end
+
+      def drop
+        establish_master_connection
+        connection.drop_database configuration['database']
+      end
+
+      def charset
+        connection.encoding
+      end
+
+      def collation
+        connection.collation
+      end
+
+      def purge
+        clear_active_connections!
+        drop
+        create true
+      end
+
+      def structure_dump(filename)
+        set_psql_env
+
+        search_path = case ActiveRecord::Base.dump_schemas
+        when :schema_search_path
+          configuration['schema_search_path']
+        when :all
+          nil
+        when String
+          ActiveRecord::Base.dump_schemas
+        end
+
+        args = ['-s', '-x', '-O', '-f', filename]
+        unless search_path.blank?
+          args += search_path.split(',').map do |part|
+            "--schema=#{part.strip}"
+          end
+        end
+        args << configuration['database']
+        run_cmd('pg_dump', args, 'dumping')
+        File.open(filename, "a") { |f| f << "SET search_path TO #{connection.schema_search_path};\n\n" }
+      end
+
+      def structure_load(filename)
+        set_psql_env
+        args = [ '-q', '-f', filename, configuration['database'] ]
+        run_cmd('psql', args, 'loading' )
+      end
+
+      private
+
+      def configuration
+        @configuration
+      end
+
+      def encoding
+        configuration['encoding'] || DEFAULT_ENCODING
+      end
+
+      def establish_master_connection
+        establish_connection configuration.merge(
+          'database'           => 'postgres',
+          'schema_search_path' => 'public'
+        )
+      end
+
+      def set_psql_env
+        ENV['PGHOST']     = configuration['host']          if configuration['host']
+        ENV['PGPORT']     = configuration['port'].to_s     if configuration['port']
+        ENV['PGPASSWORD'] = configuration['password'].to_s if configuration['password']
+        ENV['PGUSER']     = configuration['username'].to_s if configuration['username']
+      end
+
+      def run_cmd(cmd, args, action)
+        fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+      end
+
+      def run_cmd_error(cmd, args, action)
+        msg = "failed to execute:\n"
+        msg << "#{cmd} #{args.join(' ')}\n\n"
+        msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+        msg
+      end
+    end
+  end
+end

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -0,0 +1,59 @@
+module ActiveRecord
+  module Tasks # :nodoc:
+    class SQLiteDatabaseTasks # :nodoc:
+      delegate :connection, :establish_connection, to: ActiveRecord::Base
+
+      def initialize(configuration, root = ActiveRecord::Tasks::DatabaseTasks.root)
+        @configuration, @root = configuration, root
+      end
+
+      def create
+        raise DatabaseAlreadyExists if File.exist?(configuration['database'])
+
+        establish_connection configuration
+        connection
+      end
+
+      def drop
+        require 'pathname'
+        path = Pathname.new configuration['database']
+        file = path.absolute? ? path.to_s : File.join(root, path)
+
+        FileUtils.rm(file)
+      rescue Errno::ENOENT => error
+        raise NoDatabaseError.new(error.message, error)
+      end
+
+      def purge
+        drop
+      rescue NoDatabaseError
+      ensure
+        create
+      end
+
+      def charset
+        connection.encoding
+      end
+
+      def structure_dump(filename)
+        dbfile = configuration['database']
+        `sqlite3 #{dbfile} .schema > #{filename}`
+      end
+
+      def structure_load(filename)
+        dbfile = configuration['database']
+        `sqlite3 #{dbfile} < "#{filename}"`
+      end
+
+      private
+
+      def configuration
+        @configuration
+      end
+
+      def root
+        @root
+      end
+    end
+  end
+end