travis-cl 1.2.4

data/lib/cl/opt.rb

@@ -0,0 +1,276 @@
+require 'cl/cast'
+require 'cl/errors'
+
+class Cl
+  class Opt < Struct.new(:strs, :opts, :block)
+    include Cast, Regex
+
+    OPTS = %i(
+      alias default deprecated description downcase eg enum example format
+      internal max min negate note required requires secret see sep type upcase
+    )
+
+    OPT = /^--(?:\[.*\])?(.*)$/
+
+    TYPES = {
+      int: :integer,
+      str: :string,
+      bool: :flag,
+      boolean: :flag
+    }
+
+    attr_reader :short, :long
+
+    def initialize(strs, *)
+      super
+      @short, @long = Validator.new(strs, opts).apply
+    end
+
+    def define(const)
+      return unless __key__ = name
+      const.send :include, Module.new {
+        define_method (__key__) { opts[__key__] }
+        define_method (:"#{__key__}?") { !!opts[__key__] }
+      }
+    end
+
+    def name
+      return @name if instance_variable_defined?(:@name)
+      name = long.split(' ').first.match(OPT)[1] if long
+      @name = name.sub('-', '_').to_sym if name
+    end
+
+    def type
+      @type ||= TYPES[opts[:type]] || opts[:type] || infer_type
+    end
+
+    def infer_type
+      strs.any? { |str| str.split(' ').size > 1 } ? :string : :flag
+    end
+
+    def help?
+      name == :help
+    end
+
+    def flag?
+      type == :flag
+    end
+
+    def int?
+      type == :int || type == :integer
+    end
+
+    def array?
+      type == :array
+    end
+
+    def aliases?
+      !!opts[:alias]
+    end
+
+    def aliases
+      Array(opts[:alias])
+    end
+
+    def description
+      opts[:description]
+    end
+
+    def deprecated?(name = nil)
+      return !!opts[:deprecated] if name.nil?
+      names = [name.to_s.gsub('_', '-').to_sym, name.to_s.gsub('-', '_').to_sym]
+      deprecated? && names.include?(deprecated.first)
+    end
+
+    def deprecated
+      # If it's a string then it's a deprecation message and the option itself
+      # is considered deprecated. If it's a symbol it refers to a deprecated
+      # alias, and the option's name is the deprecation message.
+      return [name, opts[:deprecated]] unless opts[:deprecated].is_a?(Symbol)
+      opts[:deprecated] ? [opts[:deprecated], name] : []
+    end
+
+    def downcase?
+      !!opts[:downcase]
+    end
+
+    def default?
+      opts.key?(:default)
+    end
+
+    def default
+      opts[:default]
+    end
+
+    def enum?
+      !!opts[:enum]
+    end
+
+    def enum
+      Array(opts[:enum])
+    end
+
+    def known?(value)
+      return value.all? { |value| known?(value) } if value.is_a?(Array)
+      enum.any? { |obj| obj.is_a?(Regexp) ? obj =~ value.to_s : obj == value }
+    end
+
+    def unknown(value)
+      return value.reject { |value| known?(value) } if value.is_a?(Array)
+      known?(value) ? [] : Array(value)
+    end
+
+    def example?
+      !!opts[:example]
+    end
+
+    def example
+      opts[:example]
+    end
+
+    def format?
+      !!opts[:format]
+    end
+
+    def format
+      format_regex(opts[:format])
+    end
+
+    def formatted?(value)
+      return value.all? { |value| formatted?(value) } if value.is_a?(Array)
+      opts[:format] =~ value
+    end
+
+    def internal?
+      !!opts[:internal]
+    end
+
+    def min?
+      int? && !!opts[:min]
+    end
+
+    def min
+      opts[:min]
+    end
+
+    def max?
+      int? && !!opts[:max]
+    end
+
+    def max
+      opts[:max]
+    end
+
+    def negate?
+      !!negate
+    end
+
+    def negate
+      ['no'] + Array(opts[:negate]) if flag?
+    end
+
+    def note?
+      !!opts[:note]
+    end
+
+    def note
+      opts[:note]
+    end
+
+    def required?
+      !!opts[:required]
+    end
+
+    def requires?
+      !!opts[:requires]
+    end
+
+    def requires
+      Array(opts[:requires])
+    end
+
+    def secret?
+      !!opts[:secret]
+    end
+
+    def see?
+      !!opts[:see]
+    end
+
+    def see
+      opts[:see]
+    end
+
+    def separator
+      opts[:sep]
+    end
+
+    def upcase?
+      !!opts[:upcase]
+    end
+
+    def block
+      # raise if no block was given, and the option's name cannot be inferred
+      super || method(:assign)
+    end
+
+    def assign(opts, type, _, value)
+      [name, *aliases].each do |name|
+        if array?
+          opts[name] ||= []
+          opts[name] << value
+        else
+          opts[name] = value
+        end
+      end
+    end
+
+    def long?(str)
+      str.start_with?('--')
+    end
+
+    class Validator < Struct.new(:strs, :opts)
+      SHORT = /^-\w( \w+)?$/
+      LONG  = /^--[\w\-\[\]]+( \[?\w+\]?)?$/
+
+      MSGS = {
+        missing_strs: 'No option strings given. Pass one short -s and/or one --long option string.',
+        wrong_strs:   'Wrong option strings given. Pass one short -s and/or one --long option string.',
+        invalid_strs: 'Invalid option strings given: %p',
+        unknown_opts: 'Unknown options: %s'
+      }
+
+      def apply
+        error :missing_strs if strs.empty?
+        error :wrong_strs if short.size > 1 || long.size > 1
+        error :invalid_strs, invalid unless invalid.empty?
+        error :unknown_opts, unknown.map(&:inspect).join(', ') unless unknown.empty?
+        [short.first, long.first]
+      end
+
+      def unknown
+        @unknown ||= opts.keys - Opt::OPTS
+      end
+
+      def invalid
+        @invalid ||= strs.-(valid).join(', ')
+      end
+
+      def valid
+        strs.grep(Regexp.union(SHORT, LONG))
+      end
+
+      def short
+        strs.grep(SHORT)
+      end
+
+      def long
+        strs.grep(LONG)
+      end
+
+      def error(key, *args)
+        raise Cl::Error, MSGS[key] % args
+      end
+    end
+  end
+end

data/lib/cl/opts/validate.rb

@@ -0,0 +1,117 @@
+require 'cl/helper'
+
+class Cl
+  class Opts
+    module Validate
+      def validate(cmd, opts, values, orig)
+        Validate.constants.each do |name|
+          next if name == :Validator
+          const = Validate.const_get(name)
+          const.new(cmd, opts, values, orig).apply
+        end
+      end
+
+      class Validator < Struct.new(:cmd, :opts, :values, :orig)
+        include Regex
+        def compact(hash, *keys)
+          hash.reject { |_, value| value.nil? }.to_h
+        end
+
+        def invert(hash)
+          hash.map { |key, obj| Array(obj).map { |obj| [obj, key] } }.flatten(1).to_h
+        end
+
+        def only(hash, *keys)
+          hash.select { |key, _| keys.include?(key) }.to_h
+        end
+      end
+
+      class Required < Validator
+        def apply
+          # make sure we do not accept unnamed required options
+          raise RequiredOpts.new(missing.map(&:name)) if missing.any?
+        end
+
+        def missing
+          @missing ||= opts.select(&:required?).select { |opt| !values.key?(opt.name) }
+        end
+      end
+
+      class Requireds < Validator
+        def apply
+          raise RequiredsOpts.new(missing) if missing.any?
+        end
+
+        def missing
+          @missing ||= cmd.class.required.map do |alts|
+            alts if alts.none? { |alt| Array(alt).all? { |key| values.key?(key) } }
+          end.compact
+        end
+      end
+
+      class Requires < Validator
+        def apply
+          raise RequiresOpts.new(invert(missing)) if missing.any?
+        end
+
+        def missing
+          @missing ||= requires.map do |opt|
+            missing = opt.requires.select { |key| !values.key?(key) }
+            [opt.name, missing] if missing.any?
+          end.compact
+        end
+
+        def requires
+          opts.select(&:requires?).select { |opt| orig.key?(opt.name) }
+        end
+      end
+
+      class Format < Validator
+        def apply
+          raise InvalidFormat.new(invalid) if invalid.any?
+        end
+
+        def invalid
+          @invalid ||= opts.select(&:format?).map do |opt|
+            value = values[opt.name]
+            [opt.name, opt.format] if value && !opt.formatted?(value)
+          end.compact
+        end
+      end
+
+      class Enum < Validator
+        def apply
+          raise UnknownValues.new(unknown) if unknown.any?
+        end
+
+        def unknown
+          @unknown ||= opts.select(&:enum?).map do |opt|
+            unknown = opt.unknown(values[opt.name])
+            next if unknown.empty?
+            known = opt.enum.map { |str| format_regex(str) }
+            [opt.name, unknown, known]
+          end.compact
+        end
+      end
+
+      class Range < Validator
+        def apply
+          raise OutOfRange.new(invalid) if invalid.any?
+        end
+
+        def invalid
+          @invalid ||= opts.map do |opt|
+            next unless value = values[opt.name]
+            range = only(opt.opts, :min, :max)
+            [opt.name, compact(range)] if invalid?(range, value)
+          end.compact
+        end
+
+        def invalid?(range, value)
+          min, max = range.values_at(:min, :max)
+          min && value < min || max && value > max
+        end
+      end
+    end
+  end
+end

data/lib/cl/opts.rb

@@ -0,0 +1,114 @@
+require 'cl/opt'
+require 'cl/opts/validate'
+
+class Cl
+  class Opts
+    include Enumerable, Validate
+
+    def define(const, *args, &block)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      strs = args.select { |arg| arg.start_with?('-') }
+      opts[:description] = args.-(strs).first
+
+      opt = Opt.new(strs, opts, block)
+      opt.define(const)
+      insert(opt, const)
+    end
+
+    def apply(cmd, opts)
+      return opts if opts[:help]
+      orig = opts.dup
+      opts = defaults(cmd, opts)
+      opts = downcase(opts)
+      opts = upcase(opts)
+      opts = cast(opts)
+      opts = taint(opts)
+      validate(cmd, self, opts, orig)
+      opts
+    end
+
+    def insert(opt, const)
+      delete(opt)
+      return opts << opt if const == Cmd
+      ix = opts.index(const.superclass.opts.first)
+      opts.empty? ? opts << opt : opts.insert(ix.to_i, opt)
+    end
+
+    def [](key)
+      opts.detect { |opt| opt.name == key }
+    end
+
+    def each(&block)
+      opts.each(&block)
+    end
+
+    def delete(opt)
+      opts.delete(opts.detect { |o| o.strs == opt.strs })
+    end
+
+    def first
+      opts.first
+    end
+
+    def to_a
+      opts
+    end
+
+    attr_writer :opts
+
+    def opts
+      @opts ||= []
+    end
+
+    def deprecated
+      map(&:deprecated).flatten.compact
+    end
+
+    def ==(other)
+      strs == other.strs
+    end
+
+    def dup
+      super.tap { |obj| obj.opts = opts.dup }
+    end
+
+    private
+
+      def defaults(cmd, opts)
+        select(&:default?).inject(opts) do |opts, opt|
+          next opts if opts.key?(opt.name)
+          value = opt.default
+          value = resolve(cmd, opts, value) if value.is_a?(Symbol)
+          opts.merge(opt.name => value)
+        end
+      end
+
+      def resolve(cmd, opts, key)
+        opts[key] || cmd.respond_to?(key) && cmd.send(key)
+      end
+
+      def downcase(opts)
+        select(&:downcase?).inject(opts) do |opts, opt|
+          next opts unless value = opts[opt.name]
+          opts.merge(opt.name => value.to_s.downcase)
+        end
+      end
+
+      def upcase(opts)
+        select(&:upcase?).inject(opts) do |opts, opt|
+          next opts unless value = opts[opt.name]
+          opts.merge(opt.name => value.to_s.upcase)
+        end
+      end
+
+      def cast(opts)
+        opts.map do |key, value|
+          [key, self[key] ? self[key].cast(value) : value]
+        end.to_h
+      end
+
+      def taint(opts)
+        opts.to_h
+      end
+  end
+end

data/lib/cl/parser/format.rb

@@ -0,0 +1,63 @@
+class Cl
+  class Parser < OptionParser
+    class Format < Struct.new(:opt)
+      NAME = /^(--(?:\[no-\])?)([^= ]+)/
+
+      def strs
+        strs = opt.strs + aliases
+        strs.map { |str| long?(str) ? long(str) : short(str) }.flatten
+      end
+
+      def long(str)
+        strs = [unnegate(str)]
+        strs = strs.map { |str| negated(str) }.flatten if flag?
+        strs = collect(strs, :dashed)
+        strs = collect(strs, :underscored)
+        strs = collect(strs, :valued) if flag? && Cl.flag_values
+        strs.uniq
+      end
+
+      def short(str)
+        str = "#{str} #{opt.name.upcase}" unless opt.flag? || str.include?(' ')
+        str
+      end
+
+      def unnegate(str)
+        str.sub('--[no-]', '--')
+      end
+
+      def aliases
+        opt.aliases.map { |name| "--#{name} #{ name.upcase unless opt.flag?}".strip }
+      end
+
+      def collect(strs, mod)
+        strs = strs + strs.map { |str| send(mod, str) }
+        strs.flatten.uniq
+      end
+
+      def negated(str)
+        str.dup.insert(2, '[no-]')
+      end
+
+      def dashed(str)
+        str =~ NAME && str.sub("#{$1}#{$2}", "#{$1}#{$2.tr('_', '-')}") || str
+      end
+
+      def underscored(str)
+        str =~ NAME && str.sub("#{$1}#{$2}", "#{$1}#{$2.tr('-', '_')}") || str
+      end
+
+      def valued(str)
+        "#{str} [true|false|yes|no]"
+      end
+
+      def long?(str)
+        str.start_with?('--')
+      end
+
+      def flag?
+        opt.flag? && !opt.help?
+      end
+    end
+  end
+end

data/lib/cl/parser.rb

@@ -0,0 +1,70 @@
+require 'optparse'
+require 'cl/parser/format'
+
+class Cl
+  class Parser < OptionParser
+    attr_reader :cmd, :args, :opts
+
+    def initialize(cmd, args)
+      @cmd = cmd
+      @opts = {}
+      opts = cmd.class.opts
+
+      super do
+        opts.each do |opt|
+          Format.new(opt).strs.each do |str|
+            on(str) { |value| set(opt, str, value) }
+          end
+        end
+      end
+
+      @args = parse!(normalize(opts, args))
+    end
+
+    # should consider negative arities (e.g. |one, *two|)
+    def set(opt, str, value)
+      name = long?(str) ? opt_name(str) : opt.name
+      value = true if value.nil? && opt.flag?
+      args = [opts, opt.type, name, value]
+      args = args[-opt.block.arity, opt.block.arity]
+      instance_exec(*args, &opt.block)
+      cmd.deprecations.update([opt.deprecated].to_h) if opt.deprecated?(name)
+    end
+
+    def normalize(opts, args)
+      args = noize(opts, args)
+      # dasherize(args)
+      args
+    end
+
+    def noize(opts, args)
+      args.map do |arg|
+        str = negation(opts, arg)
+        str ? arg.sub(/^--#{str}[-_]+/, '--no-') : arg
+      end
+    end
+
+    def negation(opts, arg)
+      opts.select(&:flag?).detect do |opt|
+        str = opt.negate.detect { |str| arg =~ /^--#{str}[-_]+#{opt.name}/ }
+        break str if str
+      end
+    end
+
+    # DASHERIZE = /^--([^= ])*/
+    #
+    # def dasherize(strs)
+    #   strs.map do |str|
+    #     str.is_a?(String) ? str.gsub(DASHERIZE) { |opt| opt.gsub('_', '-') } : str
+    #   end
+    # end
+
+    def long?(str)
+      str.start_with?('--')
+    end
+
+    def opt_name(str)
+      str.split(' ').first.sub(/--(\[no[_\-]\])?/, '').to_sym
+    end
+  end
+end

data/lib/cl/runner/default.rb

@@ -0,0 +1,86 @@
+require 'forwardable'
+require 'cl/ctx'
+require 'cl/helper'
+
+class Cl
+  module Runner
+    class Default
+      Runner.register :default, self
+
+      singleton_class.send(:attr_accessor, :run_method)
+      self.run_method = :run
+
+      extend Forwardable
+      include Merge, Suggest
+
+      def_delegators :ctx, :abort
+
+      attr_reader :ctx, :const, :args, :opts
+
+      def initialize(ctx, args)
+        @ctx = ctx
+        @const, @args = lookup(args)
+      end
+
+      def run
+        cmd.help? ? help.run : cmd.send(self.class.run_method)
+      rescue OptionParser::InvalidOption => e
+        raise UnknownOption.new(const, e.message)
+      end
+
+      def cmd
+        @cmd ||= const.new(ctx, args)
+      end
+
+      def help
+        cmd.is_a?(Help) ? cmd : Help.new(ctx, [cmd.registry_key])
+      end
+
+      def suggestions(args)
+        keys = args.inject([]) { |keys, arg| keys << [keys.last, arg].compact.join(':') }
+        keys.map { |key| suggest(providers.map(&:to_s), key) }.flatten
+      end
+
+        private
+
+        # Finds a command class to run for the given arguments.
+        #
+        # Stopping at any arg that starts with a dash, find the command
+        # with the key matching the most args when joined with ":", and
+        # remove these used args from the array
+        #
+        # For example, if there are commands registered with the keys
+        #
+        #   git:pull
+        #   git:push
+        #
+        # then for the arguments:
+        #
+        #   git push master
+        #
+        # the method `lookup` will find the constant registered as `git:push`,
+        # remove these from the `args` array, and return both the constant, and
+        # the remaining args.
+        #
+        # @param args [Array<String>] arguments to run (usually ARGV)
+        def lookup(args)
+          keys = args.take_while { |key| !key.start_with?('-') }
+
+          keys = keys.inject([[], []]) do |keys, key|
+            keys[1] << key
+            keys[0] << [Cmd[keys[1].join(':')], keys[1].dup] if Cmd.registered?(keys[1].join(':'))
+            keys
+          end
+
+          cmd, keys = keys[0].last
+          raise UnknownCmd.new(self, args) if cmd.nil? || cmd.abstract?
+          keys.each { |key| args.delete_at(args.index(key)) }
+          [cmd, args]
+        end
+
+      def providers
+        Cmd.registry.keys
+      end
+    end
+  end
+end