luban-cli 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 275afb8e84ecc64947db6b5e147e37996a7d1df1
+  data.tar.gz: 866526700250c04f22aab3467ba7ee9dbadc1b66
+SHA512:
+  metadata.gz: eb7fcbd25cfe82c7bfcfb99755a1272de32bddf1e12061fedc28a95298e26e1f5d06525717b4341d9debb42dc742acc81f23d93087c477e77f68915f58129416
+  data.tar.gz: 13c432783506cd550ec5a012f2b36e25420669af7f5851145323ccd021958f002982b39b2fa4f8285d56db3dfe99077a1937df93c869b517fbe4fe5d93c00238

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Change log
+
+## Version 0.1.0 (Mar 31, 2015)
+
+Bootstrapped Luban::CLI
+
+Features:
+  * Support general command-line parsing
+    * Support options
+    * Support switches (boolean options)
+    * Support arguments
+    * Support subcommand
+  * Provide base class (Luban::CLI::Base) for command-line application
+
+## Version 0.2.0 (Apr 02, 2015)
+
+Minor enhancements:
+  * Refractor error class
+  * Refractor 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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in luban-cli.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Chi Man Lei
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Luban::CLI
+
+Luban::CLI is a command-line interface for Ruby with a simple lightweight option parser and command handler based on Ruby standard library, OptionParser.
+
+Luban::CLI requires Ruby 2.1 or later. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'luban-cli'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install luban-cli
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/luban/cli/application.rb

@@ -0,0 +1,48 @@
+require 'pathname'
+
+module Luban
+  module CLI
+    class Application < Base
+      attr_reader :rc
+
+      def initialize(starter_method = :run, &config_blk)
+        super(self, starter_method, &config_blk)
+        @rc = init_rc
+        validate
+      end
+
+      def rc_file
+        @rc_file ||= ".#{program_name}rc"
+      end
+
+      def rc_path
+        @rc_path ||= Pathname.new(ENV['HOME']).join(rc_file)
+      end
+
+      def rc_file_exists?
+        File.exists?(rc_path)
+      end
+
+      def default_rc
+        @default_rc ||= {}
+      end
+
+      protected
+
+      def validate; end
+
+      def init_rc
+        if rc_file_exists?
+          default_rc.merge(load_rc_file)
+        else
+          default_rc.clone
+        end
+      end
+
+      def load_rc_file
+        require 'yaml'
+        YAML.load_file(rc_path)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,200 @@
+module Luban
+  module CLI
+    class Argument
+      class InvalidArgumentValue < Error; end
+      class TypeCastingFailed < Error; end
+      
+      attr_reader :name
+      attr_reader :display_name
+      attr_reader :description
+      attr_accessor :value
+
+      def initialize(name, desc, **config, &blk)
+        @name = name
+        @display_name = name.to_s.upcase
+        @description = desc.to_s
+        @handler = block_given? ? blk : ->(v) { v }
+        @config = config
+        init_config
+        verify_config
+        reset
+      end
+
+      def kind
+        @kind ||= self.class.name.split('::').last.downcase
+      end
+
+      def reset
+        @value = set_default_value
+      end
+
+      def value=(v)
+        @value = process(v).tap { |v| validate(v) }
+      end
+
+      def default_type; :string; end
+      def default_imperative; true; end
+
+      def [](key); @config[key]; end
+
+      def required?; @config[:required]; end
+      def optional?; !@config[:required]; end
+      def has_default?; !@config[:default].nil?; end
+      def multiple?; @config[:multiple]; end
+
+      def validate(value = @value)
+        unless valid?(value)
+          raise InvalidArgumentValue, "Invalid value of #{kind} #{display_name}: #{value.inspect}"
+        end
+      end
+
+      def valid?(value = @value)
+        !missing?(value) and match?(value) and within?(value) and assured?(value)
+      end
+
+      def missing?(value = @value)
+        required? and value.nil?
+      end
+
+      def match?(value = @value)
+        @config[:match].nil? ? true : !!@config[:match].match(value)
+      end
+
+      def within?(value = @value)
+        @config[:within].nil? ? true : @config[:within].include?(value)
+      end
+
+      def assured?(value = @value)
+        @config[:assure].nil? ? true : !!@config[:assure].call(value)
+      end
+
+      protected
+
+      def init_config
+        @config[:type] ||= default_type
+        @config[:required] = default_imperative if @config[:required].nil?
+        @config[:required] = !!@config[:required]
+        @config[:multiple] = !!@config[:multiple]
+      end
+
+      def verify_config
+        verify_config_type if @config.has_key?(:type)
+        verify_config_default_value if @config.has_key?(:default)
+        verify_config_match if @config.has_key?(:match)
+        verify_config_within if @config.has_key?(:within)
+        verify_config_assurance if @config.has_key?(:assure)
+      end
+
+      def verify_config_type
+        @config[:type] = normalize_type(@config[:type])
+        unless respond_to?(cast_method(@config[:type]), true)
+          raise ArgumentError, "NOT castable type for #{kind} #{display_name}: #{@config[:type]}"
+        end
+      end
+
+      def normalize_type(type); type.to_s.downcase.to_sym; end
+
+      def verify_config_default_value
+        err_msg = nil
+        type = @config[:type]
+        default = @config[:default]
+        unless type.nil?
+          if multiple?
+            unless default.is_a?(Array) and
+                   default.all? { |v| send("#{type}?", v) }
+              err_msg = "must be an array of #{type} instances"
+            end
+          else
+            unless send("#{type}?", default)
+              err_msg = "must be an instance of #{type}"
+            end
+          end
+        end
+        unless err_msg.nil?
+          raise ArgumentError, "Default value for #{kind} #{display_name} #{err_msg}"
+        end
+        unless (multiple? ? default : [default]).all? { |v| valid?(v) }
+          raise ArgumentError, "Invalid default value for #{kind} #{display_name}: #{default.inspect}"
+        end
+      end
+
+      def verify_config_match
+        unless @config[:match].respond_to?(:match)
+          raise ArgumentError, "Matching pattern of #{kind} #{display_name} must respond to #match."
+        end
+      end
+
+      def verify_config_within
+        unless @config[:within].respond_to?(:include?)
+          raise ArgumentError, "Possible values of #{kind} #{display_name} must respond to #include?."
+        end
+      end
+
+      def verify_config_assurance
+        unless @config[:assure].respond_to?(:call)
+          raise ArgumentError, "Assurance of #{kind} #{display_name} must be callable."
+        end
+      end
+
+      def set_default_value(value = nil)
+        if !@config[:default].nil? and value.nil?
+          @config[:default]
+        else
+          value
+        end
+      end
+
+      def process(value)
+        post_process(@handler.call(pre_process(value)))
+      end
+
+      def pre_process(value)
+        cast_type(set_default_value(value))
+      end
+
+      def post_process(value); value; end
+
+      def cast_type(value)
+        unless value.nil?
+          if multiple?
+            value.map! { |v| cast_value(v) }
+          else
+            value = cast_value(value)
+          end
+        end
+        value
+      end
+
+      def cast_value(value)
+        if send("#{@config[:type]}?", value)
+          value
+        else
+          method(cast_method(@config[:type])).call(value)
+        end
+      rescue StandardError => e
+        raise TypeCastingFailed, "Type casting to #{@config[:type]} for #{kind} #{display_name} failed: #{e.class.name} - #{e.message}"
+      end
+
+      def cast_method(type); "cast_#{type}"; end
+
+      def cast_string(value); String(value); end
+      def cast_integer(value); Integer(value); end
+      def cast_float(value); Float(value); end
+      def cast_symbol(value); value.to_sym; end
+      def cast_time(value); Time.parse(value); end
+      def cast_date(value); Date.parse(value); end
+      def cast_datetime(value); DateTime.parse(value); end
+      BoolValues = {"true" => true, "false" => false, "yes" => true, "no" => false }
+      def cast_bool(value); !!BoolValues[value.to_s.downcase]; end
+
+      def string?(value); value.is_a?(String); end
+      def integer?(value); value.is_a?(Integer); end
+      def float?(value); value.is_a?(Float); end
+      def symbol?(value); value.is_a?(Symbol); end
+      def time?(value); value.is_a?(Time); end
+      def date?(value); value.is_a?(Date); end
+      def datetime?(value); value.is_a?(DateTime); end
+      def bool?(value); value.is_a?(TrueClass) or value.is_a?(FalseClass); end
+    end
+  end
+end

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

@@ -0,0 +1,260 @@
+require 'optparse'
+
+# Remove duplicate default options in OptionParser
+# for ARGV which never appear in option summary
+OptionParser::Officious.delete('help')
+OptionParser::Officious.delete('version')
+
+module Luban
+  module CLI
+    class Base
+      include Commands
+
+      class MissingCommand < Error; end
+      class InvalidCommand < Error; end
+      class MissingRequiredOptions < Error; end
+      class MissingRequiredArguments < Error; end
+
+      DefaultSummaryWidth = 32
+      DefaultSummaryIndent = 4
+      DefaultTitleIndent = 2
+
+      attr_reader :program_name
+      attr_reader :options
+      attr_reader :arguments
+      attr_reader :summary
+      attr_reader :description
+      attr_reader :version
+      attr_reader :result
+      attr_reader :default_argv
+
+      attr_accessor :title_indent
+      attr_accessor :summary_width
+      attr_accessor :summary_indent
+
+      def initialize(app, starter_method, &config_blk)
+        @app = app
+        @starter_method = starter_method
+        @action_defined = false
+
+        @program_name = default_program_name
+        @options = {}
+        @arguments = {}
+        @summary = ''
+        @description = ''
+        @version = ''
+        @default_argv = ARGV
+        @result = { cmd: nil, argv: @default_argv, args: {}, opts: {} }
+
+        @title_indent = DefaultTitleIndent
+        @summary_width = DefaultSummaryWidth
+        @summary_indent = DefaultSummaryIndent
+
+        configure(&config_blk)
+        setup_default_starter unless @action_defined
+      end
+
+      def parser
+        @parser ||= create_parser
+      end
+
+      def default_program_name
+        @default_program_name ||= File.basename($0, '.*')
+      end
+
+      def reset
+        @options.each_value { |o| o.reset }
+        @arguments.each_value { |a| a.reset }
+        @result = { cmd: nil, argv: @default_argv, args: {}, opts: {} }
+      end
+
+      protected
+
+      def configure(&blk)
+        config_blk = block_given? ? blk : self.class.config_blk
+        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
+        end
+      end
+
+      def dispatch_command(cmd:, argv:, **params)
+        validate_command(cmd)
+        send(cmd, argv)
+      end
+
+      def validate_command(cmd)
+        if cmd.nil?
+          raise MissingCommand, "Missing command. Expected command: #{list_commands.join(', ')}"
+        end
+        unless has_command?(cmd)
+          raise InvalidCommand, "Invalid command. Expected command: #{list_commands.join(', ')}"
+        end
+      end
+
+      def validate_required_options
+        missing_opts = @options.each_value.select(&:missing?).collect(&:display_name)
+        unless missing_opts.empty?
+          raise MissingRequiredOptions, "Missing required option(s): #{missing_opts.join(', ')}"
+        end
+      end
+
+      def validate_required_arguments
+        missing_args = @arguments.each_value.select(&:missing?).collect(&:display_name)
+        unless missing_args.empty?
+          raise MissingRequiredArguments, "Missing required argument(s): #{missing_args.join(', ')}"
+        end
+      end      
+
+      def create_parser
+        @parser = OptionParser.new
+        add_parser_usage
+        add_parser_version unless @version.empty?
+        add_parser_options unless options.empty?
+        add_parser_arguments unless arguments.empty?
+        add_parser_summary unless summary.empty?
+        add_parser_description unless description.empty?
+        add_parser_defaults unless options.values.all? { |o| o.default_str.empty? }
+        add_parser_commands if has_commands?
+        @parser
+      end
+
+      def add_parser_usage
+        parser.banner = compose_banner
+        text
+      end
+
+      def compose_banner
+        "Usage: #{program_name} #{compose_synopsis}"
+      end
+
+      def compose_synopsis
+        if has_commands?
+          compose_synopsis_with_commands
+        else
+          compose_synopsis_without_commands
+        end
+      end
+
+      def compose_synopsis_with_commands
+        "[options] command [command options] [arguments ...]"
+      end
+
+      def compose_synopsis_without_commands
+        "#{compose_synopsis_with_options}#{compose_synopsis_with_arguments}"
+      end
+
+      def compose_synopsis_with_options
+        options.empty?  ? '' : '[options] '
+      end
+
+      def compose_synopsis_with_arguments
+        synopsis = ''
+        @arguments.each_value do |arg|
+          synopsis += arg.required? ? arg.display_name : "[#{arg.display_name}]"
+          synopsis += "[, #{arg.display_name}]*" if arg.multiple?
+          synopsis += ' '
+        end
+        synopsis
+      end
+
+      def text(string = nil)
+        @parser.separator(string)
+      end
+
+      def add_parser_version
+        parser.version = @version
+      end
+
+      def add_parser_options
+        add_section("Options") do
+          @options.each_value do |option|
+            parser.on(*option.specs) { |v| option.value = v }
+          end
+        end
+      end
+
+      def add_parser_arguments
+        add_section("Arguments") do |rows|
+          @arguments.each_value do |arg|
+            rows.concat(summarize(arg.display_name, arg.description))
+          end
+        end
+      end
+
+      def add_parser_summary
+        add_section("Summary", wrap(summary, summary_width * 2))
+      end
+
+      def add_parser_description
+        add_section("Description", wrap(description, summary_width * 2))
+      end
+
+      def add_parser_defaults
+        add_section("Defaults", options.values.map(&:default_str))
+      end
+
+      def add_parser_commands
+        add_section("Commands") do |rows|
+          commands.each_value do |cmd|
+            rows.concat(summarize(cmd.name, cmd.summary))
+          end
+        end
+      end
+
+      def add_section(title, rows = [], &blk)
+        text compose_title(title)
+        yield rows if block_given?
+        rows.each { |row| text compose_row(row) }
+        text
+      end
+
+      def compose_title(title, indent = ' ' * title_indent, suffix = ':')
+        "#{indent}#{title}#{suffix}"
+      end
+
+      def compose_row(string, indent = ' ' * summary_indent)
+        "#{indent}#{string}"
+      end
+
+      def summarize(item, summary, width = summary_width, max_width = width - 1)
+        item_rows = wrap(item.to_s, max_width)
+        summary_rows = wrap(summary, max_width)
+        num_of_rows = [item_rows.size, summary_rows.size].max
+        rows = (0...num_of_rows).collect do |i|
+                 compose_summary(item_rows[i], summary_rows[i], width)
+               end
+        return rows
+      end
+
+      def compose_summary(item, summary, width)
+        "%-#{width}s %-#{width}s" % [item, summary]
+      end
+
+      def wrap(string, width)
+        rows = []
+        row = ''
+        string.split(/\s+/).each do |word|
+          if row.size + word.size >= width
+            rows << row
+            row = word
+          elsif row.empty?
+            row = word
+          else
+            row << ' ' << word
+          end
+        end
+        rows << row if row
+        rows
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+module Luban
+  module CLI
+    class Base
+      include Commands
+
+      class << self
+        attr_reader :config_blk
+        
+        def configure(&blk); @config_blk = blk; end
+
+        def help_command(auto_help: true, &blk)
+          if block_given?
+            command(:help, &blk)
+          else
+            command(:help) 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
+        end
+        alias_method :auto_help_command, :help_command
+      end
+
+      def program(name)
+        @program_name = name.to_s unless name.nil? 
+      end
+
+      def desc(string)
+        @summary = string.to_s unless string.nil?
+      end
+
+      def long_desc(string)
+        @description = string.to_s unless string.nil?
+      end
+
+      def option(name, desc, nullable: false, **config, &blk)
+        @options[name] = if nullable
+                           NullableOption.new(name, desc, **config, &blk)
+                         else
+                           Option.new(name, desc, **config, &blk)
+                         end
+      end
+
+      def switch(name, desc, negatable: false, **config, &blk)
+        @options[name] = if negatable
+                           NegatableSwitch.new(name, desc, **config, &blk)
+                         else
+                           Switch.new(name, desc, **config, &blk)
+                         end
+      end
+
+      def argument(name, desc, **config, &blk)
+        @arguments[name] = Argument.new(name, desc, **config, &blk)
+      end
+
+      def help(short: :h, desc: "Show this help message.", &blk)
+        switch :help, desc, short: short, &blk
+      end
+      alias_method :auto_help, :help
+
+      def show_help; puts parser.help; end
+
+      def show_help_for_command(args:, **params)
+        if args[:command].nil?
+          show_help
+        else
+          commands[args[:command]].show_help
+        end
+      end
+
+      def version(ver = nil, short: :v, desc: "Show #{program_name} version.", &blk)
+        if ver.nil?
+          @version
+        else
+          @version = ver.to_s
+          switch :version, desc, short: short, &blk
+        end
+      end
+
+      def show_version; puts parser.ver; end
+
+      def action(method_name = nil, &blk)
+        create_action(method_name, preserve_argv: true, &blk)
+      end
+
+      def action!(method_name = nil, &blk)
+        create_action(method_name, preserve_argv: false, &blk)
+      end
+
+      protected
+
+      def create_action(method_name = nil, preserve_argv: true, &blk)
+        handler = if method_name
+                    lambda { |**opts| send(method_name, **opts) }
+                  elsif block_given?
+                    blk
+                  end
+        if handler.nil?
+          raise ArgumentError, "Code block to execute command #{@starter_method} 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)
+          end
+        end
+        @action_defined = true
+      end
+
+      def on_parse_error(error)
+        show_error_and_exit(error)
+      end
+
+      def show_error_and_exit(error)
+        show_error(error)
+        show_help
+        exit 64 # Linux standard for bad command line
+      end
+
+      def show_error(error)
+        puts "#{error.message} (#{error.class.name})"
+        puts
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Luban
+  module CLI
+    class Option < Argument
+      def specs
+        specs = [ description ]
+        specs << build_long_option
+        specs << build_short_option if @config.has_key?(:short)
+        specs << Array if multiple?
+        specs
+      end
+
+      def default_imperative; false; end
+
+      def default_str
+        @default_str ||= has_default? ? build_default_str : ''
+      end
+
+      protected
+
+      def build_default_str
+        "--#{long_opt_name} #{default_value_str.inspect}"
+      end
+
+      def build_long_option
+        "--#{long_opt_name} #{@display_name}"
+      end
+
+      def build_short_option
+        "-#{@config[:short]}"
+      end
+
+      def long_opt_name
+        (@config[:long] || @name).to_s.gsub('_', '-')
+      end
+
+      def default_value_str
+        [*@config[:default]].map(&:to_s).join(",")
+      end
+    end
+
+    class NullableOption < Option
+      def kind; @kind ||= "nullable option"; end
+
+      def value=(val)
+        super
+        @value = true if @value.nil?
+        @value
+      end
+
+      protected
+
+      def build_long_option
+        "--#{long_opt_name} [#{@display_name}]"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Luban
+  module CLI
+    class Base
+      def parse(argv=default_argv)
+        argv = argv.dup
+        parse!(argv)
+      end
+
+      def parse!(argv=default_argv)
+        if commands.empty?
+          parse_without_commands(argv)
+        else
+          parse_with_commands(argv)
+        end
+        update_result(argv)
+      end
+
+      protected
+
+      def parse_with_commands(argv)
+        parser.order!(argv)
+        parse_command(argv)
+      end
+      alias_method :parse_posixly_correct, :parse_with_commands
+
+      def parse_command(argv)
+        cmd = argv.shift
+        cmd = cmd.to_sym unless cmd.nil?
+        @result[:cmd] = cmd
+      end
+
+      def parse_without_commands(argv)
+        parser.permute!(argv)
+        parse_arguments(argv)
+      end
+      alias_method :parse_permutationally, :parse_without_commands
+
+      def parse_arguments(argv)
+        @arguments.each_value do |arg|
+          break if argv.empty?
+          arg.value = arg.multiple? ? argv.slice!(0..-1) : argv.shift
+        end
+      end
+
+      def update_result(argv)
+        @result[:argv] = argv
+        @result[:opts] = options.values.inject({}) { |r, o| r[o.name] = o.value; r }
+        @result[:args] = arguments.values.inject({}) { |r, a| r[a.name] = a.value; r }
+        @result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Luban
+  module CLI
+    class Switch < Option
+      protected
+
+      def init_config
+        super
+        # Ensure value type to be boolean
+        @config[:type] = :bool
+        # Ensure single value instead of multiple
+        @config[:multiple] = false
+        # Ensure default switch state is set properly
+        @config[:default] = !!@config[:default]
+      end
+
+      def build_default_str
+        @config[:default] ? "--#{long_opt_name}" : ""
+      end
+
+      def build_long_option
+        "--#{long_opt_name}"
+      end
+    end
+
+    class NegatableSwitch < Switch
+      def kind; @kind ||= "negatable switch"; end
+
+      protected
+
+      def build_default_str
+        @config[:default] ? "--#{long_opt_name}" : "--no-#{long_opt_name}"
+      end
+
+      def build_long_option
+        "--[no-]#{long_opt_name}"
+      end
+    end
+  end
+end

data/lib/luban/cli/base.rb

@@ -0,0 +1,6 @@
+require_relative "base/argument"
+require_relative "base/option"
+require_relative "base/switch"
+require_relative "base/core"
+require_relative "base/parse"
+require_relative "base/dsl"

data/lib/luban/cli/command.rb

@@ -0,0 +1,18 @@
+module Luban
+  module CLI
+    class Command < Base
+      attr_reader :name
+
+      def initialize(app, name, &config_blk)
+        super
+        @name = name
+      end
+
+      protected
+
+      def compose_banner
+        "Usage: #{program_name} #{name} #{compose_synopsis}"
+      end
+    end
+  end
+end

data/lib/luban/cli/commands.rb

@@ -0,0 +1,65 @@
+module Luban
+  module CLI
+    module Commands
+      def self.included(base)
+        base.extend(ClassMethods)
+        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
+
+        def list_commands
+          commands.keys
+        end
+
+        def has_command?(cmd)
+          commands.has_key?(cmd)
+        end
+
+        def has_commands?
+          !commands.empty?
+        end
+
+        def command(cmd, &blk)
+          commands[cmd] = Command.new(self, cmd, &blk)
+        end
+
+        def undef_command(cmd)
+          commands.delete(cmd)
+          undef_method(cmd)
+        end
+      end
+
+      module InstanceMethods
+        def commands
+          self.class.commands
+        end
+
+        def list_commands
+          commands.keys
+        end
+
+        def has_command?(cmd)
+          self.class.has_command?(cmd)
+        end
+
+        def has_commands?
+          self.class.has_commands?
+        end
+      end
+    end
+  end
+end

data/lib/luban/cli/error.rb

@@ -0,0 +1,5 @@
+module Luban
+  module CLI
+    class Error < StandardError; end
+  end
+end

data/lib/luban/cli/version.rb

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

data/lib/luban/cli.rb

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

data/luban-cli.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'luban/cli/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "luban-cli"
+  spec.version       = Luban::CLI::VERSION
+  spec.authors       = ["Rubyist Chi"]
+  spec.email         = ["rubyist.chi@gmail.com"]
+  spec.description   = %q{Command-line interface for Ruby}
+  spec.summary       = %q{Luban::CLI is a command-line interface for Ruby with a simple lightweight option parser and command handler based on Ruby standard library, OptionParser}
+  spec.homepage      = "https://github.com/lubanrb/cli"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/).grep(%r{^(?!spec|examples)})
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: luban-cli
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Rubyist Chi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Command-line interface for Ruby
+email:
+- rubyist.chi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/luban-cli.rb
+- lib/luban/cli.rb
+- lib/luban/cli/application.rb
+- lib/luban/cli/base.rb
+- lib/luban/cli/base/argument.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
+homepage: https://github.com/lubanrb/cli
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Luban::CLI is a command-line interface for Ruby with a simple lightweight
+  option parser and command handler based on Ruby standard library, OptionParser
+test_files: []