luban-cli 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 275afb8e84ecc64947db6b5e147e37996a7d1df1
-  data.tar.gz: 866526700250c04f22aab3467ba7ee9dbadc1b66
+  metadata.gz: ad584f0174c5361200ed88f252387ac294ff8768
+  data.tar.gz: 9af48be33bc18fa6d049780354d0a6dc3abb34fd
 SHA512:
-  metadata.gz: eb7fcbd25cfe82c7bfcfb99755a1272de32bddf1e12061fedc28a95298e26e1f5d06525717b4341d9debb42dc742acc81f23d93087c477e77f68915f58129416
-  data.tar.gz: 13c432783506cd550ec5a012f2b36e25420669af7f5851145323ccd021958f002982b39b2fa4f8285d56db3dfe99077a1937df93c869b517fbe4fe5d93c00238
+  metadata.gz: 932c919d74edc1e23cc4a45fe10240913603864aa25cf71a24b76e0a542da0a54296d20348fb5f7dc5c645b1b143e3557d897a6fbaf36df2ae88b5a0ba1bd400
+  data.tar.gz: 889e415204354c2c6db2440e1297fb52a85e4f59a0d662707c3bc404066eeb835c592b156fc3594bb35562c9db64f463504b2ab3bb1ebd97934de4a0e0b465b1

data/CHANGELOG.md

@@ -4,7 +4,7 @@
 
 Bootstrapped Luban::CLI
 
-Features:
+New features:
   * Support general command-line parsing
     * Support options
     * Support switches (boolean options)
@@ -15,9 +15,27 @@ Features:
 ## Version 0.2.0 (Apr 02, 2015)
 
 Minor enhancements:
-  * Refractor error class
-  * Refractor argument validation
+  * Refactor error class
+  * Refactor argument validation
   * Validate required options/arguments in Luban::CLI::Base
   * Create singleton action handler method on application instance
   * Move parse error handling to action handler
   * Exclude examples and spec from the gem itself
+
+## Version 0.3.0 (Apr 11, 2015)
+
+New features:
+  * Support prefix for action name
+    * By default, subcommand method is prefixed with "__command_"
+    * By default, application action method has no prefix
+  * Support nested subcommands
+  * Add help option by default in Luban::CLI::Base in order to turn on auto help by default
+
+Minor enhancements:
+  * Refactor action creation to be more readable
+  * Add an example for subcommands and nested subcommands
+
+Bug fixes:
+  * Apply the correct method creator when defining action method
+  * Dispatch command under the right class context
+  * Show correct command chain between program name and synopsis when composing parser banner

data/lib/luban/cli/application.rb

@@ -5,8 +5,8 @@ module Luban
     class Application < Base
       attr_reader :rc
 
-      def initialize(starter_method = :run, &config_blk)
-        super(self, starter_method, &config_blk)
+      def initialize(action_name = :run, **opts, &config_blk)
+        super(self, action_name, **opts, &config_blk)
         @rc = init_rc
         validate
       end

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

@@ -19,6 +19,9 @@ module Luban
       DefaultSummaryIndent = 4
       DefaultTitleIndent = 2
 
+      attr_reader :app
+      attr_reader :prefix
+      attr_reader :action_method
       attr_reader :program_name
       attr_reader :options
       attr_reader :arguments
@@ -32,9 +35,11 @@ module Luban
       attr_accessor :summary_width
       attr_accessor :summary_indent
 
-      def initialize(app, starter_method, &config_blk)
+      def initialize(app, action_name, prefix: default_prefix, auto_help: true, &config_blk)
         @app = app
-        @starter_method = starter_method
+        @action_name = action_name
+        @prefix = prefix
+        @action_method = "#{@prefix}#{@action_name}"
         @action_defined = false
 
         @program_name = default_program_name
@@ -51,9 +56,12 @@ module Luban
         @summary_indent = DefaultSummaryIndent
 
         configure(&config_blk)
-        setup_default_starter unless @action_defined
+        setup_default_action unless @action_defined
+        self.auto_help if auto_help
       end
 
+      def default_prefix; ''; end
+
       def parser
         @parser ||= create_parser
       end
@@ -75,20 +83,16 @@ module Luban
         instance_eval(&config_blk) unless config_blk.nil?
       end
 
-      def setup_default_starter
-        method = @starter_method
-        if has_commands?
-          action :dispatch_command
-        else
-          action do |**opts|
-            raise NotImplementedError, "#{self.class.name}##{method} is an abstract method."
-          end
+      def setup_default_action
+        method = @action_method
+        action do |**opts|
+          raise NotImplementedError, "#{self.class.name}##{method} is an abstract method."
         end
       end
 
-      def dispatch_command(cmd:, argv:, **params)
+      def dispatch_command(context, cmd:, argv:, **params)
         validate_command(cmd)
-        send(cmd, argv)
+        context.send(commands[cmd].action_method, argv)
       end
 
       def validate_command(cmd)

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

@@ -8,15 +8,14 @@ module Luban
         
         def configure(&blk); @config_blk = blk; end
 
-        def help_command(auto_help: true, &blk)
+        def help_command(**opts, &blk)
           if block_given?
-            command(:help, &blk)
+            command(**opts, &blk)
           else
-            command(:help) do
+            command(:help, **opts) do
               desc "List all commands or help for one command"
               argument :command, "Command to help for", 
                        type: :symbol, required: false
-              self.auto_help if auto_help
               action :show_help_for_command
             end
           end
@@ -99,29 +98,45 @@ module Luban
                     blk
                   end
         if handler.nil?
-          raise ArgumentError, "Code block to execute command #{@starter_method} is MISSING."
+          raise ArgumentError, "Code block to execute command #{@action_name} is MISSING."
         end
         _base = self
         parse_method = preserve_argv ? :parse : :parse!
-        @app.define_singleton_method(@starter_method) do |argv=_base.default_argv|
-          _base.send(parse_method, argv)
-          begin
-            if _base.result[:opts][:help]
-              _base.show_help
-            elsif _base.result[:opts][:version]
-              _base.show_version
-            else
-              _base.validate_required_options
-              _base.validate_required_arguments
-              instance_exec(**_base.result, &handler)
-            end
-          rescue OptionParser::ParseError, Error => e
-            _base.on_parse_error(e)
+        define_action_method do |argv = _base.default_argv|
+          _base.send(:process, self, parse_method, argv) do |result|
+            instance_exec(**result, &handler)
           end
         end
         @action_defined = true
       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
+      end
+
+      def process(context, parse_method, argv)
+        send(parse_method, argv)
+        if result[:opts][:help]
+          show_help
+        elsif result[:opts][:version]
+          show_version
+        else
+          if has_commands?
+            dispatch_command(context, **result)
+          else
+            validate_required_options
+            validate_required_arguments
+            yield result
+          end
+        end
+      rescue OptionParser::ParseError, Error => e
+        on_parse_error(e)
+      end
+
       def on_parse_error(error)
         show_error_and_exit(error)
       end

data/lib/luban/cli/command.rb

@@ -2,16 +2,20 @@ module Luban
   module CLI
     class Command < Base
       attr_reader :name
+      attr_reader :command_chain
 
-      def initialize(app, name, &config_blk)
-        super
+      def initialize(app, name, command_chain: [name], **opts, &config_blk)
         @name = name
+        @command_chain = command_chain
+        super(app, name, **opts, &config_blk)
       end
 
+      def default_prefix; '__command_'; end
+
       protected
 
       def compose_banner
-        "Usage: #{program_name} #{name} #{compose_synopsis}"
+        "Usage: #{program_name} #{command_chain.map(&:to_s).join(' ')} #{compose_synopsis}"
       end
     end
   end

data/lib/luban/cli/commands.rb

@@ -6,21 +6,7 @@ module Luban
         base.send(:include, InstanceMethods)
       end
 
-      module ClassMethods
-        def inherited(subclass)
-          # Ensure commands from base class
-          # got inherited to its subclasses
-          subclass.instance_variable_set(
-            '@commands',
-            Marshal.load(Marshal.dump(instance_variable_get('@commands')))
-          )
-          super
-        end
-
-        def commands
-          @commands ||= {}
-        end
-
+      module CommonMethods
         def list_commands
           commands.keys
         end
@@ -32,32 +18,62 @@ module Luban
         def has_commands?
           !commands.empty?
         end
+      end
+
+      module ClassMethods
+        include CommonMethods
+
+        def commands
+          @commands ||= {}
+        end
 
-        def command(cmd, &blk)
-          commands[cmd] = Command.new(self, cmd, &blk)
+        def command_class(cmd)
+          "#{classify(cmd)}Command"
+        end
+
+        def command(app = self, cmd, **opts, &blk)
+          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)
-          commands.delete(cmd)
-          undef_method(cmd)
+          undef_method(commands.delete(cmd).action_method)
+        end
+
+        protected
+
+        def classify(cmd)
+          cmd = cmd.to_s.dup
+          cmd.gsub!(/\/(.?)/){ "::#{$1.upcase}" }
+          cmd.gsub!(/(?:_+|-+)([a-z])/){ $1.upcase }
+          cmd.gsub!(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+          cmd
         end
       end
 
       module InstanceMethods
+        include CommonMethods
+
         def commands
           self.class.commands
         end
 
-        def list_commands
-          commands.keys
-        end
-
-        def has_command?(cmd)
-          self.class.has_command?(cmd)
+        def command(cmd, **opts, &blk)
+          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 has_commands?
-          self.class.has_commands?
+        def undef_command(cmd)
+          self.class.undef_command(cmd)
         end
       end
     end

data/lib/luban/cli/version.rb

@@ -1,5 +1,5 @@
 module Luban
   module CLI
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: luban-cli
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Rubyist Chi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-02 00:00:00.000000000 Z
+date: 2015-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler