ardb 0.27.3 → 0.29.0

data/lib/ardb/cli.rb

@@ -1,22 +1,19 @@
-require 'ardb'
-require 'ardb/clirb'
+require "ardb/cli/clirb"
+require "ardb/cli/commands"
+require "ardb/version"
 
 module Ardb
-
   class CLI
-
-    class InvalidCommand;           end
-    class ConnectCommand;           end
-    class CreateCommand;            end
-    class DropCommand;              end
-    class MigrateCommand;           end
-    class GenerateMigrationCommand; end
-    COMMANDS = Hash.new{ |h, k| InvalidCommand.new(k) }.tap do |h|
-      h['connect']            = ConnectCommand
-      h['create']             = CreateCommand
-      h['drop']               = DropCommand
-      h['migrate']            = MigrateCommand
-      h['generate-migration'] = GenerateMigrationCommand
+    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)
@@ -32,19 +29,18 @@ module Ardb
     def run(args)
       begin
         $LOAD_PATH.push(Dir.pwd) unless $LOAD_PATH.include?(Dir.pwd)
-        Ardb.init(false) # don't establish a connection
 
         cmd_name = args.shift
-        cmd = COMMANDS[cmd_name].new(args)
-        cmd.run
+        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
@@ -59,214 +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
-
-    InvalidCommandError = Class.new(ArgumentError)
-    CommandExitError    = Class.new(RuntimeError)
-
-    class InvalidCommand
-
-      attr_reader :name, :argv, :clirb
-
-      def initialize(name)
-        @name  = name
-        @argv  = []
-        @clirb = Ardb::CLIRB.new
-      end
-
-      def new(args)
-        @argv = [@name, args].flatten.compact
-        self
-      end
-
-      def run
-        @clirb.parse!(@argv)
-        raise CLIRB::HelpExit if @clirb.args.empty? || @name.to_s.empty?
-        raise InvalidCommandError, "'#{self.name}' is not a command."
-      end
-
-      def help
-        "Usage: ardb [COMMAND] [options]\n\n" \
-        "Commands: #{COMMANDS.keys.sort.join(', ')}\n" \
-        "Options: #{@clirb}"
-      end
-
-    end
-
-    class ConnectCommand
-
-      attr_reader :clirb
-
-      def initialize(argv, stdout = nil, stderr = nil)
-        @argv   = argv
-        @stdout = stdout || $stdout
-        @stderr = stderr || $stderr
-
-        @clirb   = Ardb::CLIRB.new
-        @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
-      end
-
-      def run
-        @clirb.parse!(@argv)
-        begin
-          Ardb.init
-          @adapter.connect_db
-          @stdout.puts "connected to #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
-        rescue StandardError => e
-          @stderr.puts e
-          @stderr.puts e.backtrace.join("\n")
-          @stderr.puts "error connecting to #{Ardb.config.db.database.inspect} database " \
-                       "with #{Ardb.config.db_settings.inspect}"
-          raise CommandExitError
-        end
-      end
-
-      def help
-        "Usage: ardb connect [options]\n\n" \
-        "Options: #{@clirb}"
-      end
-
-    end
-
-    class CreateCommand
-
-      attr_reader :clirb
-
-      def initialize(argv, stdout = nil, stderr = nil)
-        @argv   = argv
-        @stdout = stdout || $stdout
-        @stderr = stderr || $stderr
-
-        @clirb   = Ardb::CLIRB.new
-        @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
-      end
-
-      def run
-        @clirb.parse!(@argv)
-        begin
-          @adapter.create_db
-          @stdout.puts "created #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
-        rescue StandardError => e
-          @stderr.puts e
-          @stderr.puts "error creating #{Ardb.config.db.database.inspect} database"
-          raise CommandExitError
-        end
-      end
-
-      def help
-        "Usage: ardb create [options]\n\n" \
-        "Options: #{@clirb}"
-      end
-
-    end
-
-    class DropCommand
-
-      attr_reader :clirb
-
-      def initialize(argv, stdout = nil, stderr = nil)
-        @argv   = argv
-        @stdout = stdout || $stdout
-        @stderr = stderr || $stderr
-
-        @clirb   = Ardb::CLIRB.new
-        @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
-      end
-
-      def run
-        @clirb.parse!(@argv)
-        begin
-          @adapter.drop_db
-          @stdout.puts "dropped #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`"
-        rescue StandardError => e
-          @stderr.puts e
-          @stderr.puts "error dropping #{Ardb.config.db.database.inspect} database"
-          raise CommandExitError
-        end
-      end
-
-      def help
-        "Usage: ardb drop [options]\n\n" \
-        "Options: #{@clirb}"
-      end
-
-    end
-
-    class MigrateCommand
-
-      attr_reader :clirb
-
-      def initialize(argv, stdout = nil, stderr = nil)
-        @argv   = argv
-        @stdout = stdout || $stdout
-        @stderr = stderr || $stderr
-
-        @clirb   = Ardb::CLIRB.new
-        @adapter = Ardb::Adapter.send(Ardb.config.db.adapter)
-      end
-
-      def run
-        @clirb.parse!(@argv)
-        begin
-          Ardb.init
-          @adapter.migrate_db
-          @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.db.database.inspect} database"
-          raise CommandExitError
-        end
-      end
-
-      def help
-        "Usage: ardb migrate [options]\n\n" \
-        "Options: #{@clirb}"
-      end
-
-    end
-
-    class GenerateMigrationCommand
-
-      attr_reader :clirb
-
-      def initialize(argv, stdout = nil, stderr = nil)
-        @argv   = argv
-        @stdout = stdout || $stdout
-        @stderr = stderr || $stderr
-
-        @clirb = Ardb::CLIRB.new
-      end
-
-      def run
-        @clirb.parse!(@argv)
-        begin
-          require "ardb/migration"
-          path = Ardb::Migration.new(@clirb.args.first).save!.file_path
-          @stdout.puts "generated #{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
-        end
-      end
-
-      def help
-        "Usage: ardb generate-migration [options] MIGRATION-NAME\n\n" \
-        "Options: #{@clirb}"
-      end
-
-    end
-
   end
-
 end

data/lib/ardb/{clirb.rb → cli/clirb.rb}

@@ -1,19 +1,19 @@
-module Ardb
-
-  class CLIRB  # Version 1.0.0, https://github.com/redding/cli.rb
+module Ardb; end
+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
 
@@ -26,33 +26,31 @@ module Ardb
     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

@@ -0,0 +1,365 @@
+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)
+      @name  = name
+      @clirb = CLIRB.new
+    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."
+    end
+
+    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_class_methods do
+      def command_name;    raise NotImplementedError; end
+      def command_summary; "";                        end
+    end
+
+    plugin_instance_methods do
+      def initialize(&clirb_build)
+        @clirb = CLIRB.new(&clirb_build)
+      end
+
+      def clirb; @clirb; end
+
+      def run(argv, stdout = nil, stderr = nil)
+        @clirb.parse!(argv)
+        @stdout = stdout || $stdout
+        @stderr = stderr || $stderr
+      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
+
+      begin
+        Ardb.init(false)
+        Ardb.adapter.connect_db
+        @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")
+        @stderr.puts "error connecting to #{Ardb.config.database.inspect} database " \
+                     "with #{Ardb.config.activerecord_connect_hash.inspect}"
+        raise CommandExitError
+      end
+    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
+
+      begin
+        Ardb.init(false)
+        Ardb.adapter.create_db
+        @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
+  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
+
+      begin
+        Ardb.init(true)
+        Ardb.adapter.drop_db
+        @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
+  end
+
+  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
+
+      begin
+        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 generating migration"
+        raise CommandExitError
+      end
+    end
+
+    def command_help
+      "Usage: ardb #{self.command_name} MIGRATION-NAME [options]\n\n" \
+      "Options: #{self.clirb}\n" \
+      "Description:\n" \
+      "  #{self.command_summary}"
+    end
+  end
+
+  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 MigrateCommand
+    include MigrateCommandBehaviors
+
+    def self.command_name;    "migrate";                   end
+    def self.command_summary; "Migrate the configured DB"; end
+
+    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
+
+  module MigrateDirectionBehaviors
+    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(: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 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     = []
+      @aliases   = {}
+      @summaries = {}
+    end
+
+    def add(klass)
+      begin
+        cmd = klass.new
+      rescue StandardError
+        # don"t add any commands you can"t initialize
+      else
+        @lookup[cmd.command_name] = cmd
+        @to_s = nil
+        @names << cmd.command_name
+        @summaries[cmd.command_name] = cmd.command_summary.to_s
+      end
+    end
+
+    def remove(klass)
+      @lookup.delete(klass.command_name)
+      @names.delete(klass.command_name)
+      @summaries.delete(klass.command_name)
+      @to_s = nil
+    end
+
+    def [](cmd_name)
+      @lookup[cmd_name]
+    end
+
+    def size
+      @names.size
+    end
+
+    def to_s
+      max_name_size  = @names.map{ |n| n.size }.max || 0
+
+      @to_s ||= @names.map do |n|
+        "#{n.ljust(max_name_size)} #{@summaries[n]}"
+      end.join("\n")
+    end
+  end
+end