ardb 0.26.0 → 0.27.0

data/lib/ardb/runner.rb

@@ -1,50 +0,0 @@
-require 'ardb'
-
-module Ardb; end
-class Ardb::Runner
-  UnknownCmdError = Class.new(ArgumentError)
-  CmdError = Class.new(RuntimeError)
-  CmdFail = Class.new(RuntimeError)
-
-  attr_reader :cmd_name, :cmd_args, :opts
-
-  def initialize(args, opts)
-    @opts = opts
-    @cmd_name = args.shift || ""
-    @cmd_args = args
-  end
-
-  def run
-    $LOAD_PATH.push(Dir.pwd) unless $LOAD_PATH.include?(Dir.pwd)
-    Ardb.init(false) # don't establish a connection
-
-    case @cmd_name
-    when 'migrate'
-      require 'ardb/runner/migrate_command'
-      MigrateCommand.new.run
-    when 'generate'
-      require 'ardb/runner/generate_command'
-      GenerateCommand.new(@cmd_args).run
-    when 'create'
-      require 'ardb/runner/create_command'
-      CreateCommand.new.run
-    when 'drop'
-      require 'ardb/runner/drop_command'
-      DropCommand.new.run
-    when 'connect'
-      require 'ardb/runner/connect_command'
-      ConnectCommand.new.run
-    when 'null'
-      NullCommand.new.run
-    else
-      raise UnknownCmdError, "unknown command `#{@cmd_name}`"
-    end
-  end
-
-  class NullCommand
-    def run
-      # if this was a real command it would do something here
-    end
-  end
-
-end

data/lib/ardb/runner/connect_command.rb

@@ -1,20 +0,0 @@
-require 'ardb/runner'
-
-class Ardb::Runner::ConnectCommand
-
-  def run
-    begin
-      Ardb.init
-      ActiveRecord::Base.connection
-      $stdout.puts "connected to #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
-    rescue Ardb::Runner::CmdError => e
-      raise e
-    rescue Exception => e
-      $stderr.puts e, *e.backtrace
-      $stderr.puts "error connecting to #{Ardb.config.db.database.inspect} database"\
-                   " with #{Ardb.config.db_settings.inspect}"
-      raise Ardb::Runner::CmdFail
-    end
-  end
-
-end

data/lib/ardb/runner/create_command.rb

@@ -1,25 +0,0 @@
-require 'active_record'
-require 'ardb/runner'
-
-class Ardb::Runner::CreateCommand
-
-  def initialize(out_io = nil, err_io = nil)
-    @out_io = out_io || $stdout
-    @err_io = err_io || $stderr
-    @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
-  end
-
-  def run
-    begin
-      @adapter.create_db
-      @out_io.puts "created #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
-    rescue Ardb::Runner::CmdError => e
-      raise e
-    rescue StandardError => e
-      @err_io.puts e
-      @err_io.puts "error creating #{Ardb.config.db.database.inspect} database"
-      raise Ardb::Runner::CmdFail
-    end
-  end
-
-end

data/lib/ardb/runner/drop_command.rb

@@ -1,25 +0,0 @@
-require 'active_record'
-require 'ardb/runner'
-
-class Ardb::Runner::DropCommand
-
-  def initialize(out_io = nil, err_io = nil)
-    @out_io = out_io || $stdout
-    @err_io = err_io || $stderr
-    @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
-  end
-
-  def run
-    begin
-      @adapter.drop_db
-      @out_io.puts "dropped #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
-    rescue Ardb::Runner::CmdError => e
-      raise e
-    rescue StandardError => e
-      @err_io.puts e
-      @err_io.puts "error dropping #{Ardb.config.db.database.inspect} database"
-      raise Ardb::Runner::CmdFail
-    end
-  end
-
-end

data/lib/ardb/runner/generate_command.rb

@@ -1,64 +0,0 @@
-require 'fileutils'
-require 'active_support/core_ext/string'
-require 'ardb/runner'
-
-class Ardb::Runner::GenerateCommand
-
-  def initialize(args)
-    @item = args.shift
-    @args = args
-  end
-
-  def run
-    if @item.nil?
-      raise Ardb::Runner::CmdError, "specify an item to generate"
-    end
-    if !self.respond_to?("#{@item}_cmd")
-      raise Ardb::Runner::CmdError, "can't generate #{@item}"
-    end
-
-    begin
-      self.send("#{@item}_cmd")
-    rescue Ardb::Runner::CmdError => e
-      raise e
-    rescue Exception => e
-      $stderr.puts e
-      $stderr.puts "error generating #{@item}."
-      raise Ardb::Runner::CmdFail
-    end
-  end
-
-  def migration_cmd
-    MigrationCommand.new(@args.first).run
-  end
-
-  class MigrationCommand
-    attr_reader :identifier, :class_name, :file_name, :template
-
-    def initialize(identifier)
-      if identifier.nil?
-        raise Ardb::Runner::CmdError, "specify a name for the migration"
-      end
-
-      @identifier = identifier
-      @class_name = @identifier.classify.pluralize
-      @file_name  = begin
-        "#{Time.now.strftime("%Y%m%d%H%M%S")}_#{@identifier.underscore}"
-      end
-      @template = "require 'ardb/migration_helpers'\n\n"\
-                  "class #{@class_name} < ActiveRecord::Migration\n"\
-                  "  include Ardb::MigrationHelpers\n\n"\
-                  "  def change\n"\
-                  "  end\n\n"\
-                  "end\n"
-    end
-
-    def run
-      FileUtils.mkdir_p Ardb.config.migrations_path
-      file_path = File.join(Ardb.config.migrations_path, "#{@file_name}.rb")
-      File.open(file_path, "w"){ |f| f.write(@template) }
-      $stdout.puts file_path
-    end
-  end
-
-end

data/lib/ardb/runner/migrate_command.rb

@@ -1,28 +0,0 @@
-require 'fileutils'
-require 'active_record'
-require 'ardb/runner'
-
-class Ardb::Runner::MigrateCommand
-
-  def initialize(out_io = nil, err_io = nil)
-    @out_io = out_io || $stdout
-    @err_io = err_io || $stderr
-    @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
-  end
-
-  def run
-    begin
-      Ardb.init
-      @adapter.migrate_db
-      @adapter.dump_schema unless ENV['ARDB_MIGRATE_NO_SCHEMA']
-    rescue Ardb::Runner::CmdError => e
-      raise e
-    rescue StandardError => e
-      @err_io.puts "error migrating #{Ardb.config.db.database.inspect} database"
-      @err_io.puts e
-      @err_io.puts e.backtrace
-      raise Ardb::Runner::CmdFail
-    end
-  end
-
-end

data/test/unit/runner/connect_command_tests.rb

@@ -1,17 +0,0 @@
-require 'assert'
-require 'ardb/runner/connect_command'
-
-class Ardb::Runner::ConnectCommand
-
-  class UnitTests < Assert::Context
-    desc "Ardb::Runner::ConnectCommand"
-    setup do
-      @cmd = Ardb::Runner::ConnectCommand.new
-    end
-    subject{ @cmd }
-
-    should have_imeths :run
-
-  end
-
-end

data/test/unit/runner/create_command_tests.rb

@@ -1,67 +0,0 @@
-require 'assert'
-require 'ardb/adapter_spy'
-require 'ardb/runner/create_command'
-
-class Ardb::Runner::CreateCommand
-
-  class UnitTests < Assert::Context
-    desc "Ardb::Runner::CreateCommand"
-    setup do
-      @command_class = Ardb::Runner::CreateCommand
-    end
-
-  end
-
-  class InitTests < UnitTests
-    desc "when init"
-    setup do
-      @adapter_spy = Class.new{ include Ardb::AdapterSpy }.new
-      Assert.stub(Ardb::Adapter, Ardb.config.db.adapter.to_sym){ @adapter_spy }
-
-      # provide an output and error IO to avoid using $stdout/$stderr in tests
-      out_io = err_io = StringIO.new
-      @command = @command_class.new(out_io, err_io)
-    end
-    subject{ @command }
-
-    should have_imeths :run
-
-  end
-
-  class RunTests < InitTests
-    desc "and run"
-    setup do
-      @command.run
-    end
-
-    should "create the db via the adapter" do
-      assert_equal true, @adapter_spy.create_db_called?
-    end
-
-  end
-
-  class RunWithCmdErrorTests < InitTests
-    desc "and run with command errors"
-    setup do
-      Assert.stub(@adapter_spy, :create_db){ raise Ardb::Runner::CmdError.new }
-    end
-
-    should "not handle the error" do
-      assert_raises(Ardb::Runner::CmdError){ subject.run }
-    end
-
-  end
-
-  class RunWithUnspecifiedErrorTests < InitTests
-    desc "and run with a standard error"
-    setup do
-      Assert.stub(@adapter_spy, :create_db){ raise StandardError.new }
-    end
-
-    should "raise a CmdFail error" do
-      assert_raises(Ardb::Runner::CmdFail){ subject.run }
-    end
-
-  end
-
-end

data/test/unit/runner/drop_command_tests.rb

@@ -1,68 +0,0 @@
-require 'assert'
-require 'ardb/adapter_spy'
-require 'ardb/runner/drop_command'
-
-class Ardb::Runner::DropCommand
-
-  class UnitTests < Assert::Context
-    desc "Ardb::Runner::DropCommand"
-    setup do
-      @command_class = Ardb::Runner::DropCommand
-    end
-
-  end
-
-  class InitTests < UnitTests
-    desc "when init"
-    setup do
-      @adapter_spy = Class.new{ include Ardb::AdapterSpy }.new
-      Assert.stub(Ardb::Adapter, Ardb.config.db.adapter.to_sym){ @adapter_spy }
-
-      # provide an output and error IO to avoid using $stdout/$stderr in tests
-      out_io = err_io = StringIO.new
-      @command = @command_class.new(out_io, err_io)
-    end
-    subject{ @command }
-
-    should have_imeths :run
-
-  end
-
-  class RunTests < InitTests
-    desc "and run"
-    setup do
-      @command.run
-    end
-
-    should "drop the db via the adapter" do
-      assert_equal true, @adapter_spy.drop_db_called?
-    end
-
-  end
-
-  class RunWithCmdErrorTests < InitTests
-    desc "and run with command errors"
-    setup do
-      Assert.stub(@adapter_spy, :drop_db){ raise Ardb::Runner::CmdError.new }
-    end
-
-    should "not handle the error" do
-      assert_raises(Ardb::Runner::CmdError){ subject.run }
-    end
-
-  end
-
-  class RunWithUnspecifiedErrorTests < InitTests
-    desc "and run with a standard error"
-    setup do
-      Assert.stub(@adapter_spy, :drop_db){ raise StandardError.new }
-    end
-
-    should "raise a CmdFail error" do
-      assert_raises(Ardb::Runner::CmdFail){ subject.run }
-    end
-
-  end
-
-end
-

data/test/unit/runner/generate_command_tests.rb

@@ -1,46 +0,0 @@
-require 'assert'
-require 'ardb/runner/generate_command'
-
-class Ardb::Runner::GenerateCommand
-
-  class UnitTests < Assert::Context
-    desc "Ardb::Runner::GenerateCommand"
-    setup do
-      @cmd = Ardb::Runner::GenerateCommand.new(['something'])
-    end
-    subject{ @cmd }
-
-    should have_imeths :run, :migration_cmd
-
-  end
-
-  class MigrationTests < UnitTests
-    desc "Ardb::Runner::GenerateCommand::MigrationCommand"
-    setup do
-      @cmd = Ardb::Runner::GenerateCommand::MigrationCommand.new('a_migration')
-    end
-
-    should have_readers :identifier, :class_name, :file_name, :template
-
-    should "know its given identifier" do
-      assert_equal 'a_migration', subject.identifier
-    end
-
-    should "know its class name" do
-      assert_equal "AMigrations", subject.class_name
-    end
-
-    should "know its file name" do
-      assert_match /.+_a_migration$/, subject.file_name
-    end
-
-    should "know its template" do
-      assert_includes "require 'ardb/migration_helpers'", subject.template
-      assert_includes "class #{subject.class_name} < ActiveRecord::Migration", subject.template
-      assert_includes "include Ardb::MigrationHelpers", subject.template
-      assert_includes "def change", subject.template
-    end
-
-  end
-
-end

data/test/unit/runner/migrate_command_tests.rb

@@ -1,96 +0,0 @@
-require 'assert'
-require 'ardb/adapter_spy'
-require 'ardb/runner/migrate_command'
-
-class Ardb::Runner::MigrateCommand
-
-  class UnitTests < Assert::Context
-    desc "Ardb::Runner::MigrateCommand"
-    setup do
-      @command_class = Ardb::Runner::MigrateCommand
-    end
-
-  end
-
-  class InitTests < UnitTests
-    desc "when init"
-    setup do
-      @adapter_spy = Class.new{ include Ardb::AdapterSpy }.new
-      Assert.stub(Ardb::Adapter, Ardb.config.db.adapter.to_sym){ @adapter_spy }
-
-      @ardb_init_called = false
-      Assert.stub(Ardb, :init){ @ardb_init_called = true }
-
-      # provide an output and error IO to avoid using $stdout/$stderr in tests
-      out_io = err_io = StringIO.new
-      @command = @command_class.new(out_io, err_io)
-    end
-    subject{ @command }
-
-    should have_imeths :run
-
-  end
-
-  class RunSetupTests < InitTests
-    desc "and run"
-
-  end
-
-  class RunTests < RunSetupTests
-    setup do
-      @command.run
-    end
-
-    should "initialize Ardb, migrate the db and dump schema via the adapter" do
-      assert_true @ardb_init_called
-      assert_true @adapter_spy.migrate_db_called?
-      assert_true @adapter_spy.dump_schema_called?
-    end
-
-  end
-
-  class RunWithNoSchemaEnvVarTests < RunSetupTests
-    desc "with no schema dump env var set"
-    setup do
-      @current_no_schema = ENV['ARDB_MIGRATE_NO_SCHEMA']
-      ENV['ARDB_MIGRATE_NO_SCHEMA'] = 'yes'
-
-      @command.run
-    end
-    teardown do
-      ENV['ARDB_MIGRATE_NO_SCHEMA'] = @current_no_schema
-    end
-
-    should "initialize Ardb and migrate the db but not dump schema" do
-      assert_true  @ardb_init_called
-      assert_true  @adapter_spy.migrate_db_called?
-      assert_false @adapter_spy.dump_schema_called?
-    end
-
-  end
-
-  class RunWithCmdErrorTests < InitTests
-    desc "and run with command errors"
-    setup do
-      Assert.stub(@adapter_spy, :migrate_db){ raise Ardb::Runner::CmdError.new }
-    end
-
-    should "not handle the error" do
-      assert_raises(Ardb::Runner::CmdError){ subject.run }
-    end
-
-  end
-
-  class RunWithUnspecifiedErrorTests < InitTests
-    desc "and run with a standard error"
-    setup do
-      Assert.stub(@adapter_spy, :migrate_db){ raise StandardError.new }
-    end
-
-    should "raise a CmdFail error" do
-      assert_raises(Ardb::Runner::CmdFail){ subject.run }
-    end
-
-  end
-
-end