ardb 0.28.3 → 0.30.0

data/lib/ardb/cli/commands.rb

@@ -1,15 +1,16 @@
-require 'ardb'
-require 'ardb/cli/clirb'
-require 'much-plugin'
+# frozen_string_literal: true
+
+require "ardb"
+require "ardb/cli/clirb"
+require "much-mixin"
 
 module Ardb; end
-class Ardb::CLI
 
+class Ardb::CLI
   InvalidCommandError = Class.new(ArgumentError)
   CommandExitError    = Class.new(RuntimeError)
 
   class InvalidCommand
-
     attr_reader :name, :clirb
 
     def initialize(name)
@@ -17,37 +18,45 @@ class Ardb::CLI
       @clirb = CLIRB.new
     end
 
-    def new; self; end
+    def new
+      self
+    end
 
     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, "\"#{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
+    include MuchMixin
 
-    plugin_included do
-      include InstanceMethods
-    end
+    mixin_class_methods do
+      def command_name
+        raise NotImplementedError
+      end
 
-    module InstanceMethods
+      def command_summary
+        ""
+      end
+    end
 
+    mixin_instance_methods do
       def initialize(&clirb_build)
         @clirb = CLIRB.new(&clirb_build)
       end
 
-      def clirb; @clirb; end
+      def clirb
+        @clirb
+      end
 
       def run(argv, stdout = nil, stderr = nil)
         @clirb.parse!(argv)
@@ -55,206 +64,379 @@ class Ardb::CLI
         @stderr = stderr || $stderr
       end
 
-      def summary
-        ''
+      def command_name
+        self.class.command_name
       end
 
-    end
+      def command_summary
+        self.class.command_summary
+      end
 
+      def command_help
+        "Usage: ardb #{command_name} [options]\n\n" \
+        "Options: #{clirb}\n" \
+        "Description:\n" \
+        "  #{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}`"
-      rescue StandardError => e
-        @stderr.puts e
-        @stderr.puts e.backtrace.join("\n")
-        @stderr.puts "error connecting to #{Ardb.config.database.inspect} database " \
-                     "with #{Ardb.config.activerecord_connect_hash.inspect}"
+        @stdout.puts(
+          "connected to #{Ardb.config.adapter} "\
+          "db #{Ardb.config.database.inspect}",
+        )
+      rescue ActiveRecord::NoDatabaseError
+        @stderr.puts(
+          "error: database #{Ardb.config.database.inspect} does not exist",
+        )
+      rescue => ex
+        @stderr.puts ex
+        @stderr.puts ex.backtrace.join("\n")
+        @stderr.puts(
+          "error connecting to #{Ardb.config.database.inspect} database " \
+          "with #{Ardb.config.activerecord_connect_hash.inspect}",
+        )
         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}`"
-      rescue StandardError => e
-        @stderr.puts e
+        @stdout.puts(
+          "created #{Ardb.config.adapter} db #{Ardb.config.database.inspect}",
+        )
+      rescue ActiveRecord::StatementInvalid
+        @stderr.puts(
+          "error: database #{Ardb.config.database.inspect} already exists",
+        )
+      rescue => ex
+        @stderr.puts ex
         @stderr.puts "error creating #{Ardb.config.database.inspect} database"
         raise CommandExitError
       end
     end
+  end
 
-    def summary
-      "Create the configured DB"
+  class DropCommand
+    include ValidCommand
+
+    def self.command_name
+      "drop"
     end
 
-    def help
-      "Usage: ardb create [options]\n\n" \
-      "Options: #{@clirb}\n" \
-      "Description:\n" \
-      "  #{self.summary}"
+    def self.command_summary
+      "Drop the configured DB"
     end
 
+    def run(argv, *args)
+      super
+
+      begin
+        Ardb.init(true)
+        Ardb.adapter.drop_db
+        @stdout.puts(
+          "dropped #{Ardb.config.adapter} db #{Ardb.config.database.inspect}",
+        )
+      rescue ActiveRecord::NoDatabaseError
+        @stderr.puts(
+          "error: database #{Ardb.config.database.inspect} does not exist",
+        )
+      rescue => ex
+        @stderr.puts ex
+        @stderr.puts "error dropping #{Ardb.config.database.inspect} database"
+        raise CommandExitError
+      end
+    end
   end
 
-  class DropCommand
+  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.drop_db
-        @stdout.puts "dropped #{Ardb.config.adapter} db `#{Ardb.config.database}`"
-      rescue StandardError => e
-        @stderr.puts e
-        @stderr.puts "error dropping #{Ardb.config.database.inspect} database"
+        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 => ex
+        error = ArgumentError.new("MIGRATION-NAME must be provided")
+        error.set_backtrace(ex.backtrace)
+        raise error
+      rescue => ex
+        @stderr.puts ex
+        @stderr.puts ex.backtrace.join("\n")
+        @stderr.puts "error generating migration"
         raise CommandExitError
       end
     end
 
-    def summary
-      "Drop the configured DB"
+    def command_help
+      "Usage: ardb #{command_name} MIGRATION-NAME [options]\n\n" \
+      "Options: #{clirb}\n" \
+      "Description:\n" \
+      "  #{command_summary}"
     end
+  end
 
-    def help
-      "Usage: ardb drop [options]\n\n" \
-      "Options: #{@clirb}\n" \
-      "Description:\n" \
-      "  #{self.summary}"
+  module MigrateCommandBehaviors
+    include MuchMixin
+
+    mixin_included do
+      include ValidCommand
     end
 
+    mixin_instance_methods do
+      def migrate
+        raise NotImplementedError
+      end
+
+      def run(argv, *args)
+        super
+
+        begin
+          Ardb.init(true)
+          migrate
+          Ardb.adapter.dump_schema unless ENV["ARDB_MIGRATE_NO_SCHEMA"]
+        rescue ActiveRecord::NoDatabaseError
+          @stderr.puts(
+            "error: database #{Ardb.config.database.inspect} does not exist",
+          )
+        rescue => ex
+          @stderr.puts ex
+          @stderr.puts ex.backtrace.join("\n")
+          @stderr.puts(
+            "error migrating #{Ardb.config.database.inspect} database",
+          )
+          raise CommandExitError
+        end
+      end
+    end
   end
 
   class MigrateCommand
-    include ValidCommand
+    include MigrateCommandBehaviors
 
-    def run(argv, *args)
-      super
+    def self.command_name
+      "migrate"
+    end
 
-      Ardb.init(true)
-      begin
-        Ardb.adapter.migrate_db
-        Ardb.adapter.dump_schema unless ENV['ARDB_MIGRATE_NO_SCHEMA']
-      rescue StandardError => e
-        @stderr.puts e
-        @stderr.puts e.backtrace.join("\n")
-        @stderr.puts "error migrating #{Ardb.config.database.inspect} database"
-        raise CommandExitError
+    def self.command_summary
+      "Migrate the configured DB"
+    end
+
+    def migrate
+      Ardb.adapter.migrate_db
+    end
+  end
+
+  module MigrateStyleBehaviors
+    include MuchMixin
+
+    mixin_included do
+      include MigrateCommandBehaviors
+    end
+
+    mixin_class_methods do
+      def command_style
+        raise NotImplementedError
+      end
+
+      def command_name
+        "migrate-#{command_style}"
+      end
+
+      def command_summary
+        "Migrate the configured DB #{command_style}"
       end
     end
 
-    def summary
-      "Migrate the configured DB"
+    mixin_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 help
-      "Usage: ardb migrate [options]\n\n" \
-      "Options: #{@clirb}\n" \
-      "Description:\n" \
-      "  #{self.summary}"
+  module MigrateDirectionBehaviors
+    include MuchMixin
+
+    mixin_included do
+      include MigrateStyleBehaviors
     end
 
+    mixin_class_methods do
+      def command_style
+        command_direction
+      end
+
+      def command_direction
+        raise NotImplementedError
+      end
+    end
+
+    mixin_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
 
-  class GenerateMigrationCommand
-    include ValidCommand
+  module MigrateStepDirectionBehaviors
+    include MuchMixin
 
-    def run(argv, *args)
-      super
+    mixin_included do
+      include MigrateStyleBehaviors
+    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
+    mixin_class_methods do
+      def command_style
+        command_direction
+      end
+
+      def command_direction
+        raise NotImplementedError
       end
     end
 
-    def summary
-      "Generate a migration file given a MIGRATION-NAME"
+    mixin_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
 
-    def help
-      "Usage: ardb generate-migration [options] MIGRATION-NAME\n\n" \
-      "Options: #{@clirb}\n" \
-      "Description:\n" \
-      "  #{self.summary}"
+  class MigrateUpCommand
+    include MigrateDirectionBehaviors
+
+    def self.command_direction
+      "up"
     end
+  end
 
+  class MigrateDownCommand
+    include MigrateDirectionBehaviors
+
+    def self.command_direction
+      "down"
+    end
   end
 
-  class CommandSet
+  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) }
+      @lookup    = Hash.new{ |_h, k| unknown_cmd_block.call(k) }
       @names     = []
       @aliases   = {}
       @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
+        # 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
@@ -262,14 +444,11 @@ class Ardb::CLI
     end
 
     def to_s
-      max_name_size  = @names.map{ |n| n.size }.max || 0
-      max_alias_size = @aliases.values.map{ |v| v.size }.max || 0
+      max_name_size = @names.map(&:size).max || 0
 
-      @to_s ||= @names.map do |n|
-        "#{n.ljust(max_name_size)} #{@aliases[n].ljust(max_alias_size)} #{@summaries[n]}"
-      end.join("\n")
+      @to_s ||= @names.map{ |n|
+        "#{n.ljust(max_name_size)} #{@summaries[n]}"
+      }.join("\n")
     end
-
   end
-
 end

data/lib/ardb/cli.rb

@@ -1,21 +1,28 @@
-require 'ardb/cli/clirb'
-require 'ardb/cli/commands'
-require 'ardb/version'
+# frozen_string_literal: true
 
-module Ardb
+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')
-    end
+    COMMANDS =
+      CommandSet.new{ |unknown|
+        InvalidCommand.new(unknown)
+      }.tap do |c|
+        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)
-      self.new.run(args)
+      new.run(args)
     end
 
     def initialize(kernel = nil, stdout = nil, stderr = nil)
@@ -32,19 +39,19 @@ 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
+      rescue CLIRB::Error, ArgumentError, InvalidCommandError => ex
+        display_debug(ex)
+        @stderr.puts "#{ex.message}\n\n"
+        @stdout.puts cmd.command_help
         @kernel.exit 1
       rescue CommandExitError
         @kernel.exit 1
-      rescue StandardError => exception
-        @stderr.puts "#{exception.class}: #{exception.message}"
-        @stderr.puts exception.backtrace.join("\n")
+      rescue => ex
+        @stderr.puts "#{ex.class}: #{ex.message}"
+        @stderr.puts ex.backtrace.join("\n")
         @kernel.exit 1
       end
       @kernel.exit 0
@@ -53,12 +60,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/db_tests.rb

@@ -1,8 +1,9 @@
-require 'active_record'
-require 'assert'
+# frozen_string_literal: true
 
-module Ardb
+require "active_record"
+require "assert"
 
+module Ardb
   class DbTests < Assert::Context
     around do |block|
       ActiveRecord::Base.transaction do
@@ -11,5 +12,4 @@ module Ardb
       end
     end
   end
-
 end