luban-cli 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5cefeb5c04a0122c4ddbcfe60ec89f10fa448986
-  data.tar.gz: 63308ba45f262576aa6208d7017accbbefcc71fd
+  metadata.gz: c3717edf51bdf2888b4d7d7d378b8ba777e7f2df
+  data.tar.gz: 23c48793a99823629c9b339a7b65f64f3be9dc27
 SHA512:
-  metadata.gz: c9783ade21c7ca9ae041262c692730fd3db7fe6cd8eaa880ff910568d57729a88688c5583edbb297b6996797d4d04deb88e7231551e9686e189d2339a0904539
-  data.tar.gz: a3724c927f17da7c1933b69ccd82e06371c982040bf8e7840f6cf569049974373ec4961551afe7d49d0f405715da63748fa5ca206242bf989914117b6067500f
+  metadata.gz: d5dd0736e211101a179af588fab6892445fc3e6b77d4203237f383cb14267da9ce61dbdc565c6ffa8cf4a46fbf7feaba43c1347afbfc8cb27afa0b00e42222ab
+  data.tar.gz: abe9f13478171fd6c9bb4b5163f73919666b2f830c5a43896812da9e09e938da9ed16c23699486657b94752ef68849f902ff5384ffee6dcb6bce5e1026f636fa

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Change log
 
+## Version 0.4.0 (Oct 14, 2015)
+
+New features:
+  * Provide convenient method :start to create and run new instance of CLI application
+  * Added method #alter to allow change cli configuration during runtime
+
+Minor enhancements:
+  * Merge Commands module into Luban::CLI::Base
+  * Handled commands in instance level instead of class level
+    * Handled command definition and action method on its eigenclass
+    * Enhanced action method invocation to look up thru its parent
+  * Update examples accordingly
+  * Some other minor refactoring
+
 ## Version 0.3.2 (Apr 28, 2015)
 
 Minor enhancements:

data/README.md

@@ -43,7 +43,7 @@ class MyApp < Luban::CLI::Application
     action :say_hi
   end
 
-  def say_hi(cmd:, argv:, args:, opts:)
+  def say_hi(args:, opts:)
     name = compose_name(opts[:prefix], opts[:suffix], args[:name])
     if opts[:verbose]
       say_hi_verbosely(name, opts, args)
@@ -72,7 +72,7 @@ class MyApp < Luban::CLI::Application
   end
 end
 
-MyApp.new.run
+MyApp.start
 ```
 
 ```
@@ -149,6 +149,8 @@ Note: An argument with multiple values needs to be positioned at the last argume
 Here is an example how to use argument:
 
 ```ruby
+require 'luban/cli'
+
 class MyApp < Luban::CLI::Application
   configure do
     argument :name, 'Name for an employee'
@@ -167,7 +169,7 @@ class MyApp < Luban::CLI::Application
   end
 end
 
-MyApp.new.run
+MyApp.start
 ```
 
 ```
@@ -207,6 +209,8 @@ Note: modifier :required is turned off by default. Therefore, all options are no
 Here is an example how to use option:
 
 ```ruby
+require 'luban/cli'
+
 class MyApp < Luban::CLI::Application
   configure do
     option :libraries, 'Require the LIBRARIES before executing your script', 
@@ -217,7 +221,7 @@ class MyApp < Luban::CLI::Application
   end
 end
 
-MyApp.new.run
+MyApp.start
 ```
 
 ```
@@ -233,6 +237,8 @@ Occassionally an option might take an optional argument, e.g. --inplace [EXTENSI
 Here is an example how to use nullable option:
 
 ```ruby
+require 'luban/cli'
+
 class MyApp < Luban::CLI::Application
   configure do
     option :inplace, 'Edit in place (make backup if EXTENSION supplied)', 
@@ -243,7 +249,7 @@ class MyApp < Luban::CLI::Application
   end
 end
 
-MyApp.new.run
+MyApp.start
 ```
 
 ```
@@ -275,16 +281,19 @@ Negatable switch is also supported, e.g., --local, --no-local. To declare a nega
 Here is an example how to use negatable option:
 
 ```ruby
+require 'luban/cli'
+
 class MyApp < Luban::CLI::Application
   configure do
     switch :local, 'Check repository locally', 
            negatable: true # Turn the switch into negatable: --local or --no-local
-  action do |**params|
-    puts params.inspect
+    action do |**params|
+      puts params.inspect
+    end
   end
 end
 
-MyApp.new.run
+MyApp.start
 ```
 
 ### help
@@ -299,11 +308,13 @@ DSL alias #auto_help is provided which applies default values for the above opti
 The switch of help display is turned on by default unless explicitly turning off when creating an application or a command.
 
 ```ruby
+require 'luban/cli'
+
 class MyApp < Luban::CLI::Application
   ... ...
 end
 
-MyApp.new(auto_help: false)
+MyApp.start(auto_help: false)
 ``` 
 
 ### version
@@ -340,6 +351,7 @@ This is used to configure CLI application during definition.
 Here is an example for how to configure CLI application:
 
 ```ruby
+require 'luban/cli'
 
 class MyApp < Luban::CLI::Application
   configure do
@@ -357,59 +369,61 @@ class MyApp < Luban::CLI::Application
   end
 end
 
-MyApp.new.run
+MyApp.start
 
 ```
 
 However, it can be overriden if a configuration block is provided during application instance creation:
 
 ```ruby
-MyApp.new.run do
-    program "my_app"
-    version "1.0.0"
-    long_desc "Demo app for Luban::CLI" 
-    option :opt2, "Description for opt2", short: :p
-    switch :swt2, "Description for swt2", short: :w
-    action :do_something_else
+MyApp.start do
+  program "my_app"
+  version "1.0.0"
+  long_desc "Demo app for Luban::CLI" 
+  option :opt2, "Description for opt2", short: :p
+  switch :swt2, "Description for swt2", short: :w
+  action :do_something_else
 end
 
 ```
 
 ## Commands
 
-Luban::CLI supports commands/subcommands. Commands can also be nested. However, all action handlers should be defined under the the application class, otherwise NoMethodError will be raised.
+Luban::CLI supports commands/subcommands. Commands can also be nested. However, all action handlers are preferred to be defined under the the application class; otherwise RuntimeError will be raised.
 
 ```ruby
+require 'luban/cli'
+
 class MyApp < Luban::CLI::Application
   configure do
     version '1.0.0'
     desc 'Short description for the application'
     long_desc 'Long description for the application'
-  end
 
-  # Define a help command to list all commands or help for one command.
-  auto_help_command
+    command :cmd1 do
+      desc 'Description for command 1'
 
-  command :cmd1 do
-    desc 'Description for command 1'
+      command :task1 do
+        desc 'Description for task 1'
+        argument :arg1, 'Description for arg1', type: :string
+        action :exec_command1_task1
+      end
 
-    command :task1 do
-      desc 'Description for task 1'
-      argument :arg1, 'Description for arg1', type: :string
-      action :exec_command1_task1
+      command :task2 do
+        desc 'Description for task 2'
+        option :opt1, 'Description for opt1', type: :integer
+        action :exec_command1_task2
+      end
     end
 
-    command :task2 do
-      desc 'Description for task 2'
-      option :opt1, 'Description for opt1', type: :integer
-      action :exec_command1_task2
+    command :cmd2 do
+      desc 'Description for command 1'
+      switch :swt1, 'Description for swt1'
+      action :exec_command2
     end
-  end
 
-  command :cmd2 do
-    desc 'Description for command 1'
-    switch :swt1, 'Description for swt1'
-    action :exec_command2
+    # Define a help command to list all commands or help for one command.
+    auto_help_command
   end
 
   def exec_command1_task1(args:, opts:); puts 'In command 1/task 1'; end
@@ -417,12 +431,12 @@ class MyApp < Luban::CLI::Application
   def exec_command2(args:, opts:); puts 'In command 2'; end
 end
 
-MyApp.new.run
+MyApp.start
 ```
 
 ### Command method/handler
 
-By default, a new method will be defined for each command under the application class. Usually you don't need to call this method directly. Luban::CLI dispatches the specified command to the corresponding command method/handler properly.
+By default, a new method will be defined for each command under the application/command instance's eigenclass. Usually you don't need to call this method directly. Luban::CLI dispatches the specified command to the corresponding command method/handler properly.
 
 The command method name is composed of the following, concatenating with an underscore:
 
@@ -456,15 +470,17 @@ Commands can be defined directly within the Luban app class like examples shown
 Below is an example demonstrating how command injection is supposed to work.
 
 ```ruby
+require 'luban/cli'
+
 module App
   module ControlTasks
-    class Task1Command < Luban::CLI::Command
+    class Task1 < Luban::CLI::Command
       configure do
         ... ...
       end
     end
 
-    class Task2Command < Luban::CLI::Command
+    class Task2 < Luban::CLI::Command
       configure do
         ... ...
       end
@@ -485,6 +501,8 @@ class MyApp < Luban::CLI::Application
   # command 'app:control_tasks:task1'
   # command 'app:control_tasks:task2'
 end
+
+MyApp.start
 ```
 
 ```
@@ -495,16 +513,14 @@ $ ruby my_app.rb app:control_tasks:task2
 
 As shown above, there are a few naming conventions about the command class naming and injection:
 
-* Command class should has suffix "Command"
-  * For instances, Task1Command, Task2Command
 * Module name to be injected should be fully qualified
   * namespaces/modules should be in snake case and
   * Separated by colon as the delimiter
-  * For instances, 'app:control_tasks'
+  * For instance, 'app:control_tasks'
 * Alternatively, commands can be injected individually
   * Command name should be fully qualified
-  * Suffix "Command" is no more needed
-
+  * For instance, 'app:control_tasks:task2'
+  
 ## Applications
 
 Luban::CLI provides a base class for cli application, Luban::CLI::Application. You can define your own cli application by inheriting it as examples shown in the previous sections. 

data/lib/luban/cli/application.rb

@@ -3,12 +3,16 @@ require 'pathname'
 module Luban
   module CLI
     class Application < Base
+      class << self
+        def start(action_name = :run, **opts, &config_blk)
+          new(action_name, **opts, &config_blk).send(action_name)
+        end
+      end
+
       attr_reader :rc
 
       def initialize(action_name = :run, **opts, &config_blk)
         super(self, action_name, **opts, &config_blk)
-        @rc = init_rc
-        validate
       end
 
       def rc_file
@@ -29,7 +33,9 @@ module Luban
 
       protected
 
-      def validate; end
+      def on_configure
+        @rc = init_rc
+      end
 
       def init_rc
         if rc_file_exists?
@@ -45,4 +51,4 @@ module Luban
       end
     end
   end
-end
+end

data/lib/luban/cli/base/argument.rb

@@ -134,7 +134,7 @@ module Luban
 
       def verify_config_assurance
         unless @config[:assure].respond_to?(:call)
-          raise ArgumentError, "Assurance of #{kind} #{display_name} must be callable."
+          raise ArgumentError, "Assurance of #{kind} #{display_name} must respond to #call."
         end
       end
 

data/lib/luban/cli/base/commands.rb

@@ -0,0 +1,72 @@
+module Luban
+  module CLI
+    class Base
+      def command(cmd, base: Command, **opts, &blk)
+        cmd = cmd.to_sym
+        @commands[cmd] = command_class(cmd, base).new(self, cmd, **opts, &blk)
+      end
+
+      def undef_command(cmd)
+        undef_singleton_method(@commands.delete(cmd.to_sym).action_method)
+      end
+
+      def use_commands(module_name, **opts, &blk)
+        module_class = Object.const_get(camelcase(module_name.to_s), false)
+        module_class.constants(false).map { |c| module_class.const_get(c, false) }.each do |c|
+          command(snakecase(c.name), base: c, **opts, &blk) if c < Command
+        end
+      end
+
+      def list_commands
+        @commands.keys
+      end
+
+      def has_command?(cmd)
+        @commands.has_key?(cmd.to_sym)
+      end
+
+      def has_commands?
+        !@commands.empty?
+      end
+
+      protected
+
+      def command_class(cmd, base)
+        class_name = camelcase(cmd)
+        if command_class_defined?(class_name)
+          get_command_class(class_name)
+        else
+          define_command_class(class_name, base)
+        end
+      end
+
+      def command_class_defined?(class_name)
+        self.class.const_defined?(class_name, false)
+      end
+
+      def get_command_class(class_name)
+        self.class.const_get(class_name, false)
+      end
+
+      def define_command_class(class_name, base)
+        self.class.send(:define_class, class_name, base: base, namespace: self.class)
+      end
+
+      def camelcase(str)
+        str = str.to_s.dup
+        str.gsub!(/(\:|\/)(.?)/){ "::#{$2.upcase}" }
+        str.gsub!(/(?:_+|-+)([a-z])/){ $1.upcase }
+        str.gsub!(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+        str
+      end
+
+      def snakecase(str)
+        str.gsub(/::/, ':').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+      end
+    end
+  end
+end

data/lib/luban/cli/base/core.rb

@@ -8,8 +8,6 @@ OptionParser::Officious.delete('version')
 module Luban
   module CLI
     class Base
-      include Commands
-
       class MissingCommand < Error; end
       class InvalidCommand < Error; end
       class MissingRequiredOptions < Error; end
@@ -19,7 +17,7 @@ module Luban
       DefaultSummaryIndent = 4
       DefaultTitleIndent = 2
 
-      attr_reader :app
+      attr_reader :parent
       attr_reader :prefix
       attr_reader :program_name
       attr_reader :options
@@ -29,13 +27,14 @@ module Luban
       attr_reader :version
       attr_reader :result
       attr_reader :default_argv
+      attr_reader :commands
 
       attr_accessor :title_indent
       attr_accessor :summary_width
       attr_accessor :summary_indent
 
-      def initialize(app, action_name, prefix: default_prefix, auto_help: true, &config_blk)
-        @app = app
+      def initialize(parent, action_name, prefix: default_prefix, auto_help: true, &config_blk)
+        @parent = parent
         @action_name = action_name
         @prefix = prefix
         @action_defined = false
@@ -48,6 +47,7 @@ module Luban
         @version = ''
         @default_argv = ARGV
         @result = { cmd: nil, argv: @default_argv, args: {}, opts: {} }
+        @commands = {}
 
         @title_indent = DefaultTitleIndent
         @summary_width = DefaultSummaryWidth
@@ -78,36 +78,86 @@ module Luban
         @result = { cmd: nil, argv: @default_argv, args: {}, opts: {} }
       end
 
+      def alter(&blk)
+        instance_eval(&blk)
+        on_alter
+      end
+
       protected
 
+      def self.define_class(class_name, base:, namespace:)
+        mods = class_name.split('::')
+        cmd_class = mods.pop
+        mods.inject(namespace) do |ns, mod|
+          ns.const_set(mod, Module.new) unless ns.const_defined?(mod, false)
+          ns.const_get(mod, false)
+        end.const_set(cmd_class, Class.new(base))
+      end
+
+      def undef_singleton_method(method_name)
+        # Undefine methods that are defined in the eigenclass
+        (class << self; self; end).send(:undef_method, method_name)
+      end
+
       def configure(&blk)
-        config_blk = block_given? ? blk : self.class.config_blk
-        instance_eval(&config_blk) unless config_blk.nil?
+        [self.class.config_blk, blk].each do |callback|
+          instance_eval(&callback) unless callback.nil?
+        end
+        on_configure
       end
 
+      def on_configure; end 
+      def on_alter; end
+
       def setup_default_action
-        method = @action_method
-        action do |**opts|
-          raise NotImplementedError, "#{self.class.name}##{method} is an abstract method."
+        if has_commands?
+          action_noops
+        else
+          action_abort
         end
       end
 
-      def dispatch_command(context, cmd:, argv:)
+      def action_noops
+        action { } # NOOPS
+      end
+
+      def action_abort
+        name = @action_name
+        action do
+          abort "Aborted! Action is NOT defined for #{name} in #{self.class.name}."
+        end
+      end
+
+      def dispatch_command(cmd:, argv:)
         validate_command(cmd)
-        cmd_method = commands[cmd].action_method
-        if respond_to?(cmd_method)
-          send(cmd_method, argv)
-        else          
-          context.send(cmd_method, argv)
+        send(commands[cmd].action_method, argv)
+      end
+
+      def invoke_action(action_method, **opts)
+        handler = find_action_handler(action_method)
+        if handler.nil?
+          raise RuntimeError, "Action handler #{action_method} is MISSING."
+        else
+          handler.send(action_method, **opts)
+        end
+      end
+
+      def find_action_handler(action_method)
+        if respond_to?(action_method, true)
+          self
+        elsif @parent != self and @parent.respond_to?(:find_action_handler, true)
+          @parent.send(:find_action_handler, action_method)
+        else
+          nil
         end
       end
 
       def validate_command(cmd)
         if cmd.nil?
-          raise MissingCommand, "Missing command. Expected command: #{list_commands.join(', ')}"
+          raise MissingCommand, "Please specify a command to execute."
         end
         unless has_command?(cmd)
-          raise InvalidCommand, "Invalid command. Expected command: #{list_commands.join(', ')}"
+          raise InvalidCommand, "Invalid command: #{cmd}"
         end
       end
 

data/lib/luban/cli/base/dsl.rb

@@ -1,28 +1,18 @@
 module Luban
   module CLI
     class Base
-      include Commands
-
       class << self
+        def inherited(subclass)
+          super
+          # Ensure configuration block from base class
+          # got inherited to its subclasses
+          blk = instance_variable_get('@config_blk')
+          subclass.instance_variable_set('@config_blk', blk.clone) unless blk.nil?
+        end
+
         attr_reader :config_blk
-        
-        def configure(&blk); @config_blk = blk; end
 
-        def help_command(**opts, &blk)
-          if block_given?
-            command(**opts, &blk)
-          else
-            validator = method(:has_command?)
-            command(:help, **opts) do
-              desc "List all commands or help for one command"
-              argument :command, "Command to help for", 
-                       type: :symbol, required: false,
-                       assure: validator
-              action :show_help_for_command
-            end
-          end
-        end
-        alias_method :auto_help_command, :help_command
+        def configure(&blk); @config_blk = blk; end
       end
 
       def program(name)
@@ -72,6 +62,22 @@ module Luban
         end
       end
 
+      def help_command(**opts, &blk)
+        if block_given?
+          command(**opts, &blk)
+        else
+          validator = method(:has_command?)
+          command(:help, **opts) do
+            desc "List all commands or help for one command"
+            argument :command, "Command to help for", 
+                      type: :symbol, required: false,
+                     assure: validator
+            action :show_help_for_command
+          end
+        end
+      end
+      alias_method :auto_help_command, :help_command
+
       def version(ver = nil, short: :v, desc: "Show #{program_name} version.", &blk)
         if ver.nil?
           @version
@@ -95,7 +101,7 @@ module Luban
 
       def create_action(method_name = nil, preserve_argv: true, &blk)
         handler = if method_name
-                    lambda { |**opts| send(method_name, **opts) }
+                    lambda { |**opts| invoke_action(method_name, **opts) }
                   elsif block_given?
                     blk
                   end
@@ -105,7 +111,7 @@ module Luban
         _base = self
         parse_method = preserve_argv ? :parse : :parse!
         define_action_method do |argv = _base.default_argv|
-          _base.send(:process, self, parse_method, argv) do |params|
+          _base.send(:process, parse_method, argv) do |params|
             instance_exec(**params, &handler)
           end
         end
@@ -113,26 +119,21 @@ module Luban
       end
 
       def define_action_method(&action_blk)
-        @app.send(method_creator, action_method, &action_blk)
-      end
-
-      def method_creator
-        @method_creator ||= @app.is_a?(Class) ? :define_method : :define_singleton_method
+        @parent.send(:define_singleton_method, action_method, &action_blk)
       end
 
-      def process(context, parse_method, argv)
+      def process(parse_method, argv)
         send(parse_method, argv)
         if result[:opts][:help]
           show_help
-        elsif result[:opts][:version]
+        elsif !@version.empty? and result[:opts][:version]
           show_version
         else
+          validate_required_options
+          validate_required_arguments
+          yield args: result[:args], opts: result[:opts]
           if has_commands?
-            dispatch_command(context, cmd: result[:cmd], argv: result[:argv])
-          else
-            validate_required_options
-            validate_required_arguments
-            yield args: result[:args], opts: result[:opts]
+            dispatch_command(cmd: result[:cmd], argv: result[:argv])
           end
         end
       rescue OptionParser::ParseError, Error => e

data/lib/luban/cli/base.rb

@@ -4,3 +4,4 @@ require_relative "base/switch"
 require_relative "base/core"
 require_relative "base/parse"
 require_relative "base/dsl"
+require_relative "base/commands"

data/lib/luban/cli/command.rb

@@ -4,10 +4,10 @@ module Luban
       attr_reader :name
       attr_reader :command_chain
 
-      def initialize(app, name, command_chain: [name], **opts, &config_blk)
+      def initialize(parent, name, command_chain: [name], **opts, &config_blk)
         @name = name
         @command_chain = command_chain
-        super(app, name, **opts, &config_blk)
+        super(parent, name, **opts, &config_blk)
       end
 
       def default_prefix; '__command_'; end
@@ -16,6 +16,11 @@ module Luban
         @action_method ||= "#{@prefix}#{command_chain.map(&:to_s).join('_').gsub(':', '_')}"
       end
 
+      def command(cmd, **opts, &blk)
+        opts[:command_chain] = self.command_chain.clone.push(cmd)
+        super
+      end
+
       protected
 
       def compose_banner

data/lib/luban/cli/version.rb

@@ -1,5 +1,5 @@
 module Luban
   module CLI
-    VERSION = "0.3.2"
+    VERSION = "0.4.0"
   end
 end

data/lib/luban/cli.rb

@@ -1,6 +1,5 @@
 require_relative "cli/error"
 require_relative "cli/version"
-require_relative "cli/commands"
 require_relative "cli/base"
 require_relative "cli/command"
 require_relative "cli/application"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: luban-cli
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Rubyist Chi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-28 00:00:00.000000000 Z
+date: 2015-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,13 +56,13 @@ files:
 - lib/luban/cli/application.rb
 - lib/luban/cli/base.rb
 - lib/luban/cli/base/argument.rb
+- lib/luban/cli/base/commands.rb
 - lib/luban/cli/base/core.rb
 - lib/luban/cli/base/dsl.rb
 - lib/luban/cli/base/option.rb
 - lib/luban/cli/base/parse.rb
 - lib/luban/cli/base/switch.rb
 - lib/luban/cli/command.rb
-- lib/luban/cli/commands.rb
 - lib/luban/cli/error.rb
 - lib/luban/cli/version.rb
 - luban-cli.gemspec

data/lib/luban/cli/commands.rb

@@ -1,98 +0,0 @@
-module Luban
-  module CLI
-    module Commands
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.send(:include, InstanceMethods)
-      end
-
-      module CommonMethods
-        def list_commands
-          commands.keys
-        end
-
-        def has_command?(cmd)
-          commands.has_key?(cmd)
-        end
-
-        def has_commands?
-          !commands.empty?
-        end
-
-        def use_commands(mod_name)
-          mod_class = Kernel.const_get(camelcase(mod_name.to_s))
-          mod_class.constants.map { |c| mod_class.const_get(c) }.each do |c|
-            command(snakecase(c.name.sub(/Command$/, ''))) if c < Luban::CLI::Command
-          end
-        end
-
-        protected
-
-        def camelcase(str)
-          str = str.to_s.dup
-          str.gsub!(/\:(.?)/){ "::#{$1.upcase}" }
-          str.gsub!(/(?:_+|-+)([a-z])/){ $1.upcase }
-          str.gsub!(/(\A|\s)([a-z])/){ $1 + $2.upcase }
-          str
-        end
-
-        def snakecase(str)
-          str.gsub(/::/, ':').
-          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-          gsub(/([a-z\d])([A-Z])/,'\1_\2').
-          tr("-", "_").
-          downcase
-        end
-      end
-
-      module ClassMethods
-        include CommonMethods
-
-        def commands
-          @commands ||= {}
-        end
-
-        def command_class(cmd)
-          "#{camelcase(cmd)}Command"
-        end
-
-        def command(app = self, cmd, **opts, &blk)
-          cmd = cmd.to_sym
-          cmd_class = command_class(cmd)
-          klass = if self.const_defined?(command_class(cmd))
-                    self.const_get(command_class(cmd))
-                  else
-                    self.const_set(command_class(cmd), Class.new(Command))
-                  end
-          commands[cmd] = klass.new(app, cmd, **opts, &blk)
-        end
-
-        def undef_command(cmd)
-          undef_method(commands.delete(cmd).action_method)
-        end
-      end
-
-      module InstanceMethods
-        include CommonMethods
-
-        def commands
-          self.class.commands
-        end
-
-        def command(cmd, **opts, &blk)
-          cmd = cmd.to_sym
-          if self.is_a?(Command)
-            opts[:command_chain] = self.command_chain.clone.push(cmd)
-            self.class.command(self.app, cmd, **opts, &blk)
-          else
-            self.class.command(cmd, **opts, &blk)
-          end
-        end
-
-        def undef_command(cmd)
-          self.class.undef_command(cmd)
-        end
-      end
-    end
-  end
-end