cl 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7dbb945fc479c46219fa0aa0f57b6b3a6ed935de
-  data.tar.gz: d7011478b8db611917ad9adc6826e787b425f3e2
+  metadata.gz: 111acf22811807b4d15e0809ce6572d621446e47
+  data.tar.gz: 9a6b0db3a509ee87bc9206e1ea2093e108ba7821
 SHA512:
-  metadata.gz: eb8c51c3e073bc619f3c2247c085a2b0b40e32eb3acfc6deeb1a4a1a5054ed2cbedbb68056d2d3950c3da01fcfca6609ba33e2d1790929811880f0b5b8bdeebe
-  data.tar.gz: b8eff80a773703c9921fdddc59d41c0c5b6bfc8e58e3359f9b13130735329d6f8acf24ed70fa381a88af6492b798016f756e4fb6c39908b00bd0501b55c773bf
+  metadata.gz: 3e78849c155cdabd3b05dd5740ff4ef2308d67b315d9937f815fb951b5856de314a3b1342dbf6411ba4fd3e6d953114b1d3ab526a0d929877b0c50003d80aa30
+  data.tar.gz: 1991a74dd9085e2ddcb09ed80e64845666524803edc5fd10775e4b2d3fb8912d3f075cc5cad788274681581310e2ecee4a8d8943f14056cc9fe6f4444ba6b2a7

data/Gemfile

@@ -1,3 +1,5 @@
+source 'https://rubygems.org'
+
 group :test do
   gem 'rspec'
 end

data/Gemfile.lock

@@ -1,4 +1,5 @@
 GEM
+  remote: https://rubygems.org/
   specs:
     diff-lcs (1.3)
     rspec (3.5.0)
@@ -22,4 +23,4 @@ DEPENDENCIES
   rspec
 
 BUNDLED WITH
-   1.14.5
+   1.14.6

data/NOTES.md

@@ -0,0 +1,25 @@
+Usage: gem release [gemspec] [options]
+
+  Options:
+    -t, --[no-]tag                   Create a git tag and push it to the destination (defaults to false)
+    -d, --destination DESTINATION    Destination git repository (defaults to origin)
+    -k, --key KEY                    Use the given API key from ~/.gem/credentials (not set by default)
+        --host HOST                  Push to a gemcutter-compatible host other than rubygems.org (not set by default)
+
+
+  Common Options:
+    -h, --help                       Get help on this command
+    -V, --[no-]verbose               Set the verbose level of output
+    -q, --quiet                      Silence command progress meter
+        --silent                     Silence rubygems output
+        --config-file FILE           Use this config file instead of default
+        --backtrace                  Show stack backtrace on errors
+        --debug                      Turn on Ruby debugging
+        --norc                       Avoid loading any .gemrc file
+
+
+  Arguments:
+    gemspec - optional gemspec file name, will use the first *.gemspec if not specified
+
+  Summary:
+    Build gem from a gemspec and push to rubygems.org

data/README.md

@@ -1,13 +1,12 @@
-# CLI
+# CL [![Build Status](https://travis-ci.org/svenfuchs/cl.svg?branch=master)](https://travis-ci.org/svenfuchs/cl)
 
 This library wraps Ruby's `OptionParser` in order to make it easier to use it in an object oriented context.
 
 ## Usage
 
-```
+```ruby
 module Owners
-  class Add < Struct.new(:args, :opts)
-    include Cli::Cmd
+  class Add < Cli::Cmd
 
     register 'owners:add'
 

data/examples/args/cast.rb

@@ -0,0 +1,63 @@
+require 'cl'
+
+class Bool < Cl::Cmd
+  arg :bool, type: :bool
+
+  def run
+    [self.registry_key, bool: bool]
+  end
+end
+
+class Types < Cl::Cmd
+  arg :a, type: :bool
+  arg :b, type: :int
+  arg :c, type: :float
+  arg :d
+
+  def run
+    [self.registry_key, a: a, b: b, c: c, d: d]
+  end
+end
+
+def output(cmd, args)
+  args = args.map { |key, value| "#{key}=#{value.inspect}" }.join(' ')
+  puts "Called #{cmd} with #{args}"
+end
+
+output *Cl.run(*%w(bool on))
+# Output:
+# Called bool with bool=true
+
+output *Cl.run(*%w(bool on))
+# Output:
+# Called bool with bool=true
+
+output *Cl.run(*%w(bool on))
+# Output:
+# Called bool with bool=true
+
+output *Cl.run(*%w(bool on))
+# Output:
+# Called bool with bool=true
+
+output *Cl.run(*%w(types true 1 1.2 foo))
+# Output:
+# Called types with a=true b=1 c=1.2 d="foo"
+
+output *Cl.run(*%w(types true 1 1.2))
+# Output:
+# Too many arguments (given: 5, allowed: 4)
+#
+# Usage: cast.rb types [a (bool)] [b (int)] [c (float)] [d]
+
+output *Cl.run(*%w(types true one 1.2))
+# Output:
+# Wrong argument type (given: "one", expected: int)
+#
+# Usage: cast.rb types [a (bool)] [b (int)] [c (float)] [d]
+
+output *Cl.run(*%w(types true 1 one))
+# Output:
+# Wrong argument type (given: "one", expected: float)
+#
+# Usage: cast.rb types [a (bool)] [b (int)] [c (float)] [d]

data/examples/args/opts.rb

@@ -0,0 +1,32 @@
+require 'cl'
+
+class Opts < Cl::Cmd
+  opt '-p', '--path PATH' do |value|
+    opts[:path] = value
+  end
+
+  opt '-v', '--verbose' do
+    opts[:verbose] = true
+  end
+
+  def run
+    [self.registry_key, args, opts]
+  end
+end
+
+def output(cmd, args, opts)
+  puts "Called #{cmd} with args=#{args} opts=#{opts}"
+end
+
+output *Cl.run(*%w(opts -p path -v))
+# Output:
+# Called cast with args=[] opts={:path=>"path", :verbose=>true}
+
+output *Cl.run(*%w(opts --path path --verbose))
+# Output:
+# Called cast with args=[] opts={:path=>"path", :verbose=>true}
+
+output *Cl.run(*%w(opts one -p path two -v three))
+# Output:
+# Called cast with args=["one", "two", "three"] opts={:path=>"path", :verbose=>true}
+

data/examples/args/required.rb

@@ -0,0 +1,35 @@
+require 'cl'
+
+class Required < Cl::Cmd
+  arg :one, required: true
+  arg :two
+
+  def run
+    [self.registry_key, one: one, two: two]
+  end
+end
+
+def output(cmd, args)
+  args = args.map { |key, value| "#{key}=#{value.inspect}" }.join(' ')
+  puts "Called #{cmd} with #{args}"
+end
+
+output *Cl.run(*%w(required one two))
+# Output:
+# Called required with one="one" two="two"
+
+output *Cl.run(*%w(required one))
+# Output:
+# Called required with one="one" two=nil
+
+output *Cl.run(*%w(required))
+# Output:
+# Missing arguments (given: 0, required: 1)
+#
+# Usage: args.rb required one [two]
+
+output *Cl.run(*%w(required one two three))
+# Output:
+# Too many arguments (given: 3, allowed: 2)
+#
+# Usage: args.rb required one [two]

data/examples/args/splat.rb

@@ -0,0 +1,52 @@
+require 'cl'
+
+class SplatLeft < Cl::Cmd
+  register 'splat:left'
+
+  arg :one, type: :array
+  args :two, :three
+
+  def run
+    [self.registry_key, one: one, two: two, three: three]
+  end
+end
+
+class SplatMiddle < Cl::Cmd
+  register 'splat:middle'
+
+  arg :one
+  arg :two, type: :array
+  arg :three
+
+  def run
+    [self.registry_key, one: one, two: two, three: three]
+  end
+end
+
+class SplatRight < Cl::Cmd
+  register 'splat:right'
+
+  args :one, :two
+  arg :three, type: :array
+
+  def run
+    [self.registry_key, one: one, two: two, three: three]
+  end
+end
+
+def output(cmd, args)
+  args = args.map { |key, value| "#{key}=#{value.inspect}" }.join(' ')
+  puts "Called #{cmd} with #{args}"
+end
+
+output *Cl.run(*%w(splat left foo bar baz buz))
+# Output:
+# Called splat:left with one=["foo", "bar"] two="baz" three="buz"
+
+output *Cl.run(*%w(splat middle foo bar baz buz))
+# Output:
+# Called splat:middle with one="foo" two=["bar", "baz"] three="buz"
+
+output *Cl.run(*%w(splat right foo bar baz buz))
+# Output:
+# Called splat:middle with one="foo" two="bar" three=["baz", "buz"]

data/examples/gem.rb

@@ -0,0 +1,81 @@
+require 'cl'
+
+module Gem
+  module Release
+    module Cmds
+      class Release < Cl::Cmd
+        arg :gemspec
+
+        opt '-h', '--host HOST' do |value|
+          opts[:host] = value
+        end
+
+        opt '-k', '--key KEY' do |value|
+          opts[:key] = value
+        end
+
+        opt '-q', '--quiet' do
+          opts[:version] = true
+        end
+
+        def run
+          [self.registry_key, args, opts]
+        end
+      end
+
+      class Bump < Cl::Cmd
+        OPTS = {
+          commit: true
+        }
+
+        opt '-v', '--version VERSION', 'the version to bump to [1.1.1|major|minor|patch|pre|rc|release]' do  |value|
+          opts[:version] = value
+        end
+
+        opt '--no-commit', 'bump the version, but do not commit' do
+          opts[:commit] = false
+        end
+
+        def run
+          [self.registry_key, args, opts]
+        end
+      end
+    end
+  end
+end
+
+Cl.runner = :multi
+Cl.run(*%w(help))
+puts
+
+# Type "gem.rb help COMMAND [SUBCOMMAND]" for more details:
+#
+# gem.rb release [gemspec] [options]
+# gem.rb bump [options]
+
+Cl.run(*%w(help release))
+puts
+
+# Usage: gem.rb release [gemspec] [options]
+#
+# -h --host HOST
+# -k --key KEY
+# -q --quiet
+
+Cl.run(*%w(help bump))
+puts
+
+# Usage: gem.rb bump [options]
+#
+# -v --version VERSION # the version to bump to [1.1.1|major|minor|patch|pre|rc|release]
+# --no-commit          # bump the version, but do not commit
+
+cmds = Cl.run(*%w(bump -v 1.1.1 release foo.gemspec -h host -k key -q))
+puts 'Commands run:'
+cmds.each do |(cmd, args, opts)|
+  puts "#{cmd} with args=#{args} opts=#{opts}"
+end
+
+# Commands run:
+# bump with args=[] opts={:version=>"1.1.1"}
+# release with args=["foo.gemspec"] opts={:host=>"host", :key=>"key", :version=>true}

data/examples/heroku.rb

@@ -0,0 +1,41 @@
+require 'cl'
+
+module Heroku
+  module Apps
+    class Create < Cl::Cmd
+      register 'apps:create'
+
+      arg :name, required: true
+
+      opt '-o', '--org ORG' do |value|
+        opts[:org] = value
+      end
+
+      def run; [registry_key, args, opts] end
+    end
+
+    class List < Cl::Cmd
+      register 'apps:info'
+
+      opt '-a', '--app APP' do |value|
+        opts[:app] = value
+      end
+
+      def run; [registry_key, args, opts] end
+    end
+  end
+end
+
+def output(cmd, args, opts)
+  puts "Called #{cmd} with args=#{args} opts=#{opts}"
+end
+
+output *Cl.run(*%w(apps:create name -o org))
+# Called apps:create with args=["name"] opts={:org=>"org"}
+
+output *Cl.run(*%w(apps create name -o org))
+# Called apps:create with args=["name"] opts={:org=>"org"}
+
+output *Cl.run(*%w(apps:info -a app))
+# Called apps:create with args=["app"] opts={}
+

data/examples/multi.rb

@@ -0,0 +1,50 @@
+require 'cl'
+
+module Rakeish
+  module Db
+    class Create < Cl::Cmd
+      register 'db:create'
+
+      arg :name
+
+      def run; [registry_key, args, opts] end
+    end
+
+    class Drop < Cl::Cmd
+      register 'db:drop'
+
+      arg :name
+
+      opt '-f', '--force' do
+        opts[:force] = true
+      end
+
+      def run; [registry_key, args, opts] end
+    end
+
+    class Migrate < Cl::Cmd
+      register 'db:migrate'
+
+      arg :name
+
+      opt '-v', '--version VERSION' do |value|
+        opts[:version] = value
+      end
+
+      def run; [registry_key, args, opts] end
+    end
+  end
+end
+
+def output(result)
+  result.each do |cmd, args, opts|
+    puts "Called #{cmd} with args=#{args} opts=#{opts}"
+  end
+end
+
+Cl.runner = :multi
+output Cl.run(*%w(db:drop production -f db:create db:migrate production -v 1))
+# Output:
+# Called db:drop with args=["production"] opts={:force=>true}
+# Called db:create with args=[] opts={}
+# Called db:migrate with args=["production"] opts={:version=>"1"}

data/lib/cl.rb

@@ -1,18 +1,44 @@
 require 'cl/cmd'
 require 'cl/help'
-require 'cl/runner'
+require 'cl/runner/default'
+require 'cl/runner/multi'
 
 module Cl
+  class Error < StandardError
+    MSGS = {
+      missing_args:  'Missing arguments (given: %s, required: %s)',
+      too_many_args: 'Too many arguments (given: %s, allowed: %s)',
+      wrong_type:    'Wrong argument type (given: %s, expected: %s)'
+    }
+
+    def initialize(msg, *args)
+      super(MSGS[msg] ? MSGS[msg] % args : msg)
+    end
+  end
+
+  ArgumentError = Class.new(Error)
+
   def included(const)
     const.send(:include, Cmd)
   end
 
   def run(*args)
-    Runner.new(*args).run
+    runner(*args).run
+  rescue Error => e
+    abort [e.message, runner(:help, *args).cmd.help].join("\n\n")
   end
 
-  def help
-    Runner.new(:help).run
+  def help(*args)
+    runner(:help, *args).run
+  end
+
+  attr_writer :runner
+  @runner = :default
+
+  def runner(*args)
+    args = args.flatten
+    runner = args.first.to_s == 'help' ? :default : @runner
+    Runner.const_get(runner.to_s.capitalize).new(*args)
   end
 
   extend self

data/lib/cl/arg.rb

@@ -0,0 +1,60 @@
+module Cl
+  class Arg < Struct.new(:name, :opts)
+    TRUE  = /^(true|yes|on)$/
+    FALSE = /^(false|no|off)$/
+
+    def define(const)
+      const.send(:attr_accessor, name)
+    end
+
+    def set(cmd, value)
+      cmd.send(:"#{name}=", cast(value))
+    end
+
+    def type
+      opts[:type] || :str
+    end
+
+    def splat?
+      type == :array
+    end
+
+    def required?
+      !!opts[:required]
+    end
+
+    def cast(value)
+      case type
+      when nil
+        value
+      when :array
+        Array(value).flatten.map { |value| value.split(',') }.flatten
+      when :string, :str
+        value.to_s
+      when :boolean, :bool
+        return true  if value.to_s =~ TRUE
+        return false if value.to_s =~ FALSE
+        !!value
+      when :integer, :int
+        Integer(value)
+      when :float
+        Float(value)
+      else
+        raise ArgumentError, "Unknown type: #{type}" if value
+      end
+    rescue ::ArgumentError => e
+      raise ArgumentError.new(:wrong_type, value.inspect, type)
+    end
+
+    def to_s
+      str = name
+      case type
+      when :array          then str = "#{str}.."
+      when :integer, :int  then str = "#{str} (int)"
+      when :boolean, :bool then str = "#{str} (bool)"
+      when :float          then str = "#{str} (float)"
+      end
+      required? ? str : "[#{str}]"
+    end
+  end
+end

data/lib/cl/args.rb

@@ -0,0 +1,66 @@
+require 'cl/arg'
+
+module Cl
+  class Args
+    include Enumerable
+
+    def define(const, name, opts = {})
+      arg = Arg.new(name, opts)
+      arg.define(const)
+      args << arg
+    end
+
+    def apply(cmd, args)
+      return args unless self.args.any?
+      args = grouped(args)
+      validate(args)
+      args.map { |(arg, value)| arg.set(cmd, value) }.flatten(1)
+    end
+
+    def each(&block)
+      args.each(&block)
+    end
+
+    def index(*args, &block)
+      self.args.index(*args, &block)
+    end
+
+    def args
+      @args ||= []
+    end
+
+    private
+
+      def validate(args)
+        raise ArgumentError.new(:missing_args, args.size, required) if args.size < required
+        raise ArgumentError.new(:too_many_args, args.size, allowed) if args.size > allowed && !splat?
+      end
+
+      def allowed
+        args.size
+      end
+
+      def splat?
+        args.any?(&:splat?)
+      end
+
+      def required
+        args.select { |arg| arg.required? }.size
+      end
+
+      def grouped(values)
+        values.inject([0, {}]) do |(ix, group), value|
+          arg = args[ix]
+          if arg && arg.splat?
+            group[arg] ||= []
+            group[arg] << value
+            ix += 1 if args.size + group[arg].size > values.size
+          else
+            group[arg] = value
+            ix += 1
+          end
+          [ix, group]
+        end.last
+      end
+  end
+end

data/lib/cl/cmd.rb

@@ -1,28 +1,50 @@
+require 'cl/args'
 require 'cl/registry'
 
 module Cl
-  module Cmd
-    def self.included(const)
-      const.send :include, Registry
-      const.send :extend, ClassMethods
-    end
+  class Cmd < Struct.new(:args, :opts)
+    include Registry
+
+    class << self
+      def inherited(cmd)
+        cmd.register underscore(cmd.name.split('::').last)
+      end
 
-    module ClassMethods
       def args(*args)
-        args.any? ? @args = args : @args ||= []
+        return @args ||= Args.new unless args.any?
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        args.each { |arg| arg(arg, opts) }
+      end
+
+      def arg(name, opts = {})
+        args.define(self, name, opts)
       end
 
-      def purpose(purpose = nil)
-        purpose ? @purpose = purpose : @purpose
+      def cmd(summary = nil)
+        @summary = summary
       end
 
-      def on(*args, &block)
+      attr_reader :summary
+
+      def opt(*args, &block)
         opts << [args, block]
       end
 
       def opts
-        @opts ||= superclass.respond_to?(:opts) ? superclass.opts : []
+        @opts ||= superclass != Cmd && superclass.respond_to?(:opts) ? superclass.opts.dup : []
+      end
+
+      def underscore(string)
+        string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        downcase
       end
     end
+
+    def initialize(args, opts)
+      args = self.class.args.apply(self, args)
+      opts = self.class::OPTS.merge(opts) if self.class.const_defined?(:OPTS)
+      super
+    end
   end
 end

data/lib/cl/format/cmd.rb

@@ -10,7 +10,7 @@ module Cl
 
       def banner
         banner = []
-        banner << "#{cmd.purpose}\n" if cmd.purpose
+        banner << "#{cmd.summary}\n" if cmd.summary
         banner << "Usage: #{Usage.new(cmd).format}\n"
         banner
       end

data/lib/cl/format/list.rb

@@ -4,7 +4,7 @@ require 'cl/format/usage'
 module Cl
   class Format
     class List < Struct.new(:cmds)
-      HEAD = %(Type "#{$0} help COMMAND [SUBCOMMAND]" for more details:\n)
+      HEAD = %(Type "#{$0.split('/').last} help COMMAND [SUBCOMMAND]" for more details:\n)
 
       def format
         [HEAD, Format::Table.new(list).format].join("\n")
@@ -15,7 +15,7 @@ module Cl
       end
 
       def format_cmd(cmd)
-        ["#{$0} #{Usage.new(cmd).format}", cmd.purpose]
+        ["#{Usage.new(cmd).format}", cmd.summary]
       end
     end
   end

data/lib/cl/format/usage.rb

@@ -2,8 +2,8 @@ module Cl
   class Format
     class Usage < Struct.new(:cmd)
       def format
-        usage = [name]
-        usage += cmd.args.map { |arg| "[#{arg}]" }
+        usage = [$0.split('/').last, name]
+        usage += cmd.args.map(&:to_s)
         usage << '[options]' if opts?
         usage.join(' ')
       end

data/lib/cl/help.rb

@@ -2,9 +2,7 @@ require 'cl/format/cmd'
 require 'cl/format/list'
 
 module Cl
-  class Help < Struct.new(:args, :opts)
-    include Cl::Cmd
-
+  class Help < Cl::Cmd
     register :help
 
     def run
@@ -25,7 +23,11 @@ module Cl
       end
 
       def cmd
-        args && Cl[args.join(':')]
+        args.inject([[], []]) do |(args, cmds), arg|
+          args << arg
+          cmds << Cl[args.join(':')]
+          [args, cmds.compact]
+        end.last.last
       end
   end
 end

data/lib/cl/options.rb

@@ -1,3 +1,5 @@
+require 'optparse'
+
 module Cl
   class Options < OptionParser
     attr_reader :opts

data/lib/cl/runner/default.rb

@@ -0,0 +1,42 @@
+require 'cl/options'
+
+module Cl
+  module Runner
+    class Default
+      attr_reader :const, :args, :opts
+
+      def initialize(*args)
+        args = args.flatten.map(&:to_s)
+        @const, @args, @opts = lookup(args)
+      end
+
+      def run
+        cmd.run
+      end
+
+      def cmd
+        const.new(args, opts)
+      end
+
+      private
+
+        def lookup(args)
+          cmd = keys_for(args).map { |key| Cl[key] }.compact.last
+          cmd || abort("Unknown command: #{args.join(' ')}")
+          opts = Options.new(cmd.opts, args).opts unless cmd == Help
+          [cmd, args - cmds_for(cmd, args), opts]
+        end
+
+        def cmds_for(cmd, args)
+          name = cmd.registry_key.to_s
+          args.take_while do |arg|
+            name = name.sub(/#{arg}(:|$)/, '') if name =~ /#{arg}(:|$)/
+          end
+        end
+
+        def keys_for(args)
+          args.inject([]) { |keys, key| keys << [keys.last, key].compact.join(':') }
+        end
+    end
+  end
+end

data/lib/cl/runner/multi.rb

@@ -0,0 +1,33 @@
+require 'cl/options'
+
+module Cl
+  module Runner
+    class Multi
+      attr_reader :cmds
+
+      def initialize(*args)
+        @cmds = build(group(args))
+      end
+
+      def run
+        cmds.map(&:run)
+      end
+
+      private
+
+        def group(args, cmds = [])
+          args.flatten.map(&:to_s).inject([[]]) do |cmds, arg|
+            cmd = Cl[arg]
+            cmd ? cmds << [cmd] : cmds.last << arg
+            cmds.reject(&:empty?)
+          end
+        end
+
+        def build(cmds)
+          cmds.map do |(cmd, *args)|
+            cmd.new(args, Options.new(cmd.opts, args).opts)
+          end
+        end
+    end
+  end
+end

data/lib/cl/version.rb

@@ -1,3 +1,3 @@
 module Cl
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: cl
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Sven Fuchs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-09 00:00:00.000000000 Z
+date: 2017-08-02 00:00:00.000000000 Z
 dependencies: []
 description: OptionParser based CLI support.
-email: me@svenfuchs.com
+email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -19,10 +19,19 @@ files:
 - Gemfile
 - Gemfile.lock
 - MIT_LICENSE.md
+- NOTES.md
 - README.md
+- examples/args/cast.rb
+- examples/args/opts.rb
+- examples/args/required.rb
+- examples/args/splat.rb
+- examples/gem.rb
+- examples/heroku.rb
+- examples/multi.rb
 - lib/cl.rb
+- lib/cl/arg.rb
+- lib/cl/args.rb
 - lib/cl/cmd.rb
-- lib/cl/cmds.rb
 - lib/cl/format/cmd.rb
 - lib/cl/format/list.rb
 - lib/cl/format/table.rb
@@ -30,7 +39,8 @@ files:
 - lib/cl/help.rb
 - lib/cl/options.rb
 - lib/cl/registry.rb
-- lib/cl/runner.rb
+- lib/cl/runner/default.rb
+- lib/cl/runner/multi.rb
 - lib/cl/version.rb
 homepage: https://github.com/svenfuchs/cl
 licenses:
@@ -52,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: OptionParser based CLI support

data/lib/cl/cmds.rb

@@ -1,28 +0,0 @@
-require 'cl/options'
-
-module Cl
-  class Cmds < Struct.new(:args)
-    def lookup
-      cmd || abort("Unknown command: #{args.join(' ')}")
-      opts = Options.new(cmd.opts, args).opts
-      [cmd, args - cmds, opts]
-    end
-
-    private
-
-      def cmds
-        name = cmd.registry_key.to_s
-        args.take_while do |arg|
-          name = name.sub(/#{arg}(:|$)/, '') if name =~ /#{arg}(:|$)/
-        end
-      end
-
-      def cmd
-        @cmd ||= keys.map { |key| Cl[key] }.compact.last
-      end
-
-      def keys
-        @keys ||= args.inject([]) { |keys, key| keys << [keys.last, key].compact.join(':') }
-      end
-  end
-end

data/lib/cl/runner.rb

@@ -1,20 +0,0 @@
-require 'cl/cmds'
-
-module Cl
-  class Runner
-    attr_reader :const, :args, :opts
-
-    def initialize(*args)
-      args = args.flatten.map(&:to_s)
-      @const, @args, @opts = Cmds.new(args).lookup
-    end
-
-    def run
-      cmd.run
-    end
-
-    def cmd
-      const.new(args, opts)
-    end
-  end
-end