cl 0.0.4 → 0.1.0

data/lib/cl/cast.rb

@@ -0,0 +1,29 @@
+class Cl
+  module Cast
+    TRUE  = /^(true|yes|on)$/
+    FALSE = /^(false|no|off)$/
+
+    def cast(value)
+      case type
+      when nil
+        value
+      when :array
+        Array(value).compact.flatten.map { |value| value.to_s.split(',') }.flatten
+      when :string, :str
+        value.to_s unless value.to_s.empty?
+      when :flag, :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
+  end
+end

data/lib/cl/cmd.rb

@@ -1,13 +1,35 @@
+require 'registry'
 require 'cl/args'
-require 'cl/registry'
+require 'cl/helper'
+require 'cl/opts'
+# require 'cl/registry'
 
-module Cl
-  class Cmd < Struct.new(:args, :opts)
+class Cl
+  class Cmd
     include Registry
 
     class << self
-      def inherited(cmd)
-        cmd.register underscore(cmd.name.split('::').last)
+      include Merge
+
+      inherited = ->(const) do
+        const.register [registry_key, underscore(const.name.split('::').last)].compact.join(':') if const.name
+        const.define_singleton_method(:inherited, &inherited)
+      end
+
+      define_method(:inherited, &inherited)
+
+      def cmds
+        registry.values
+      end
+
+      def parse(ctx, args)
+        opts = Parser.new(self.opts, args).opts unless self == Help
+        opts = merge(ctx.config[registry_key], opts) if ctx.config[registry_key]
+        [args, opts]
+      end
+
+      def abstract
+        unregister
       end
 
       def args(*args)
@@ -16,22 +38,35 @@ module Cl
         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 arg(*args)
+        self.args.define(self, *args)
       end
 
       def opt(*args, &block)
-        opts << [args, block]
+        self.opts.define(self, *args, &block)
       end
 
       def opts
-        @opts ||= superclass != Cmd && superclass.respond_to?(:opts) ? superclass.opts.dup : []
+        @opts ||= self == Cmd ? Opts.new : superclass.opts.dup
+      end
+
+      def description(description = nil)
+        description ? @description = description : @description
       end
 
+      def required?
+        !!@required
+      end
+
+      def required(*required)
+        required.any? ? self.required << required : @required ||= []
+      end
+
+      def summary(summary = nil)
+        summary ? @summary = summary : @summary
+      end
+      alias purpose summary
+
       def underscore(string)
         string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
         gsub(/([a-z\d])([A-Z])/,'\1_\2').
@@ -39,10 +74,23 @@ module Cl
       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
+    opt '--help', 'Get help on this command'
+
+    attr_reader :ctx, :args
+
+    def initialize(ctx, args)
+      args, opts = self.class.parse(ctx, args)
+      @ctx = ctx
+      @opts = self.class.opts.apply(self, self.opts.merge(opts || {}))
+      @args = @opts[:help] ? args : self.class.args.apply(self, args)
+    end
+
+    def opts
+      @opts ||= {}
+    end
+
+    def deprecated_opts
+      opts.keys & self.class.opts.deprecated
     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,29 @@
+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, :ui
+
+    def initialize(name, opts = {})
+      @config = Config.new(name).to_h
+      @ui = Ui.new(self, opts)
+    end
+
+    def abort(str)
+      fail(str) if test?
+      ui.error(str)
+      exit 1
+    end
+
+    def test?
+      ENV['ENV'] == 'test'
+    end
+  end
+end

data/lib/cl/help/cmd.rb

@@ -0,0 +1,142 @@
+require 'cl/help/table'
+require 'cl/help/usage'
+
+class Cl
+  class Help
+    class Cmd
+      attr_reader :cmd
+
+      def initialize(cmd)
+        @cmd = cmd
+      end
+
+      def format
+        [usage, arguments, options, common, summary, description].compact.join("\n\n")
+      end
+
+      def usage
+        "Usage: #{Usage.new(cmd).format}"
+      end
+
+      def summary
+        ['Summary:', indent(cmd.summary)] if cmd.summary
+      end
+
+      def description
+        ['Description:', indent(cmd.description)] if cmd.description
+      end
+
+      def arguments
+        ['Arguments:', table(:args)] if args.any?
+      end
+
+      def options
+        ['Options:', requireds, table(:opts)].compact if opts.any?
+      end
+
+      def common
+        ['Common Options:', table(:cmmn)] if common?
+      end
+
+      def table(name)
+        table = send(name)
+        indent(table.to_s(width - table.width + 5))
+      end
+
+      def args
+        @args ||= begin
+          Table.new(cmd.args.map { |arg| [arg.name, format_obj(arg)] })
+        end
+      end
+
+      def opts
+        @opts ||= begin
+          opts = cmd.opts.to_a
+          opts = opts - cmd.superclass.opts.to_a if common?
+          strs = Table.new(rjust(opts.map { |opt| [*opt.strs] }))
+          opts = opts.map { |opt| format_obj(opt) }
+          Table.new(strs.rows.zip(opts))
+        end
+      end
+
+      def cmmn
+        @cmmn ||= begin
+          opts = cmd.superclass.opts
+          strs = Table.new(rjust(opts.map { |opt| [*opt.strs] }))
+          opts = opts.map { |opt| format_obj(opt) }
+          Table.new(strs.rows.zip(opts))
+        end
+      end
+
+      def requireds
+        return unless cmd.required?
+        opts = cmd.required
+        strs = opts.map { |alts| alts.map { |alt| Array(alt).join(' and ') }.join(', or ' ) }
+        strs = strs.map { |str| "Either #{str} are required." }.join("\n")
+        indent(strs)
+      end
+
+      def common?
+        cmd.superclass < Cl::Cmd
+      end
+
+      def width
+        [args.width, opts.width, cmmn.width].max
+      end
+
+      def format_obj(obj)
+        opts = []
+        opts << "type: #{format_type(obj)}"
+        opts << 'required: true' if obj.required?
+        opts += format_opt(obj) if obj.is_a?(Opt)
+        opts = opts.join(', ')
+        opts = "(#{opts})" if obj.description && !opts.empty?
+        opts = [obj.description, opts]
+        opts.compact.join(' ')
+      end
+
+      def format_opt(opt)
+        opts = []
+        opts << "alias: #{format_aliases(opt)}" if opt.aliases?
+        opts << "requires: #{opt.requires.join(', ')}" if opt.requires?
+        opts << "default: #{format_default(opt)}" if opt.default?
+        opts << "known values: #{opt.enum.join(', ')}" if opt.enum?
+        opts << "format: #{opt.format}" if opt.format?
+        opts << "max: #{opt.max}" if opt.max?
+        opts << format_deprecated(opt) if opt.deprecated?
+        opts.compact
+      end
+
+      def format_aliases(opt)
+        opt.aliases.map do |name|
+          strs = [name]
+          strs << '(deprecated)' if Array(opt.deprecated).include?(name)
+          strs.join(' ')
+        end.join(', ')
+      end
+
+
+      def format_type(obj)
+        return obj.type unless obj.is_a?(Opt) && obj.type == :array
+        "array (can be given multiple times)"
+      end
+
+      def format_default(opt)
+        opt.default.is_a?(Symbol) ? opt.default.to_s.sub('_', ' ') : opt.default
+      end
+
+      def format_deprecated(opt)
+        return 'deprecated' if opt.deprecated == [opt.name]
+      end
+
+      def rjust(objs)
+        width = objs.max_by(&:size).size
+        objs.map { |objs| [*Array.new(width - objs.size) { '' }, *objs] }
+      end
+
+      def indent(str)
+        str.lines.map { |line| "  #{line}" }.join
+      end
+    end
+  end
+end

data/lib/cl/help/cmds.rb

@@ -0,0 +1,28 @@
+require 'cl/help/table'
+require 'cl/help/usage'
+
+class Cl
+  class Help
+    class Cmds
+      HEAD = %(Type "#{$0.split('/').last} help COMMAND [SUBCOMMAND]" for more details:\n)
+
+      attr_reader :cmds
+
+      def initialize(cmds)
+        @cmds = cmds
+      end
+
+      def format
+        [HEAD, Table.new(list).format].join("\n")
+      end
+
+      def list
+        cmds.any? ? cmds.map { |cmd| format_cmd(cmd) } : [['[no commands]']]
+      end
+
+      def format_cmd(cmd)
+        ["#{Usage.new(cmd).format}", cmd.summary]
+      end
+    end
+  end
+end

data/lib/cl/help/table.rb

@@ -0,0 +1,45 @@
+class Cl
+  class Help
+    class Table
+      attr_reader :data, :padding
+
+      def initialize(data)
+        @data = data
+      end
+
+      def any?
+        data.any?
+      end
+
+      def format(padding = 8)
+        @padding = padding
+        rows.join("\n")
+      end
+      alias to_s format
+
+      def rows
+        data.map { |row| cells(row).join(' ').rstrip }
+      end
+
+      def cells(row)
+        row.map.with_index { |cell, ix| cell.to_s.ljust(widths[ix]) }
+      end
+
+      def width
+        widths = cols[0..-2].map { |col| col.max_by(&:size).size }.inject(&:+).to_i
+        widths + cols.size - 1
+      end
+
+      def widths
+        cols.map.with_index do |col, ix|
+          width = col.compact.max_by(&:size)&.size
+          ix < cols.size - 2 ? width.to_i : width.to_i + padding.to_i
+        end
+      end
+
+      def cols
+        @cols ||= data.transpose
+      end
+    end
+  end
+end

data/lib/cl/{format → help}/usage.rb

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

data/lib/cl/help.rb

@@ -1,33 +1,31 @@
-require 'cl/format/cmd'
-require 'cl/format/list'
-
-module Cl
+class Cl
   class Help < Cl::Cmd
     register :help
 
     def run
-      puts help
+      ctx.puts help
     end
 
     def help
-      cmd ? Format::Cmd.new(cmd).format : Format::List.new(cmds).format
+      args.any? ? Cmd.new(cmd).format : Cmds.new(cmds).format
     end
 
     private
 
       def cmds
-        cmds = Cl.cmds.reject { |cmd| cmd.registry_key == :help }
+        cmds = Cl::Cmd.cmds.reject { |cmd| cmd.registry_key == :help }
         key  = args.join(':') if args
         cmds = cmds.select { |cmd| cmd.registry_key.to_s.start_with?(key) } if key
         cmds
       end
 
       def cmd
-        args.inject([[], []]) do |(args, cmds), arg|
-          args << arg
-          cmds << Cl[args.join(':')]
-          [args, cmds.compact]
-        end.last.last
+        key = args.join(':')
+        return Cl::Cmd[key] if Cl::Cmd.registered?(key)
+        ctx.abort("Unknown command: #{key}")
       end
   end
 end
+
+require 'cl/help/cmd'
+require 'cl/help/cmds'

data/lib/cl/helper.rb

@@ -0,0 +1,11 @@
+class Cl
+  module Merge
+    MERGE = ->(key, lft, rgt) do
+      lft.is_a?(Hash) && rgt.is_a?(Hash) ? lft.merge(rgt, &MERGE) : rgt
+    end
+
+    def merge(*objs)
+      objs.inject({}) { |lft, rgt| lft.merge(rgt, &MERGE) }
+    end
+  end
+end