ardb 0.28.1 → 0.29.2

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/cli/clirb.rb

@@ -1,59 +1,61 @@
 module Ardb; end
-class Ardb::CLI
 
-  class CLIRB  # Version 1.0.0, https://github.com/redding/cli.rb
+class Ardb::CLI
+  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
 
     def option(*args); @options << Option.new(*args); end
+
     def parse!(argv)
       @args = (argv || []).dup.tap do |args_list|
         begin; @parser.parse!(args_list)
         rescue OptionParser::ParseError => err; raise Error, err.message; end
       end; @data = @args + [@opts]
     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,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