ardb 0.28.0 → 0.29.1

data/lib/ardb/adapter/base.rb

@@ -1,14 +1,13 @@
-require 'ardb'
+require "ardb"
 
 module Ardb; end
 module Ardb::Adapter
-
   class Base
-
     attr_reader :config
 
     def initialize(config)
       @config = config
+      validate!
     end
 
     def connect_hash;    self.config.activerecord_connect_hash; end
@@ -30,11 +29,9 @@ module Ardb::Adapter
       pattern.gsub!(escape_char){ escape_char * 2 }
       # don't allow custom wildcards
       pattern.gsub!(/%|_/){ |wildcard_char| "#{escape_char}#{wildcard_char}" }
+      pattern
     end
 
-    def foreign_key_add_sql(*args);  raise NotImplementedError; end
-    def foreign_key_drop_sql(*args); raise NotImplementedError; end
-
     def create_db(*args); raise NotImplementedError; end
     def drop_db(*args);   raise NotImplementedError; end
 
@@ -42,33 +39,34 @@ module Ardb::Adapter
 
     def connect_db
       ActiveRecord::Base.establish_connection(self.connect_hash)
-      # checkout a connection to ensure we can connect to the DB, we don't do
+      # checkout a connection to ensure we can connect to the DB, we don"t do
       # anything with the connection and immediately check it back in
       ActiveRecord::Base.connection_pool.with_connection{ }
     end
 
     def migrate_db
-      verbose = ENV["MIGRATE_QUIET"].nil?
-      version = ENV["MIGRATE_VERSION"] ? ENV["MIGRATE_VERSION"].to_i : nil
-
-      if defined?(ActiveRecord::Migration::CommandRecorder)
-        require 'ardb/migration_helpers'
-        ActiveRecord::Migration::CommandRecorder.class_eval do
-          include Ardb::MigrationHelpers::RecorderMixin
-        end
-      end
+      migrate_db_up
+    end
 
-      ActiveRecord::Migrator.migrations_path = self.migrations_path
-      ActiveRecord::Migration.verbose = verbose
-      ActiveRecord::Migrator.migrate(self.migrations_path, version) do |migration|
-        ENV["MIGRATE_SCOPE"].blank? || (ENV["MIGRATE_SCOPE"] == migration.scope)
-      end
+    def migrate_db_up(target_version = nil)
+      migration_context.up(target_version)
+    end
+
+    def migrate_db_down(target_version = nil)
+      migration_context.down(target_version)
+    end
+
+    def migrate_db_forward(steps = 1)
+      migration_context.forward(steps)
+    end
+
+    def migrate_db_backward(steps = 1)
+      migration_context.rollback(steps)
     end
 
     def load_schema
-      # silence STDOUT
-      current_stdout = $stdout.dup
-      $stdout = File.new('/dev/null', 'w')
+      current_stdout = $stdout.dup # silence STDOUT
+      $stdout = File.new("/dev/null", "w")
       load_ruby_schema if self.schema_format == Ardb::Config::RUBY_SCHEMA_FORMAT
       load_sql_schema  if self.schema_format == Ardb::Config::SQL_SCHEMA_FORMAT
       $stdout = current_stdout
@@ -83,18 +81,17 @@ module Ardb::Adapter
     end
 
     def dump_schema
-      # silence STDOUT
-      current_stdout = $stdout.dup
-      $stdout = File.new('/dev/null', 'w')
+      current_stdout = $stdout.dup # silence STDOUT
+      $stdout = File.new("/dev/null", "w")
       dump_ruby_schema
       dump_sql_schema if self.schema_format == Ardb::Config::SQL_SCHEMA_FORMAT
       $stdout = current_stdout
     end
 
     def dump_ruby_schema
-      require 'active_record/schema_dumper'
+      require "active_record/schema_dumper"
       FileUtils.mkdir_p File.dirname(self.ruby_schema_path)
-      File.open(self.ruby_schema_path, 'w:utf-8') do |file|
+      File.open(self.ruby_schema_path, "w:utf-8") do |file|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
       end
     end
@@ -111,6 +108,14 @@ module Ardb::Adapter
       end
     end
 
-  end
+    private
 
+    def validate!
+      # override as needed
+    end
+
+    def migration_context
+      ActiveRecord::MigrationContext.new(migrations_path)
+    end
+  end
 end

data/lib/ardb/adapter/mysql.rb

@@ -1,21 +1,6 @@
-require 'ardb/adapter/base'
+require "ardb/adapter/base"
 
 module Ardb::Adapter
-
-  class Mysql < Base
-
-    def foreign_key_add_sql
-      "ALTER TABLE :from_table"\
-      " ADD CONSTRAINT :name"\
-      " FOREIGN KEY (:from_column)"\
-      " REFERENCES :to_table (:to_column)"
-    end
-
-    def foreign_key_drop_sql
-      "ALTER TABLE :from_table"\
-      " DROP FOREIGN KEY :name"
-    end
-
+  class Mysql < Ardb::Adapter::Base
   end
-
 end

data/lib/ardb/adapter/postgresql.rb

@@ -1,16 +1,14 @@
-require 'ardb/adapter/base'
+require "ardb/adapter/base"
 
 module Ardb::Adapter
-
-  class Postgresql < Base
-
-    # the 'postgres' db is a "public" (doesn't typically require auth/grants to
+  class Postgresql < Ardb::Adapter::Base
+    # the "postgres" db is a "public" (doesn"t typically require auth/grants to
     # connect to) db that typically exists for all postgres installations; the
     # adapter uses it to create/drop other databases
     def public_connect_hash
       @public_connect_hash ||= self.connect_hash.merge({
-        'database'           => 'postgres',
-        'schema_search_path' => 'public'
+        "database"           => "postgres",
+        "schema_search_path" => "public"
       })
     end
 
@@ -42,47 +40,43 @@ module Ardb::Adapter
         tables = conn.execute "SELECT table_name"\
                               " FROM information_schema.tables"\
                               " WHERE table_schema = 'public';"
-        tables.each{ |row| conn.execute "DROP TABLE #{row['table_name']} CASCADE" }
+        tables.each{ |row| conn.execute "DROP TABLE #{row["table_name"]} CASCADE" }
       end
     end
 
-    def foreign_key_add_sql
-      "ALTER TABLE :from_table"\
-      " ADD CONSTRAINT :name"\
-      " FOREIGN KEY (:from_column)"\
-      " REFERENCES :to_table (:to_column)"
-    end
-
-    def foreign_key_drop_sql
-      "ALTER TABLE :from_table"\
-      " DROP CONSTRAINT :name"
-    end
-
     def load_sql_schema
-      require 'scmd'
+      require "scmd"
       cmd_str = "psql -f \"#{self.sql_schema_path}\" #{self.database}"
       cmd = Scmd.new(cmd_str, :env => env_var_hash).tap(&:run)
-      raise 'Error loading database' unless cmd.success?
+      raise "Error loading database" unless cmd.success?
     end
 
     def dump_sql_schema
-      require 'scmd'
+      require "scmd"
       cmd_str = "pg_dump -i -s -x -O -f \"#{self.sql_schema_path}\" #{self.database}"
       cmd = Scmd.new(cmd_str, :env => env_var_hash).tap(&:run)
-      raise 'Error dumping database' unless cmd.success?
+      raise "Error dumping database" unless cmd.success?
     end
 
     private
 
+    def validate!
+      if self.database =~ /\W/
+        raise(
+          Ardb::ConfigurationError,
+          "database value must not contain non-word characters. "\
+          "Given: #{self.database.inspect}."
+        )
+      end
+    end
+
     def env_var_hash
       @env_var_hash ||= {
-        'PGHOST'     => self.connect_hash['host'],
-        'PGPORT'     => self.connect_hash['port'],
-        'PGUSER'     => self.connect_hash['username'],
-        'PGPASSWORD' => self.connect_hash['password']
+        "PGHOST"     => self.connect_hash["host"],
+        "PGPORT"     => self.connect_hash["port"],
+        "PGUSER"     => self.connect_hash["username"],
+        "PGPASSWORD" => self.connect_hash["password"]
       }
     end
-
   end
-
 end

data/lib/ardb/adapter/sqlite.rb

@@ -1,11 +1,9 @@
-require 'fileutils'
-require 'ardb'
-require 'ardb/adapter/base'
+require "fileutils"
+require "ardb"
+require "ardb/adapter/base"
 
 module Ardb::Adapter
-
-  class Sqlite < Base
-
+  class Sqlite < Ardb::Adapter::Base
     def db_file_path
       File.expand_path(self.database, self.config.root_path)
     end
@@ -25,7 +23,5 @@ module Ardb::Adapter
     def drop_db
       FileUtils.rm(self.db_file_path) if File.exist?(self.db_file_path)
     end
-
   end
-
 end

data/lib/ardb/adapter_spy.rb

@@ -1,10 +1,8 @@
-require 'ardb'
-require 'ardb/adapter/base'
+require "ardb"
+require "ardb/adapter/base"
 
 module Ardb
-
   class AdapterSpy < Ardb::Adapter::Base
-
     attr_accessor :drop_tables_called_count
     attr_accessor :dump_schema_called_count, :load_schema_called_count
     attr_accessor :drop_db_called_count, :create_db_called_count
@@ -51,16 +49,6 @@ module Ardb
 
     # Overwritten `Adapter::Base` methods
 
-    def foreign_key_add_sql
-      "FAKE ADD FOREIGN KEY SQL :from_table :from_column " \
-      ":to_table :to_column :name"
-    end
-
-    def foreign_key_drop_sql
-      "FAKE DROP FOREIGN KEY SQL :from_table :from_column " \
-      ":to_table :to_column :name"
-    end
-
     def create_db(*args, &block)
       self.create_db_called_count += 1
     end
@@ -88,7 +76,5 @@ module Ardb
     def dump_schema(*args, &block)
       self.dump_schema_called_count += 1
     end
-
   end
-
 end

data/lib/ardb/cli.rb

@@ -1,17 +1,19 @@
-require 'ardb/cli/clirb'
-require 'ardb/cli/commands'
-require 'ardb/version'
+require "ardb/cli/clirb"
+require "ardb/cli/commands"
+require "ardb/version"
 
 module Ardb
-
   class CLI
-
     COMMANDS = CommandSet.new{ |unknown| InvalidCommand.new(unknown) }.tap do |c|
-      c.add(ConnectCommand,           'connect')
-      c.add(CreateCommand,            'create')
-      c.add(DropCommand,              'drop')
-      c.add(MigrateCommand,           'migrate')
-      c.add(GenerateMigrationCommand, 'generate-migration')
+      c.add(ConnectCommand)
+      c.add(CreateCommand)
+      c.add(DropCommand)
+      c.add(GenerateMigrationCommand)
+      c.add(MigrateCommand)
+      c.add(MigrateUpCommand)
+      c.add(MigrateDownCommand)
+      c.add(MigrateForwardCommand)
+      c.add(MigrateBackwardCommand)
     end
 
     def self.run(args)
@@ -32,13 +34,13 @@ module Ardb
         cmd = COMMANDS[cmd_name]
         cmd.run(args)
       rescue CLIRB::HelpExit
-        @stdout.puts cmd.help
+        @stdout.puts cmd.command_help
       rescue CLIRB::VersionExit
         @stdout.puts Ardb::VERSION
       rescue CLIRB::Error, ArgumentError, InvalidCommandError => exception
         display_debug(exception)
         @stderr.puts "#{exception.message}\n\n"
-        @stdout.puts cmd.help
+        @stdout.puts cmd.command_help
         @kernel.exit 1
       rescue CommandExitError
         @kernel.exit 1
@@ -53,12 +55,10 @@ module Ardb
     private
 
     def display_debug(exception)
-      if ENV['DEBUG']
+      if ENV["DEBUG"]
         @stderr.puts "#{exception.class}: #{exception.message}"
         @stderr.puts exception.backtrace.join("\n")
       end
     end
-
   end
-
 end

data/lib/ardb/cli/clirb.rb

@@ -1,20 +1,19 @@
 module Ardb; end
 class Ardb::CLI
-
-  class CLIRB  # Version 1.0.0, https://github.com/redding/cli.rb
+  class CLIRB  # Version 1.1.0, https://github.com/redding/cli.rb
     Error    = Class.new(RuntimeError);
     HelpExit = Class.new(RuntimeError); VersionExit = Class.new(RuntimeError)
     attr_reader :argv, :args, :opts, :data
 
     def initialize(&block)
       @options = []; instance_eval(&block) if block
-      require 'optparse'
+      require "optparse"
       @data, @args, @opts = [], [], {}; @parser = OptionParser.new do |p|
-        p.banner = ''; @options.each do |o|
+        p.banner = ""; @options.each do |o|
           @opts[o.name] = o.value; p.on(*o.parser_args){ |v| @opts[o.name] = v }
         end
-        p.on_tail('--version', ''){ |v| raise VersionExit, v.to_s }
-        p.on_tail('--help',    ''){ |v| raise HelpExit,    v.to_s }
+        p.on_tail("--version", ""){ |v| raise VersionExit, v.to_s }
+        p.on_tail("--help",    ""){ |v| raise HelpExit,    v.to_s }
       end
     end
 
@@ -27,33 +26,31 @@ class Ardb::CLI
     end
     def to_s; @parser.to_s; end
     def inspect
-      "#<#{self.class}:#{'0x0%x' % (object_id << 1)} @data=#{@data.inspect}>"
+      "#<#{self.class}:#{"0x0%x" % (object_id << 1)} @data=#{@data.inspect}>"
     end
 
     class Option
       attr_reader :name, :opt_name, :desc, :abbrev, :value, :klass, :parser_args
 
-      def initialize(name, *args)
-        settings, @desc = args.last.kind_of?(::Hash) ? args.pop : {}, args.pop || ''
-        @name, @opt_name, @abbrev = parse_name_values(name, settings[:abbrev])
-        @value, @klass = gvalinfo(settings[:value])
+      def initialize(name, desc = nil, abbrev: nil, value: nil)
+        @name, @desc = name, desc || ""
+        @opt_name, @abbrev = parse_name_values(name, abbrev)
+        @value, @klass = gvalinfo(value)
         @parser_args = if [TrueClass, FalseClass, NilClass].include?(@klass)
           ["-#{@abbrev}", "--[no-]#{@opt_name}", @desc]
         else
-          ["-#{@abbrev}", "--#{@opt_name} #{@opt_name.upcase}", @klass, @desc]
+          ["-#{@abbrev}", "--#{@opt_name} VALUE", @klass, @desc]
         end
       end
 
       private
 
       def parse_name_values(name, custom_abbrev)
-        [ (processed_name = name.to_s.strip.downcase), processed_name.gsub('_', '-'),
-          custom_abbrev || processed_name.gsub(/[^a-z]/, '').chars.first || 'a'
+        [ (processed_name = name.to_s.strip.downcase).gsub("_", "-"),
+          custom_abbrev || processed_name.gsub(/[^a-z]/, "").chars.first || "a"
         ]
       end
-      def gvalinfo(v); v.kind_of?(Class) ? [nil,gklass(v)] : [v,gklass(v.class)]; end
-      def gklass(k); k == Fixnum ? Integer : k; end
+      def gvalinfo(v); v.kind_of?(Class) ? [nil,v] : [v,v.class]; end
     end
   end
-
 end

data/lib/ardb/cli/commands.rb

@@ -1,15 +1,13 @@
-require 'ardb'
-require 'ardb/cli/clirb'
-require 'much-plugin'
+require "ardb"
+require "ardb/cli/clirb"
+require "much-plugin"
 
 module Ardb; end
 class Ardb::CLI
-
   InvalidCommandError = Class.new(ArgumentError)
   CommandExitError    = Class.new(RuntimeError)
 
   class InvalidCommand
-
     attr_reader :name, :clirb
 
     def initialize(name)
@@ -22,27 +20,26 @@ class Ardb::CLI
     def run(argv)
       @clirb.parse!([@name, argv].flatten.compact)
       raise CLIRB::HelpExit if @name.to_s.empty?
-      raise InvalidCommandError, "'#{self.name}' is not a command."
+      raise InvalidCommandError, "\"#{self.name}\" is not a command."
     end
 
-    def help
+    def command_help
       "Usage: ardb [COMMAND] [options]\n\n" \
       "Options: #{@clirb}\n" \
       "Commands:\n" \
       "#{COMMANDS.to_s.split("\n").map{ |l| "  #{l}" }.join("\n")}\n"
     end
-
   end
 
   module ValidCommand
     include MuchPlugin
 
-    plugin_included do
-      include InstanceMethods
+    plugin_class_methods do
+      def command_name;    raise NotImplementedError; end
+      def command_summary; "";                        end
     end
 
-    module InstanceMethods
-
+    plugin_instance_methods do
       def initialize(&clirb_build)
         @clirb = CLIRB.new(&clirb_build)
       end
@@ -55,24 +52,34 @@ class Ardb::CLI
         @stderr = stderr || $stderr
       end
 
-      def summary
-        ''
-      end
+      def command_name;    self.class.command_name;    end
+      def command_summary; self.class.command_summary; end
 
+      def command_help
+        "Usage: ardb #{self.command_name} [options]\n\n" \
+        "Options: #{self.clirb}\n" \
+        "Description:\n" \
+        "  #{self.command_summary}"
+      end
     end
-
   end
 
   class ConnectCommand
     include ValidCommand
 
+    def self.command_name;    "connect";                      end
+    def self.command_summary; "Connect to the configured DB"; end
+
     def run(argv, *args)
       super
 
-      Ardb.init(false)
       begin
+        Ardb.init(false)
         Ardb.adapter.connect_db
-        @stdout.puts "connected to #{Ardb.config.adapter} db `#{Ardb.config.database}`"
+        @stdout.puts "connected to #{Ardb.config.adapter} db #{Ardb.config.database.inspect}"
+      rescue ActiveRecord::NoDatabaseError => e
+        @stderr.puts "error: database #{Ardb.config.database.inspect} "\
+                     "does not exist"
       rescue StandardError => e
         @stderr.puts e
         @stderr.puts e.backtrace.join("\n")
@@ -81,150 +88,237 @@ class Ardb::CLI
         raise CommandExitError
       end
     end
-
-    def summary
-      "Connect to the configured DB"
-    end
-
-    def help
-      "Usage: ardb connect [options]\n\n" \
-      "Options: #{@clirb}\n" \
-      "Description:\n" \
-      "  #{self.summary}"
-    end
-
   end
 
   class CreateCommand
     include ValidCommand
 
+    def self.command_name;    "create";                   end
+    def self.command_summary; "Create the configured DB"; end
+
     def run(argv, *args)
       super
 
-      Ardb.init(false)
       begin
+        Ardb.init(false)
         Ardb.adapter.create_db
-        @stdout.puts "created #{Ardb.config.adapter} db `#{Ardb.config.database}`"
+        @stdout.puts "created #{Ardb.config.adapter} db #{Ardb.config.database.inspect}"
+      rescue ActiveRecord::StatementInvalid => e
+        @stderr.puts "error: database #{Ardb.config.database.inspect} "\
+                     "already exists"
       rescue StandardError => e
         @stderr.puts e
         @stderr.puts "error creating #{Ardb.config.database.inspect} database"
         raise CommandExitError
       end
     end
-
-    def summary
-      "Create the configured DB"
-    end
-
-    def help
-      "Usage: ardb create [options]\n\n" \
-      "Options: #{@clirb}\n" \
-      "Description:\n" \
-      "  #{self.summary}"
-    end
-
   end
 
   class DropCommand
     include ValidCommand
 
+    def self.command_name;    "drop";                   end
+    def self.command_summary; "Drop the configured DB"; end
+
     def run(argv, *args)
       super
 
-      Ardb.init(true)
       begin
+        Ardb.init(true)
         Ardb.adapter.drop_db
-        @stdout.puts "dropped #{Ardb.config.adapter} db `#{Ardb.config.database}`"
+        @stdout.puts "dropped #{Ardb.config.adapter} db #{Ardb.config.database.inspect}"
+      rescue ActiveRecord::NoDatabaseError => e
+        @stderr.puts "error: database #{Ardb.config.database.inspect} "\
+                     "does not exist"
       rescue StandardError => e
         @stderr.puts e
         @stderr.puts "error dropping #{Ardb.config.database.inspect} database"
         raise CommandExitError
       end
     end
-
-    def summary
-      "Drop the configured DB"
-    end
-
-    def help
-      "Usage: ardb drop [options]\n\n" \
-      "Options: #{@clirb}\n" \
-      "Description:\n" \
-      "  #{self.summary}"
-    end
-
   end
 
-  class MigrateCommand
+  class GenerateMigrationCommand
     include ValidCommand
 
+    def self.command_name;    "generate-migration";                       end
+    def self.command_summary; "Generate a MIGRATION-NAME migration file"; end
+
     def run(argv, *args)
       super
 
-      Ardb.init(true)
       begin
-        Ardb.adapter.migrate_db
-        Ardb.adapter.dump_schema unless ENV['ARDB_MIGRATE_NO_SCHEMA']
+        Ardb.init(false)
+
+        require "ardb/migration"
+        migration = Ardb::Migration.new(Ardb.config, @clirb.args.first)
+        migration.save!
+        @stdout.puts "generated #{migration.file_path}"
+      rescue Ardb::Migration::NoIdentifierError => exception
+        error = ArgumentError.new("MIGRATION-NAME must be provided")
+        error.set_backtrace(exception.backtrace)
+        raise error
       rescue StandardError => e
         @stderr.puts e
         @stderr.puts e.backtrace.join("\n")
-        @stderr.puts "error migrating #{Ardb.config.database.inspect} database"
+        @stderr.puts "error generating migration"
         raise CommandExitError
       end
     end
 
-    def summary
-      "Migrate the configured DB"
+    def command_help
+      "Usage: ardb #{self.command_name} MIGRATION-NAME [options]\n\n" \
+      "Options: #{self.clirb}\n" \
+      "Description:\n" \
+      "  #{self.command_summary}"
     end
+  end
 
-    def help
-      "Usage: ardb migrate [options]\n\n" \
-      "Options: #{@clirb}\n" \
-      "Description:\n" \
-      "  #{self.summary}"
+  module MigrateCommandBehaviors
+    include MuchPlugin
+
+    plugin_included do
+      include ValidCommand
     end
 
+    plugin_instance_methods do
+      def migrate; raise NotImplementedError; end
+
+      def run(argv, *args)
+        super
+
+        begin
+          Ardb.init(true)
+          self.migrate
+          Ardb.adapter.dump_schema unless ENV["ARDB_MIGRATE_NO_SCHEMA"]
+        rescue ActiveRecord::NoDatabaseError => e
+          @stderr.puts "error: database #{Ardb.config.database.inspect} "\
+                       "does not exist"
+        rescue StandardError => e
+          @stderr.puts e
+          @stderr.puts e.backtrace.join("\n")
+          @stderr.puts "error migrating #{Ardb.config.database.inspect} database"
+          raise CommandExitError
+        end
+      end
+    end
   end
 
-  class GenerateMigrationCommand
-    include ValidCommand
+  class MigrateCommand
+    include MigrateCommandBehaviors
 
-    def run(argv, *args)
-      super
+    def self.command_name;    "migrate";                   end
+    def self.command_summary; "Migrate the configured DB"; end
 
-      Ardb.init(false)
-      begin
-        require 'ardb/migration'
-        migration = Ardb::Migration.new(Ardb.config, @clirb.args.first)
-        migration.save!
-        @stdout.puts "generated #{migration.file_path}"
-      rescue Ardb::Migration::NoIdentifierError => exception
-        error = ArgumentError.new("MIGRATION-NAME must be provided")
-        error.set_backtrace(exception.backtrace)
-        raise error
-      rescue StandardError => e
-        @stderr.puts e
-        @stderr.puts e.backtrace.join("\n")
-        @stderr.puts "error generating migration"
-        raise CommandExitError
+    def migrate
+      Ardb.adapter.migrate_db
+    end
+  end
+
+  module MigrateStyleBehaviors
+    include MuchPlugin
+
+    plugin_included do
+      include MigrateCommandBehaviors
+    end
+
+    plugin_class_methods do
+      def command_style; raise NotImplementedError; end
+
+      def command_name;    "migrate-#{self.command_style}";                   end
+      def command_summary; "Migrate the configured DB #{self.command_style}"; end
+    end
+
+    plugin_instance_methods do
+      def migrate
+        Ardb.adapter.send("migrate_db_#{self.class.command_style}", *migrate_args)
       end
+
+      private
+
+      def migrate_args; raise NotImplementedError; end
     end
+  end
 
-    def summary
-      "Generate a migration file given a MIGRATION-NAME"
+  module MigrateDirectionBehaviors
+    include MuchPlugin
+
+    plugin_included do
+      include MigrateStyleBehaviors
     end
 
-    def help
-      "Usage: ardb generate-migration [options] MIGRATION-NAME\n\n" \
-      "Options: #{@clirb}\n" \
-      "Description:\n" \
-      "  #{self.summary}"
+    plugin_class_methods do
+      def command_style;     self.command_direction;    end
+      def command_direction; raise NotImplementedError; end
+    end
+
+    plugin_instance_methods do
+      def initialize
+        super do
+          option(:target_version, "version to migrate to", value: String)
+        end
+      end
+
+      private
+
+      def migrate_args
+        [@clirb.opts[:target_version]]
+      end
+    end
+  end
+
+  module MigrateStepDirectionBehaviors
+    include MuchPlugin
+
+    plugin_included do
+      include MigrateStyleBehaviors
+    end
+
+    plugin_class_methods do
+      def command_style;     self.command_direction;    end
+      def command_direction; raise NotImplementedError; end
     end
 
+    plugin_instance_methods do
+      def initialize
+        super do
+          option(:steps, "number of migrations to migrate", value: 1)
+        end
+      end
+
+      private
+
+      def migrate_args
+        [@clirb.opts[:steps]]
+      end
+    end
   end
 
-  class CommandSet
+  class MigrateUpCommand
+    include MigrateDirectionBehaviors
+
+    def self.command_direction; "up"; end
+  end
+
+  class MigrateDownCommand
+    include MigrateDirectionBehaviors
 
+    def self.command_direction; "down"; end
+  end
+
+  class MigrateForwardCommand
+    include MigrateStepDirectionBehaviors
+
+    def self.command_direction; "forward"; end
+  end
+
+  class MigrateBackwardCommand
+    include MigrateStepDirectionBehaviors
+
+    def self.command_direction; "backward"; end
+  end
+
+  class CommandSet
     def initialize(&unknown_cmd_block)
       @lookup    = Hash.new{ |h,k| unknown_cmd_block.call(k) }
       @names     = []
@@ -232,29 +326,28 @@ class Ardb::CLI
       @summaries = {}
     end
 
-    def add(klass, name, *aliases)
+    def add(klass)
       begin
         cmd = klass.new
-      rescue StandardError => err
-        # don't add any commands you can't init
+      rescue StandardError
+        # don"t add any commands you can"t initialize
       else
-        ([name] + aliases).each{ |n| @lookup[n] = cmd }
+        @lookup[cmd.command_name] = cmd
         @to_s = nil
-        @names << name
-        @aliases[name] = aliases.empty? ? '' : "(#{aliases.join(', ')})"
-        @summaries[name] = cmd.summary.to_s.empty? ? '' : "# #{cmd.summary}"
+        @names << cmd.command_name
+        @summaries[cmd.command_name] = cmd.command_summary.to_s
       end
     end
 
-    def remove(name)
-      @lookup.delete(name)
-      @names.delete(name)
-      @aliases.delete(name)
+    def remove(klass)
+      @lookup.delete(klass.command_name)
+      @names.delete(klass.command_name)
+      @summaries.delete(klass.command_name)
       @to_s = nil
     end
 
-    def [](name)
-      @lookup[name]
+    def [](cmd_name)
+      @lookup[cmd_name]
     end
 
     def size
@@ -263,13 +356,10 @@ class Ardb::CLI
 
     def to_s
       max_name_size  = @names.map{ |n| n.size }.max || 0
-      max_alias_size = @aliases.values.map{ |v| v.size }.max || 0
 
       @to_s ||= @names.map do |n|
-        "#{n.ljust(max_name_size)} #{@aliases[n].ljust(max_alias_size)} #{@summaries[n]}"
+        "#{n.ljust(max_name_size)} #{@summaries[n]}"
       end.join("\n")
     end
-
   end
-
 end