travis-cl 1.2.4

data/examples/_src/readme/requires.erb.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+<%= run sq(<<-'rb')
+  class Add < Cl::Cmd
+    register :add
+
+    opt '--to GROUP'
+    opt '--other GROUP', requires: :to
+
+    def run
+      p to: to, other: other
+    end
+  end
+  rb
+-%>
+
+<%= run "Cl.new('owners').run(%w(add --to one --other two))" %>
+
+<%= out '{:to=>"one", :other=>"two"}' %>
+
+<%= run "Cl.new('owners').run(%w(add --other two))" %>
+
+<%= out sq(<<-'str')
+  Missing option: to (required by other)
+
+  Usage: owners add [options]
+
+  Options:
+
+    --to GROUP         type: string
+    --other GROUP      type: string, requires: to
+    --help             Get help on this command
+  str
+%>

data/examples/_src/readme/runner.erb.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+<%= run sq(<<-'rb')
+  module Git
+    class Pull < Cl::Cmd
+      register :'git:pull'
+
+      arg :branch
+
+      def run
+        p cmd: registry_key, args: args
+      end
+    end
+  end
+  rb
+-%>
+
+# With this class registered (and assuming the executable that calls `Cl` is
+# `bin/run`) the default runner would recognize and run it:
+#
+# $ bin/run git:pull master # instantiates Git::Pull, and passes ["master"] as args
+# $ bin/run git pull master # does the same
+
+<%= run "Cl.new('run').run(%w(git:pull master))" %>
+<%= out '{:cmd=>:"git:pull", :args=>["master"]}' %>
+
+<%= run "Cl.new('run').run(%w(git pull master))" %>
+<%= out '{:cmd=>:"git:pull", :args=>["master"]}' %>

data/examples/_src/readme/runner_custom.erb.rb

@@ -0,0 +1,25 @@
+<%= run sq(<<-'rb')
+  # anywhere in your library
+
+  require 'cl'
+
+  class Runner
+    Cl::Runner.register :custom, self
+
+    def initialize(ctx, args)
+      # ...
+    end
+
+    def run
+      const = identify_cmd_class_from_args
+      const.new(ctx, args).run
+    end
+  end
+  rb
+-%>
+
+# in bin/run
+Cl.new('run', runner: :custom).run(ARGV)
+
+<% run "p Cl.new('run', runner: :custom).runner([]).class" %>
+<% out 'Runner' %>

data/examples/_src/readme/secret.erb.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+<%= run sq(<<-'rb')
+  class Add < Cl::Cmd
+    register :add
+
+    opt '--pass PASS', secret: true
+
+    def run
+      p(
+        secret?: self.class.opts[:pass].secret?,
+        tainted?: pass
+      )
+    end
+  end
+  rb
+-%>
+
+<%= run "Cl.new('owners').run(%w(add --pass pass))" %>
+
+<%= out '{:secret?=>true, :tainted?=>true}' %>

data/examples/_src/readme/see.erb.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+<%= run sq(<<-'rb')
+  require 'cl'
+
+  class Add < Cl::Cmd
+    register :add
+
+    opt '--to GROUP', see: 'https://docs.io/cli/owners/add'
+  end
+  rb
+-%>
+
+<%= run "Cl.new('owners').run(%w(add --help))" %>
+
+<%= out sq(<<-'str')
+  Usage: owners add [options]
+
+  Options:
+
+    --to GROUP      type: string, see: https://docs.io/cli/owners/add
+    --help          Get help on this command
+  str
+%>

data/examples/_src/readme/type.erb.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+<%= run sq(<<-'rb')
+  class Add < Cl::Cmd
+    register :add
+
+    opt '--active BOOL', type: :boolean
+    opt '--retries INT', type: :integer
+    opt '--sleep FLOAT', type: :float
+
+    def run
+      p active: active.class, retries: retries.class, sleep: sleep.class
+    end
+  end
+  rb
+-%>
+
+<%= run "Cl.new('owners').run(%w(add --active yes --retries 1 --sleep 0.1))" %>
+
+<%= out "{:active=>TrueClass, :retries=>#{RUBY_VERSION < '2.4' ? 'Fixnum' : 'Integer'}, :sleep=>Float}" %>

data/examples/args/cast

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+require 'cl'
+
+module Cast
+  class Bool < Cl::Cmd
+    register :bool
+
+    arg :bool, type: :bool
+
+    def run
+      p cmd: registry_key, bool: bool
+    end
+  end
+
+  class Types < Cl::Cmd
+    register :types
+
+    arg :a, type: :bool
+    arg :b, type: :int
+    arg :c, type: :float
+    arg :d
+
+    def run
+      p cmd: registry_key, a: a, b: b, c: c, d: d
+    end
+  end
+end
+
+Cl.new($0).run(%w(bool on))
+
+# Output:
+#
+#   {:cmd=>:bool, :bool=>true}
+
+Cl.new($0).run(%w(types true 1 1.2 foo))
+
+# Output:
+#
+#   {:cmd=>:types, :a=>true, :b=>1, :c=>1.2, :d=>"foo"}
+
+Cl.new($0).run(%w(types true 1 1.2 foo bar))
+
+# Output:
+#
+#   Too many arguments: true 1 1.2 foo bar (given: 5, allowed: 4)
+#
+#   Usage: bin/examples types [a:bool] [b:int] [c:float] [d] [options]
+#
+#   Arguments:
+#
+#     a           type: bool
+#     b           type: int
+#     c           type: float
+#     d           type: string
+#
+#   Options:
+#
+#     --help      Get help on this command
+
+Cl.new($0).run(%w(types true one 1.2))
+
+# Output:
+#
+#   Wrong argument type (given: "one", expected: int)
+#
+#   Usage: bin/examples types [a:bool] [b:int] [c:float] [d] [options]
+#
+#   Arguments:
+#
+#     a           type: bool
+#     b           type: int
+#     c           type: float
+#     d           type: string
+#
+#   Options:
+#
+#     --help      Get help on this command
+
+Cl.new($0).run(%w(types true 1 one))
+
+# Output:
+#
+#   Wrong argument type (given: "one", expected: float)
+#
+#   Usage: bin/examples types [a:bool] [b:int] [c:float] [d] [options]
+#
+#   Arguments:
+#
+#     a           type: bool
+#     b           type: int
+#     c           type: float
+#     d           type: string
+#
+#   Options:
+#
+#     --help      Get help on this command

data/examples/args/opts

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+require 'cl'
+
+module Opts
+  class Bool < Cl::Cmd
+    register :bool
+
+    arg :bool, type: :bool
+
+    def run
+      p cmd: registry_key, bool: bool
+    end
+  end
+
+  class Types < Cl::Cmd
+    register :types
+
+    arg :a, type: :bool
+    arg :b, type: :int
+    arg :c, type: :float
+    arg :d
+
+    def run
+      p cmd: registry_key, a: a, b: b, c: c, d: d
+    end
+  end
+end
+
+Cl.new($0).run(%w(bool on))
+
+# Output:
+#
+#   {:cmd=>:bool, :bool=>true}
+
+Cl.new($0).run(%w(types true 1 1.2 foo))
+
+# Output:
+#
+#   {:cmd=>:types, :a=>true, :b=>1, :c=>1.2, :d=>"foo"}
+
+Cl.new($0).run(%w(types true 1 1.2 foo bar))
+
+# Output:
+#
+#   Too many arguments: true 1 1.2 foo bar (given: 5, allowed: 4)
+#
+#   Usage: bin/examples types [a:bool] [b:int] [c:float] [d] [options]
+#
+#   Arguments:
+#
+#     a           type: bool
+#     b           type: int
+#     c           type: float
+#     d           type: string
+#
+#   Options:
+#
+#     --help      Get help on this command
+
+Cl.new($0).run(%w(types true one 1.2))
+
+# Output:
+#
+#   Wrong argument type (given: "one", expected: int)
+#
+#   Usage: bin/examples types [a:bool] [b:int] [c:float] [d] [options]
+#
+#   Arguments:
+#
+#     a           type: bool
+#     b           type: int
+#     c           type: float
+#     d           type: string
+#
+#   Options:
+#
+#     --help      Get help on this command
+
+Cl.new($0).run(%w(types true 1 one))
+
+# Output:
+#
+#   Wrong argument type (given: "one", expected: float)
+#
+#   Usage: bin/examples types [a:bool] [b:int] [c:float] [d] [options]
+#
+#   Arguments:
+#
+#     a           type: bool
+#     b           type: int
+#     c           type: float
+#     d           type: string
+#
+#   Options:
+#
+#     --help      Get help on this command

data/examples/args/required

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+require 'cl'
+
+class Required < Cl::Cmd
+  register :required
+
+  arg :one, required: true
+  arg :two
+
+  def run
+    p cmd: registry_key, one: one, two: two
+  end
+end
+
+Cl.new($0).run(%w(required one two))
+
+# Output:
+#
+#   {:cmd=>:required, :one=>"one", :two=>"two"}
+
+Cl.new($0).run(%w(required one))
+
+# Output:
+#
+#   {:cmd=>:required, :one=>"one", :two=>nil}
+
+Cl.new($0).run(%w(required))
+
+# Output:
+#
+#   Missing arguments (given: 0, required: 1)
+#
+#   Usage: bin/examples required one [two] [options]
+#
+#   Arguments:
+#
+#     one         type: string, required
+#     two         type: string
+#
+#   Options:
+#
+#     --help      Get help on this command
+
+Cl.new($0).run(%w(required one two three))
+
+# Output:
+#
+#   Too many arguments: one two three (given: 3, allowed: 2)
+#
+#   Usage: bin/examples required one [two] [options]
+#
+#   Arguments:
+#
+#     one         type: string, required
+#     two         type: string
+#
+#   Options:
+#
+#     --help      Get help on this command
+

data/examples/args/splat

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+require 'cl'
+
+module Splat
+  class Left < Cl::Cmd
+    register :left
+
+    arg :one, type: :array, splat: true
+    args :two, :three
+
+    def run
+      p cmd: registry_key, one: one, two: two, three: three
+    end
+  end
+
+  class Middle < Cl::Cmd
+    register :middle
+
+    arg :one
+    arg :two, type: :array, splat: true
+    arg :three
+
+    def run
+      p cmd: registry_key, one: one, two: two, three: three
+    end
+  end
+
+  class Right < Cl::Cmd
+    register :right
+
+    args :one, :two
+    arg :three, type: :array, splat: true
+
+    def run
+      p cmd: registry_key, one: one, two: two, three: three
+    end
+  end
+end
+
+Cl.new('splat').run(%w(left foo bar baz buz))
+
+# Output:
+#
+#   {:cmd=>:left, :one=>["foo", "bar"], :two=>"baz", :three=>"buz"}
+
+Cl.new('splat').run(%w(middle foo bar baz buz))
+
+# Output:
+#
+#   {:cmd=>:middle, :one=>"foo", :two=>["bar", "baz"], :three=>"buz"}
+
+Cl.new('splat').run(%w(right foo bar baz buz))
+
+# Output:
+#
+#   {:cmd=>:right, :one=>"foo", :two=>"bar", :three=>["baz", "buz"]}

data/examples/gem

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+require 'cl'
+
+module Gem
+  module Release
+    module Cmds
+      class Release < Cl::Cmd
+        register 'release'
+
+        arg :gemspec
+
+        opt '-h', '--host HOST', 'Push to a compatible host other than rubygems.org'
+        opt '-k', '--key KEY',   'Rubygems API key to use'
+        opt '-q', '--quiet',     'Silence output'
+
+        def run
+          p cmd: registry_key, args: args, opts: opts
+        end
+      end
+
+      class Bump < Cl::Cmd
+        register 'bump'
+
+        opt '-v', '--version VERSION', 'The version to bump to [1.1.1|major|minor|patch|pre|rc|release]'
+        opt '--[no-]commit',           'Bump the version, but do not commit'
+
+        def run
+          p cmd: registry_key, args: args, opts: opts
+        end
+      end
+    end
+  end
+end
+
+Cl.new('gem').run(%w(help))
+
+# Output:
+#
+#   Type "gem help COMMAND [SUBCOMMAND]" for more details:
+#
+#   gem release [gemspec] [options]
+#   gem bump [options]
+
+
+Cl.new('gem').run(%w(help release))
+# or:
+#
+#   Cl.new('gem').run(%w(release --help)))
+#   Cl.new('gem').run(%w(release -h)))
+#
+# Output:
+#
+#   Usage: gem release [gemspec] [options]
+#
+#   Arguments:
+#
+#     gemspec              type: string
+#
+#   Options:
+#
+#     -h --host HOST       Push to a compatible host other than rubygems.org (type: string)
+#     -k --key KEY         Rubygems API key to use (type: string)
+#     -q --[no-]quiet      Silence output
+#        --help            Get help on this command
+
+
+Cl.new('gem').run(%w(help bump))
+# or:
+#
+#   Cl.new('gem').run(%w(bump --help)))
+#   Cl.new('gem').run(%w(bump -h)))
+#
+# Output:
+#
+#   Usage: gem bump [options]
+#
+#   Options:
+#
+#     -v --version VERSION      The version to bump to [1.1.1|major|minor|patch|pre|rc|release] (type: string)
+#        --[no-]commit          Bump the version, but do not commit
+#        --help                 Get help on this command
+
+
+Cl.new('gem').run(%w(bump -v 1.1.1))
+
+# Output:
+#
+#   {:cmd=>:bump, :args=>[], :opts=>{:version=>"1.1.1"}}
+
+
+Cl.new('gem').run(%w(release foo.gemspec -h host -k key -q))
+
+# Output:
+#
+#   {:cmd=>:release, :args=>["foo.gemspec"], :opts=>{:host=>"host", :key=>"key", :quiet=>true}}

data/examples/heroku

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+require 'cl'
+
+module Heroku
+  module Apps
+    class Create < Cl::Cmd
+      register 'apps:create'
+
+      arg :name, required: true
+
+      opt '-o', '--org ORG'
+
+      def run
+        p cmd: registry_key, args: args, opts: opts
+      end
+    end
+
+    class List < Cl::Cmd
+      register 'apps:info'
+
+      opt '-a', '--app APP'
+
+      def run
+        p cmd: registry_key, args: args, opts: opts
+      end
+    end
+  end
+end
+
+Cl.new('heroku').run(%w(apps:create name -o org))
+# or:
+#
+#   Cl.new('heroku').run(%w(apps create name -o org))
+
+# Output:
+#
+#   {:cmd=>:"apps:create", :args=>["name"], :opts=>{:org=>"org"}}
+
+Cl.new('heroku').run(%w(apps:info -a app))
+# or:
+#
+#   Cl.new('heroku').run(%w(apps info -a app))
+
+# Output:
+#
+#   {:cmd=>:"apps:info", :args=>[], :opts=>{:app=>"app"}}

data/examples/rakeish

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+require 'cl'
+
+module Rakeish
+  module Db
+    class Create < Cl::Cmd
+      register 'db:create'
+
+      arg :name
+
+      def run
+        p cmd: registry_key, args: args, opts: opts
+      end
+    end
+
+    class Drop < Cl::Cmd
+      register 'db:drop'
+
+      arg :name
+
+      opt '-f', '--force'
+
+      def run
+        p cmd: registry_key, args: args, opts: opts
+      end
+    end
+
+    class Migrate < Cl::Cmd
+      register 'db:migrate'
+
+      arg :name
+
+      opt '-v', '--version VERSION'
+
+      def run
+        p cmd: registry_key, args: args, opts: opts
+      end
+    end
+  end
+end
+
+Cl.new('rake', runner: :multi).run(%w(db:drop production -f db:create db:migrate production -v 1))
+
+# Output:
+#
+#   {:cmd=>:"db:drop", :args=>["production"], :opts=>{:force=>true}}
+#   {:cmd=>:"db:create", :args=>[], :opts=>{}}
+#   {:cmd=>:"db:migrate", :args=>["production"], :opts=>{:version=>"1"}}

data/examples/readme/abstract

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+require 'cl'
+
+class Base < Cl::Cmd
+  abstract
+end
+
+class Add < Base
+  register :add
+
+  def run
+    puts 'Success'
+  end
+end
+
+Cl.new('owners').run(%w(add))
+
+# Output:
+#
+#   Success
+
+Cl.new('owners').run(%w(base))
+
+# Output:
+#
+#   Unknown command: base