travis-cl 1.2.4

data/examples/readme/requireds

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+class Add < Cl::Cmd
+  register :add
+
+  # read DNF, i.e. "token OR user AND pass
+  required :token, [:user, :pass]
+
+  opt '--token TOKEN'
+  opt '--user NAME'
+  opt '--pass PASS'
+
+  def run
+    p token: token, user: user, pass: pass
+  end
+end
+
+Cl.new('owners').run(%w(add --token token))
+
+# Output:
+#
+#   {:token=>"token", :user=>nil, :pass=>nil}
+
+Cl.new('owners').run(%w(add --user user --pass pass))
+
+# Output:
+#
+#   {:token=>nil, :user=>"user", :pass=>"pass"}
+
+Cl.new('owners').run(%w(add))
+
+# Output:
+#
+#   Missing options: token, or user and pass
+#
+#   Usage: owners add [options]
+#
+#   Options:
+#
+#     Either token, or user and pass are required.
+#
+#     --token TOKEN      type: string
+#     --user NAME        type: string
+#     --pass PASS        type: string
+#     --help             Get help on this command

data/examples/readme/requires

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+class Add < Cl::Cmd
+  register :add
+
+  opt '--to GROUP'
+  opt '--other GROUP', requires: :to
+
+  def run
+    p to: to, other: other
+  end
+end
+
+Cl.new('owners').run(%w(add --to one --other two))
+
+# Output:
+#
+#   {:to=>"one", :other=>"two"}
+
+Cl.new('owners').run(%w(add --other two))
+
+# Output:
+#
+#   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

data/examples/readme/runner

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+module Git
+  class Pull < Cl::Cmd
+    register :'git:pull'
+
+    arg :branch
+
+    def run
+      p cmd: registry_key, args: args
+    end
+  end
+end
+
+# 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
+
+Cl.new('run').run(%w(git:pull master))
+# Output:
+#
+#   {:cmd=>:"git:pull", :args=>["master"]}
+
+Cl.new('run').run(%w(git pull master))
+# Output:
+#
+#   {:cmd=>:"git:pull", :args=>["master"]}

data/examples/readme/runner_custom

@@ -0,0 +1,22 @@
+# 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
+
+# in bin/run
+Cl.new('run', runner: :custom).run(ARGV)
+
+
+

data/examples/readme/secret

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

data/examples/readme/see

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

data/examples/readme/type

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('lib')
+
+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
+
+Cl.new('owners').run(%w(add --active yes --retries 1 --sleep 0.1))
+
+# Output:
+#
+#   {:active=>TrueClass, :retries=>Integer, :sleep=>Float}

data/lib/cl/arg.rb

@@ -0,0 +1,79 @@
+require 'cl/cast'
+
+class Cl
+  class Arg < Struct.new(:name, :opts)
+    include Cast
+
+    def define(const)
+      mod = Module.new
+      mod.send(:attr_accessor, name)
+      mod.class_eval "def #{name}?; #{name}.is_a?(Array) ? !#{name}.empty? : !!#{name} end"
+      const.send(:include, mod)
+    end
+
+    def set(cmd, value)
+      value = cast(value)
+      unknown(value) if enum? && !known?(value)
+      cmd.send(:"#{name}=", value)
+    end
+
+    def type
+      opts[:type] || :string
+    end
+
+    def array?
+      type == :array
+    end
+
+    def description
+      opts[:description]
+    end
+
+    def enum
+      Array(opts[:enum])
+    end
+
+    def enum?
+      opts.key?(:enum)
+    end
+
+    def default
+      opts[:default]
+    end
+
+    def default?
+      opts.key?(:default)
+    end
+
+    def known?(value)
+      enum.include?(value)
+    end
+
+    def required?
+      !!opts[:required]
+    end
+
+    def separator
+      opts[:sep]
+    end
+
+    def splat?
+      !!opts[:splat] && array?
+    end
+
+    def unknown(value)
+      raise UnknownArgumentValue.new(value, enum.join(', '))
+    end
+
+    def to_s
+      str = name
+      case type
+      when :array          then str = "#{str}.."
+      when :boolean, :bool then str = "#{str}:bool"
+      when :integer, :int  then str = "#{str}:int"
+      when :float          then str = "#{str}:float"
+      end
+      required? ? str : "[#{str}]"
+    end
+  end
+end

data/lib/cl/args.rb

@@ -0,0 +1,92 @@
+require 'cl/arg'
+
+class Cl
+  class Args
+    include Enumerable
+
+    def define(const, name, *args)
+      opts = args.last.is_a?(Hash) ? args.pop.dup : {}
+      opts[:description] = args.shift if args.any?
+
+      arg = Arg.new(name, opts)
+      arg.define(const)
+      self.args << arg
+    end
+
+    def apply(cmd, values, opts)
+      values = splat(values) if splat?
+      values = default(values) if default?
+      validate(values)
+      return values if args.empty?
+      values = args.zip(values).map { |(arg, value)| arg.set(cmd, value) }.flatten(1) #.compact
+      compact_args(values)
+    end
+
+    def each(&block)
+      args.each(&block)
+    end
+
+    def index(*args, &block)
+      self.args.index(*args, &block)
+    end
+
+    attr_writer :args
+
+    def args
+      @args ||= []
+    end
+
+    def clear
+      args.clear
+    end
+
+    def dup
+      args = super
+      args.args = args.args.dup
+      args
+    end
+
+    private
+
+      def validate(args)
+        # raise ArgumentError.new(:unknown_arg, arg) if unknown?(arg)
+        raise ArgumentError.new(:missing_args, args.size, required) if args.size < required
+        raise ArgumentError.new(:too_many_args, args.join(' '), args.size, allowed) if args.size > allowed && !splat?
+      end
+
+      def allowed
+        args.size
+      end
+
+      def splat?
+        any?(&:splat?)
+      end
+
+      def default?
+        any?(&:default?)
+      end
+
+      def required
+        select(&:required?).size
+      end
+
+      def splat(values)
+        args.each.with_index.inject([]) do |group, (arg, ix)|
+          count = arg && arg.splat? ? [values.size - args.size + ix + 1] : []
+          count = 0 if count.first.to_i < 0
+          group << values.shift(*count)
+        end
+      end
+
+      def default(values)
+        args.each.with_index.inject([]) do |args, (arg, ix)|
+          args << (values[ix] || arg.default)
+        end
+      end
+
+      def compact_args(args)
+        args = compact_args(args[0..-2]) while args.last.nil? && args.size > 0
+        args
+      end
+  end
+end

data/lib/cl/cast.rb

@@ -0,0 +1,55 @@
+class Cl
+  module Cast
+    class Cast < Struct.new(:type, :value, :opts)
+      TRUE  = /^(true|yes|on)$/
+      FALSE = /^(false|no|off)$/
+
+      def apply
+        return send(type) if respond_to?(type, true)
+        raise ArgumentError, "Unknown type: #{type}"
+      rescue ::ArgumentError => e
+        raise ArgumentError.new(:wrong_type, value.inspect, type)
+      end
+
+      private
+
+        def array
+          Array(value).compact.flatten.map { |value| split(value) }.flatten.compact
+        end
+
+        def string
+          value.to_s unless value.to_s.empty?
+        end
+        alias str string
+
+        def boolean
+          return true  if value.to_s =~ TRUE
+          return false if value.to_s =~ FALSE
+          !!value
+        end
+        alias bool boolean
+        alias flag boolean
+
+        def int
+          Integer(value) if value
+        end
+        alias integer int
+
+        def float
+          Float(value) if value
+        end
+
+        def split(value)
+          separator ? value.to_s.split(separator) : value
+        end
+
+        def separator
+          opts[:separator]
+        end
+    end
+
+    def cast(value)
+      type ? Cast.new(type, value, separator: separator).apply : value
+    end
+  end
+end

data/lib/cl/cmd.rb

@@ -0,0 +1,74 @@
+require 'registry'
+require 'cl'
+require 'cl/args'
+require 'cl/dsl'
+require 'cl/opts'
+require 'cl/parser'
+
+class Cl
+  # Base class for all command classes that can be run.
+  #
+  # Inherit your command classes from this class, use the {Cl::Cmd::Dsl} to
+  # declare arguments, options, summary, description, examples etc., and
+  # implement the method #run.
+  #
+  # See {Cl::Cmd::Dsl} for details on the DSL methods.
+  class Cmd
+    include Registry
+    extend Dsl
+
+    class << self
+      include Merge, Suggest, Underscore
+
+      attr_accessor :auto_register
+
+      inherited = ->(const) do
+        if const.name && Cmd.auto_register
+          key = underscore(const.name.split('::').last)
+          key = [registry_key, key].compact.join(':') unless abstract?
+          const.register(key)
+        end
+        const.define_singleton_method(:inherited, &inherited)
+      end
+      define_method(:inherited, &inherited)
+
+      def cmds
+        registry.values.uniq
+      end
+
+      def parse(ctx, cmd, args)
+        parser = Parser.new(cmd, args)
+        args, opts = parser.args, parser.opts unless self == Help
+        opts = merge(ctx.config[registry_key], opts) if ctx.config[registry_key]
+        [args, opts || {}]
+      end
+
+      def suggestions(opt)
+        suggest(opts.map(&:name), opt.sub(/^--/, ''))
+      end
+    end
+
+    self.auto_register = true
+
+    abstract
+
+    opt '--help', 'Get help on this command'
+
+    attr_reader :ctx, :args
+
+    def initialize(ctx, args)
+      @ctx = ctx
+      args, opts = self.class.parse(ctx, self, args)
+      @opts = self.class.opts.apply(self, self.opts.merge(opts))
+      @args = self.class.args.apply(self, args, opts) unless help? && !is_a?(Help)
+    end
+
+    def opts
+      @opts ||= {}
+    end
+
+    def deprecations
+      @deprecations ||= {}
+    end
+  end
+end

data/lib/cl/config/env.rb

@@ -0,0 +1,52 @@
+require 'cl/helper'
+
+class Cl
+  class Config
+    class Env < Struct.new(:name)
+      include Merge
+
+      TRUE  = /^(true|yes|on)$/
+      FALSE = /^(false|no|off)$/
+
+      def load
+        vars = opts.map { |cmd, opts| vars(cmd, opts) }
+        merge(*vars.flatten.compact)
+      end
+
+      private
+
+        def vars(cmd, opts)
+          opts.map { |opt| var(cmd, opt, key(cmd, opt)) }
+        end
+
+        def opts
+          Cmd.registry.map { |key, cmd| [key, cmd.opts.map(&:name) - [:help]] }
+        end
+
+        def var(cmd, opt, key)
+          { cmd => { opt => cast(ENV[key]) } } if ENV[key]
+        end
+
+        def key(*keys)
+          [name.upcase, *keys].join('_').upcase.sub('-', '_')
+        end
+
+        def only(hash, *keys)
+          hash.select { |key, _| keys.include?(key) }.to_h
+        end
+
+        def cast(value)
+          case value
+          when TRUE
+            true
+          when FALSE
+            false
+          when ''
+            false
+          else
+            value
+          end
+        end
+    end
+  end
+end

data/lib/cl/config/files.rb

@@ -0,0 +1,34 @@
+require 'yaml'
+require 'cl/helper'
+
+class Cl
+  class Config
+    class Files < Struct.new(:name)
+      include Merge
+
+      PATHS = %w(
+        ~/.%s.yml
+        ./.%s.yml
+      )
+
+      def load
+        configs.any? ? symbolize(merge(*configs)) : {}
+      end
+
+      private
+
+        def configs
+          @configs ||= paths.map { |path| YAML.load_file(path) || {} }
+        end
+
+        def paths
+          paths = PATHS.map { |path| File.expand_path(path % name) }
+          paths.select { |path| File.exist?(path) }
+        end
+
+        def symbolize(hash)
+          hash.map { |key, value| [key.to_sym, value] }.to_h
+        end
+    end
+  end
+end

data/lib/cl/config.rb

@@ -0,0 +1,30 @@
+require 'cl/config/env'
+require 'cl/config/files'
+require 'cl/helper'
+
+class Cl
+  class Config
+    include Merge
+
+    attr_reader :name, :opts
+
+    def initialize(name)
+      @name = name
+      @opts = load
+    end
+
+    def to_h
+      opts
+    end
+
+    private
+
+      def load
+        merge(*sources.map(&:load))
+      end
+
+      def sources
+        [Files.new(name), Env.new(name)]
+      end
+  end
+end

data/lib/cl/ctx.rb

@@ -0,0 +1,36 @@
+require 'forwardable'
+require 'cl/config'
+require 'cl/ui'
+
+class Cl
+  class Ctx
+    extend Forwardable
+
+    def_delegators :ui, :puts, :stdout, :announce, :info, :notice, :warn,
+      :error, :success, :cmd
+
+    attr_accessor :config, :name, :opts
+
+    def initialize(name, opts = {})
+      @config = Config.new(name).to_h
+      @opts = opts
+      @name = name
+    end
+
+    def ui
+      @ui ||= opts[:ui] || Ui.new(self, opts)
+    end
+
+    def abort(error, *strs)
+      abort? ? ui.abort(error, *strs) : raise(error)
+    end
+
+    def abort?
+      !opts[:abort].is_a?(FalseClass)
+    end
+
+    def test?
+      ENV['ENV'] == 'test'
+    end
+  end
+end