cl 0.0.4 → 0.1.0

data/lib/cl/opt.rb

@@ -0,0 +1,141 @@
+require 'cl/cast'
+
+class Cl
+  class Opt < Struct.new(:strs, :opts, :block)
+    include Cast
+
+    OPT = /^--(?:\[.*\])?(.*)$/
+
+    TYPES = {
+      int: :integer,
+      str: :string,
+      bool: :flag,
+      boolean: :flag
+    }
+
+    def initialize(*)
+      super
+      noize(strs) if type == :flag && default.is_a?(TrueClass)
+    end
+
+    def define(const)
+      return unless __key__ = name
+      const.include Module.new {
+        define_method (__key__) { opts[__key__] }
+        define_method (:"#{__key__}?") { !!opts[__key__] }
+      }
+    end
+
+    def name
+      return @name if instance_variable_defined?(:@name)
+      opt = strs.detect { |str| str.start_with?('--') }
+      name = opt.split(' ').first.match(OPT)[1] if opt
+      @name = name&.sub('-', '_')&.to_sym
+    end
+
+    def type
+      TYPES[opts[:type]] || opts[:type] || infer_type
+    end
+
+    def infer_type
+      strs.any? { |str| str.split(' ').size > 1 } ? :string : :flag
+    end
+
+    def int?
+      type == :int || type == :integer
+    end
+
+    def description
+      opts[:description]
+    end
+
+    def aliases?
+      !!opts[:alias]
+    end
+
+    def aliases
+      Array(opts[:alias])
+    end
+
+    def deprecated?
+      !!opts[:deprecated]
+    end
+
+    def deprecated
+      return [name] if opts[:deprecated].is_a?(TrueClass)
+      Array(opts[:deprecated]) if opts[:deprecated]
+    end
+
+    def default?
+      !!default
+    end
+
+    def default
+      opts[:default]
+    end
+
+    def enum?
+      !!opts[:enum]
+    end
+
+    def enum
+      Array(opts[:enum])
+    end
+
+    def known?(value)
+      enum.include?(value)
+    end
+
+    def format?
+      !!opts[:format]
+    end
+
+    def format
+      opts[:format].to_s.sub('(?-mix:', '').sub(/\)$/, '')
+    end
+
+    def formatted?(value)
+      opts[:format] =~ value
+    end
+
+    def max?
+      int? && !!opts[:max]
+    end
+
+    def max
+      opts[:max]
+    end
+
+    def required?
+      !!opts[:required]
+    end
+
+    def requires?
+      !!opts[:requires]
+    end
+
+    def requires
+      Array(opts[:requires])
+    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, name, value)
+      if type == :array
+        opts[name] ||= []
+        opts[name] << value
+      else
+        opts[name] = value
+      end
+    end
+
+    def noize(strs)
+      strs = strs.select { |str| str.start_with?('--') }
+      strs = strs.reject { |str| str.include?('[no-]') }
+      strs.each { |str| str.replace(str.sub('--', '--[no-]')) }
+    end
+  end
+end

data/lib/cl/opts.rb

@@ -0,0 +1,155 @@
+require 'cl/opt'
+
+class Cl
+  class Opts
+    include Enumerable
+
+    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)
+      self << opt
+    end
+
+    def apply(cmd, opts)
+      opts = with_defaults(cmd, opts)
+      opts = cast(opts)
+      validate(cmd, opts) unless opts[:help]
+      opts
+    end
+
+    def <<(opt)
+      # keep the --help option at the end for help output
+      opts.empty? ? opts << opt : opts.insert(-2, opt)
+    end
+
+    def [](key)
+      opts.detect { |opt| opt.name == key }
+    end
+
+    def each(&block)
+      opts.each(&block)
+    end
+
+    def to_a
+      opts
+    end
+
+    attr_writer :opts
+
+    def opts
+      @opts ||= []
+    end
+
+    def deprecated
+      map(&:deprecated).flatten.compact
+    end
+
+    def dup
+      super.tap { |obj| obj.opts = opts.dup }
+    end
+
+    private
+
+      def validate(cmd, opts)
+        validate_requireds(cmd, opts)
+        validate_required(opts)
+        validate_requires(opts)
+        validate_max(opts)
+        validate_format(opts)
+        validate_enum(opts)
+      end
+
+      def validate_requireds(cmd, opts)
+        opts = missing_requireds(cmd, opts)
+        raise RequiredsOpts.new(opts) if opts.any?
+      end
+
+      def validate_required(opts)
+        opts = missing_required(opts)
+        # make sure we do not accept unnamed required options
+        raise RequiredOpts.new(opts.map(&:name)) if opts.any?
+      end
+
+      def validate_requires(opts)
+        opts = missing_requires(opts)
+        raise RequiresOpts.new(invert(opts)) if opts.any?
+      end
+
+      def validate_max(opts)
+        opts = exceeding_max(opts)
+        raise ExceedingMax.new(opts) if opts.any?
+      end
+
+      def validate_format(opts)
+        opts = invalid_format(opts)
+        raise InvalidFormat.new(opts) if opts.any?
+      end
+
+      def validate_enum(opts)
+        opts = unknown_values(opts)
+        raise UnknownValues.new(opts) if opts.any?
+      end
+
+      def missing_requireds(cmd, opts)
+        opts = cmd.class.required.map do |alts|
+          alts if alts.none? { |alt| Array(alt).all? { |key| opts.key?(key) } }
+        end.compact
+      end
+
+      def missing_required(opts)
+        select(&:required?).select { |opt| !opts.key?(opt.name) }
+      end
+
+      def missing_requires(opts)
+        select(&:requires?).map do |opt|
+          missing = opt.requires.select { |key| !opts.key?(key) }
+          [opt.name, missing] if missing.any?
+        end.compact
+      end
+
+      def exceeding_max(opts)
+        select(&:max?).map do |opt|
+          [opt.name, opt.max] if opts[opt.name] > opt.max
+        end.compact
+      end
+
+      def invalid_format(opts)
+        select(&:format?).map do |opt|
+          [opt.name, opt.format] unless opt.formatted?(opts[opt.name])
+        end.compact
+      end
+
+      def unknown_values(opts)
+        select(&:enum?).map do |opt|
+          [opt.name, opts[opt.name], opt.enum] unless opt.known?(opts[opt.name])
+        end.compact
+      end
+
+      def with_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 cast(opts)
+        opts.map do |key, value|
+          [key, self[key] ? self[key].cast(value) : value]
+        end.to_h
+      end
+
+      def invert(hash)
+        hash.map { |key, obj| Array(obj).map { |obj| [obj, key] } }.flatten(1).to_h
+      end
+  end
+end

data/lib/cl/parser.rb

@@ -0,0 +1,39 @@
+require 'optparse'
+
+class Cl
+  class Parser < OptionParser
+    attr_reader :opts
+
+    def initialize(opts, args)
+      @opts = {}
+
+      super do
+        opts.each do |opt|
+          on(*opt.strs) do |value|
+            set(opt, value)
+          end
+
+          opt.aliases.each do |name|
+            on(aliased(opt, name)) do |value|
+              @opts[name] = set(opt, value)
+            end
+          end
+        end
+      end
+
+      parse!(args)
+    end
+
+    def aliased(opt, name)
+      str = opt.strs.detect { |str| str.start_with?('--') } || raise
+      str.sub(opt.name.to_s, name.to_s)
+    end
+
+    # should consider negative arities (e.g. |one, *two|)
+    def set(opt, value)
+      args = [opts, opt.type, opt.name, value]
+      args = args[-opt.block.arity, opt.block.arity]
+      instance_exec(*args, &opt.block)
+    end
+  end
+end

data/lib/cl/runner/default.rb

@@ -1,41 +1,57 @@
-require 'cl/options'
+require 'forwardable'
+require 'cl/ctx'
+require 'cl/parser'
+require 'cl/helper'
 
-module Cl
+class Cl
   module Runner
     class Default
-      attr_reader :const, :args, :opts
+      extend Forwardable
+      include Merge
 
-      def initialize(*args)
-        args = args.flatten.map(&:to_s)
-        @const, @args, @opts = lookup(args)
+      def_delegators :ctx, :abort
+
+      attr_reader :ctx, :const, :args, :opts
+
+      def initialize(ctx, args)
+        @ctx = ctx
+        @const, @args = lookup(args)
+        # @opts, @args = parse(args)
       end
 
       def run
-        cmd.run
+        cmd.help? ? help.run : cmd.run
       end
 
       def cmd
-        const.new(args, opts)
+        @cmd ||= const.new(ctx, args)
+      end
+
+      def help
+        Help.new(ctx, [cmd.registry_key])
       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]
+          keys = expand(args) & Cmd.registry.keys.map(&:to_s)
+          cmd = Cmd[keys.last] || abort("Unknown command: #{args.join(' ')}")
+          [cmd, args - keys(cmd)]
+        end
+
+        def name
+          const.registry_key
         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
+        def keys(cmd)
+          keys = cmd.registry_key.to_s.split(':')
+          keys.concat(expand(keys)).uniq
         end
 
-        def keys_for(args)
-          args.inject([]) { |keys, key| keys << [keys.last, key].compact.join(':') }
+        def expand(strs)
+          # strs = strs.reject { |str| str.start_with?('-') }
+          strs = strs.take_while { |str| !str.start_with?('-') }
+          strs.inject([]) { |strs, str| strs << [strs.last, str].compact.join(':') }
         end
     end
   end

data/lib/cl/runner/multi.rb

@@ -1,11 +1,10 @@
-require 'cl/options'
-
-module Cl
+class Cl
   module Runner
     class Multi
-      attr_reader :cmds
+      attr_reader :name, :cmds
 
-      def initialize(*args)
+      def initialize(name, *args)
+        @name = name
         @cmds = build(group(args))
       end
 
@@ -17,7 +16,7 @@ module Cl
 
         def group(args, cmds = [])
           args.flatten.map(&:to_s).inject([[]]) do |cmds, arg|
-            cmd = Cl[arg]
+            cmd = Cmd.registered?(arg) ? Cmd[arg] : nil
             cmd ? cmds << [cmd] : cmds.last << arg
             cmds.reject(&:empty?)
           end
@@ -25,7 +24,7 @@ module Cl
 
         def build(cmds)
           cmds.map do |(cmd, *args)|
-            cmd.new(args, Options.new(cmd.opts, args).opts)
+            cmd.new(name, args)
           end
         end
     end

data/lib/cl/ui.rb

@@ -0,0 +1,137 @@
+require 'stringio'
+
+class Cl
+  module Ui
+    def self.new(ctx, opts)
+      const = Test if ctx.test?
+      const ||= Silent if opts[:silent]
+      const ||= Tty if $stdout.tty?
+      const ||= Pipe
+      const.new(opts)
+    end
+
+    class Base < Struct.new(:opts)
+      attr_writer :stdout
+
+      def stdout
+        @stdout ||= opts[:stdout] || $stdout
+      end
+
+      def puts(*str)
+        stdout.puts(*str)
+      end
+    end
+
+    class Silent < Base
+      %i(announce info notice warn error success cmd).each do |name|
+        define_method (name) { |*| }
+      end
+    end
+
+    class Test < Base
+      %i(announce info notice warn error success cmd).each do |name|
+        define_method (name) do |*args|
+          puts ["[#{name}]", *args.map(&:inspect)].join(' ')
+        end
+      end
+
+      def stdout
+        @stdout ||= StringIO.new
+      end
+    end
+
+    class Pipe < Base
+      %i(announce info notice warn error).each do |name|
+        define_method (name) do |msg, args = nil, _ = nil|
+          puts format_msg(msg, args)
+        end
+      end
+
+      %i(success cmd).each do |name|
+        define_method (name) { |*| }
+      end
+
+      private
+
+        def format_msg(msg, args)
+          msg = [msg, args].flatten.map(&:to_s)
+          msg = msg.map { |str| quote_spaced(str) }
+          msg.join(' ').strip
+        end
+
+        def quote_spaced(str)
+          str.include?(' ') ? %("#{str}") : str
+        end
+    end
+
+    module Colors
+      COLORS = {
+        red:    "\e[31m",
+        green:  "\e[32m",
+        yellow: "\e[33m",
+        blue:   "\e[34m",
+        gray:   "\e[37m",
+        reset:  "\e[0m"
+      }
+
+      def colored(color, str)
+        [COLORS[color], str, COLORS[:reset]].join
+      end
+    end
+
+    class Tty < Base
+      include Colors
+
+      def announce(msg, args = [], msgs = [])
+        msg = format_msg(msg, args, msgs)
+        puts colored(:green, with_spacing(msg, true))
+      end
+
+      def info(msg, args = [], msgs = [])
+        msg = format_msg(msg, args, msgs)
+        puts colored(:blue, with_spacing(msg, true))
+      end
+
+      def notice(msg, args = [], msgs = [])
+        msg = format_msg(msg, args, msgs)
+        puts colored(:gray, with_spacing(msg, false))
+      end
+
+      def warn(msg, args = [], msgs = [])
+        msg = format_msg(msg, args, msgs)
+        puts colored(:yellow, with_spacing(msg, false))
+      end
+
+      def error(msg, args = [], msgs = [])
+        msg = format_msg(msg, args, msgs)
+        puts colored(:red, with_spacing(msg, true))
+      end
+
+      def success(msg)
+        announce(msg)
+        puts
+      end
+
+      def cmd(msg)
+        notice("$ #{msg}")
+      end
+
+      private
+
+        def colored(color, str)
+          opts[:color] ? super : str
+        end
+
+        def format_msg(msg, args, msgs)
+          msg = msgs[msg] % args if msg.is_a?(Symbol)
+          msg.strip
+        end
+
+        def with_spacing(str, space)
+          str = "\n#{str}" if space && !@last
+          @last = space
+          str
+        end
+    end
+  end
+end

data/lib/cl/version.rb

@@ -1,3 +1,3 @@
-module Cl
-  VERSION = '0.0.4'
+class Cl
+  VERSION = '0.1.0'
 end

data/lib/cl.rb

@@ -3,12 +3,19 @@ require 'cl/help'
 require 'cl/runner/default'
 require 'cl/runner/multi'
 
-module Cl
+class 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)'
+      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)',
+      exceeding_max:  'Exceeds max value: %s',
+      invalid_format: 'Invalid format: %s',
+      unknown_values: 'Unknown value: %s',
+      required_opt:   'Missing required option: %s',
+      required_opts:  'Missing required options: %s',
+      requires_opt:   'Missing option: %s',
+      requires_opts:  'Missing options: %s',
     }
 
     def initialize(msg, *args)
@@ -17,29 +24,67 @@ module Cl
   end
 
   ArgumentError = Class.new(Error)
+  OptionError = Class.new(Error)
+  RequiredOpts = Class.new(OptionError)
 
-  def included(const)
-    const.send(:include, Cmd)
+  class RequiredsOpts < OptionError
+    def initialize(opts)
+      opts = opts.map { |alts| alts.map { |alt| Array(alt).join(' and ') }.join(' or ' ) }
+      super(:requires_opts, opts.join(', '))
+    end
   end
 
-  def run(*args)
-    runner(*args).run
-  rescue Error => e
-    abort [e.message, runner(:help, *args).cmd.help].join("\n\n")
+  class RequiresOpts < OptionError
+    def initialize(opts)
+      msg = opts.size == 1 ? :requires_opt : :requires_opts
+      opts = opts.map { |one, other| "#{one} (required by #{other})" }.join(', ')
+      super(msg, opts)
+    end
+  end
+
+  class ExceedingMax < OptionError
+    def initialize(opts)
+      opts = opts.map { |opt, max| "#{opt} (max: #{max})" }.join(', ')
+      super(:exceeding_max, opts)
+    end
   end
 
-  def help(*args)
-    runner(:help, *args).run
+  class InvalidFormat < OptionError
+    def initialize(opts)
+      opts = opts.map { |opt, format| "#{opt} (format: #{format})" }.join(', ')
+      super(:invalid_format, opts)
+    end
   end
 
-  attr_writer :runner
-  @runner = :default
+  class UnknownValues < OptionError
+    def initialize(opts)
+      opts = opts.map { |(key, value, known)| "#{key}=#{value} (known values: #{known.join(', ')})" }.join(', ')
+      super(:unknown_values, opts)
+    end
+  end
+
+  attr_reader :ctx, :name, :opts
+
+  def initialize(*args)
+    ctx   = args.shift if args.first.is_a?(Ctx)
+    @opts = args.last.is_a?(Hash) ? args.pop : {}
+    @name = args.shift || $0
+    @ctx  = ctx || Ctx.new(name, opts)
+  end
+
+  def run(args)
+    runner(args).run
+  rescue Error => e
+    abort [e.message, runner(['help', args.first]).cmd.help].join("\n\n")
+  end
 
-  def runner(*args)
-    args = args.flatten
-    runner = args.first.to_s == 'help' ? :default : @runner
-    Runner.const_get(runner.to_s.capitalize).new(*args)
+  def runner(args)
+    runner = :default if args.first.to_s == 'help'
+    runner ||= opts[:runner] || :default
+    Runner.const_get(runner.to_s.capitalize).new(ctx, args)
   end
 
-  extend self
+  # def help(*args)
+  #   runner(:help, *args).run
+  # end
 end