clee 0.4.2

data/lib/clee.rb

@@ -0,0 +1,623 @@
+# -*- encoding : utf-8 -*-
+#
+  require_relative 'clee/_lib.rb'
+
+  Clee.load_dependencies!
+
+#
+  class Clee
+    class Error < ::StandardError; end
+
+    attr_accessor :env
+    attr_accessor :argv
+    attr_accessor :options
+    attr_accessor :params
+    attr_accessor :stdin
+    attr_accessor :stdout
+    attr_accessor :stderr
+    attr_accessor :help
+
+    def _run!
+      _setup!
+      _parse_command_line!
+      _set_mode!
+      _run_mode!
+    end
+
+    def _setup!
+      @klass = self.class
+
+      @env = Hash.new
+      @options = Hash.new
+
+      @argv = ARGV.map(&:dup)
+
+      @stdin = $stdin.dup
+      @stdout = $stdout.dup
+      @stderr = $stderr.dup
+
+      @name = @klass.name.dup
+      @help = @klass.help.dup
+      @tldr = @klass.tldr.dup
+    end
+
+    def _parse_command_line!
+      _parse_options!
+      _parse_env!
+      _parse_params!
+    end
+
+    def _parse_options!
+      @options = Hash.new
+
+      o = OptionParser.new
+
+      klass.options.each do |spec|
+        spec => long:, short:, value:
+        args = []
+
+        case value
+          when :required
+            args.push "-#{ short }" if short
+            args.push "--#{ long } value" if long
+          when :optional
+            args.push "-#{ short }" if short
+            args.push "--#{ long } [value]" if long
+          when :none
+            args.push "-#{ short }" if short
+            args.push "--[no-]#{ long }" if long
+        end
+
+        o.on(*args) do |val|
+          if @options.has_key?(long)
+            @options[long] = [@options[long], val].flatten
+          else
+            @options[long] = val
+          end
+        end
+      end
+
+      begin
+        o.parse!(@argv)
+      rescue OptionParser::MissingArgument => e
+        warn(e.message)
+        exit 1
+      rescue OptionParser::InvalidOption => e
+        warn(e.message)
+        exit 1
+      end
+
+      Clee.symbolize_keys!(@options)
+    end
+
+    def _parse_env!
+    #
+      envs = Hash.new
+
+      @argv.each_with_index do |arg, index|
+        if arg =~ /[^=]+\s*=/
+          k, v = arg.split(/\s*=\s*/, 3)
+
+          key = k.to_s.strip.to_sym
+          val = v.to_s.strip == '' ? nil : v
+
+          envs[index] = {key:, val:}
+        end
+      end
+
+    #
+      validate = proc do |long:, value:, val:|
+        case value
+          when :required
+            unless val
+              warn("#{ long }=:missing")
+              exit 1
+            end
+
+          when :none
+            unless val.nil?
+              warn("#{ long }=#{ val }")
+              exit 1
+            end
+
+          when :optional
+            :noop
+        end
+      end
+
+    #
+      add_env = proc do |long, val|
+        if @env.has_key?(long)
+          @env[long] = [@env[long], val].flatten
+        else
+          @env[long] = val
+        end
+      end
+
+      klass.envs.each do |spec|
+        spec => long:, short:, keys:, value:
+
+        keys.reverse.each do |key|
+          if ENV.has_key?(key.to_s)
+            v = ENV[key.to_s]
+            val = v.to_s.strip == '' ? nil : v
+            validate[long:, value:, val:]
+            add_env[long, val]
+          end
+        end
+
+        envs.each do |index, env|
+          env => key:, val:
+
+          if([long, short].include?(key))
+            validate[long:, value:, val:]
+            add_env[long, val]
+            @argv[index] = nil
+          end
+        end
+      end
+
+    #
+      @argv.compact!
+
+      Clee.symbolize_keys!(@env)
+    end
+
+    def _parse_params!
+      @params = @env.merge(@options)
+    end
+
+    def _set_mode!
+      @mode = nil
+
+      first = 0
+      last = @argv.size
+
+      while last > 0
+        args = @argv[first ... last]
+        mode = klass.mode?(*args)
+
+        if mode
+          @mode = mode
+          @argv.replace(@argv[last..])
+          break
+        end
+
+        last = last - 1
+      end
+    end
+
+    def _run_mode!
+      if @mode
+        mode_method = klass.mode_method_for(@mode)
+        send(mode_method)
+        exit 0
+      end
+
+      if argv.first == 'help' || params[:help]
+        help!(exit: 0)
+      end
+
+      send(:run)
+      exit 0
+    end
+
+    def _default_run!
+      help!(exit: 1)
+    end
+
+    def run
+      _default_run!
+    end
+
+    def progname
+      File.basename($0)
+    end
+
+    def help!(**kws)
+      help = (@help || _default_help)
+      puts help
+      status = kws.fetch(:exit){ kws.fetch('exit'){ 1 } }
+      exit(status.to_i) if status
+    end
+
+    def _default_help
+      [].tap do |l|
+        p = proc do |string|
+          l.push string.to_s.rstrip
+          l.push "\n"
+        end
+
+        h = proc do |header|
+          l.push "\n"
+          p[header]
+          p['_' * header.to_s.size]
+        end
+
+        h[:NAME]
+        p["  #{ progname }"]
+
+        if @tldr
+          h[:TLDR]
+          p["  #{ @tldr }"]
+        end
+
+        unless klass.envs.empty?
+          h[:ENVIRONMENT]
+          klass.envs.each do |spec|
+            spec => value:, keys:
+
+            if value == :none
+              p["  #{ keys.join(' | ') }"]
+            else
+              p["  #{ keys.join(' | ') } : value=#{ value }"]
+            end
+          end
+        end
+
+        unless klass.options.empty?
+          h[:OPTIONS]
+          klass.options.each do |spec|
+            spec => value:, opts:
+
+            if value == :none
+              p["  #{ opts.join(' | ') }"]
+            else
+              p["  #{ opts.join(' | ') } : value=#{ value }"]
+            end
+          end
+        end
+
+
+        h[:MODES]
+        p["  ~> #{ progname }"]
+        modes.each do |mode|
+          p["  ~> #{ progname } #{ mode.join ' ' }"]
+        end
+        p["  ~> #{ progname } help"]
+
+      end.join.strip
+    end
+  #
+    def Clee.deep_copy(obj)
+      Marshal.load(Marshal.dump(obj))
+    end
+
+    def Clee.symbolize_keys!(hash)
+      hash.transform_keys!(&:to_sym)
+
+      hash.each do |key, val|
+        if val.is_a?(Hash)
+          symbolize_keys!(val)
+        end
+      end
+
+      hash
+    end
+
+    def Clee.stringify_keys(hash)
+      stringify_keys!(deep_copy(hash))
+    end
+
+    def Clee.stringify_keys!(hash)
+      hash.transform_keys!(&:to_sym)
+
+      hash.each do |key, val|
+        if val.is_a?(Hash)
+          stringify_keys!(val)
+        end
+      end
+
+      hash
+    end
+
+    def Clee.stringify_keys(hash)
+      stringify_keys!(deep_copy(hash))
+    end
+
+  #
+    def klass
+      self.class
+    end
+
+    def Clee.klass
+      self
+    end
+
+  #
+    ANSI = {
+      :clear      => "\e[0m",
+      :reset      => "\e[0m",
+      :erase_line => "\e[K",
+      :erase_char => "\e[P",
+      :bold       => "\e[1m",
+      :dark       => "\e[2m",
+      :underline  => "\e[4m",
+      :underscore => "\e[4m",
+      :blink      => "\e[5m",
+      :reverse    => "\e[7m",
+      :concealed  => "\e[8m",
+      :black      => "\e[30m",
+      :red        => "\e[31m",
+      :green      => "\e[32m",
+      :yellow     => "\e[33m",
+      :blue       => "\e[34m",
+      :magenta    => "\e[35m",
+      :cyan       => "\e[36m",
+      :white      => "\e[37m",
+      :on_black   => "\e[40m",
+      :on_red     => "\e[41m",
+      :on_green   => "\e[42m",
+      :on_yellow  => "\e[43m",
+      :on_blue    => "\e[44m",
+      :on_magenta => "\e[45m",
+      :on_cyan    => "\e[46m",
+      :on_white   => "\e[47m"
+    }
+
+    Ansi = Object.new
+
+    ANSI.each do |key, value|
+      Ansi.singleton_class.define_method(key){ value }
+    end
+
+    def Clee.ansi
+      @ansi ||= Ansi
+    end
+
+    def ansi
+      klass.ansi
+    end
+
+  #
+    class Logger
+      Levels = [
+        :success,
+        :failure,
+        :message,
+        :warning,
+        :special,
+      ]
+
+      Colors = {
+        success: Ansi.green,
+        failure: Ansi.red,
+        message: Ansi.cyan,
+        default: Ansi.blue,
+        warning: Ansi.yellow,
+        special: Ansi.magenta,
+        clear: Ansi.clear,
+      }
+
+      def initialize(io = $stderr)
+        @io = io
+      end
+
+      def log(arg, *args, **kws)
+        level = kws.fetch(:level){ :message }
+        color = kws[:color] ? Ansi.public_send(kws[:color]) : color_for(level)
+        clear = color_for(:clear)
+
+        [arg, *args].each do |arg|
+          ts = Time.now.utc.iso8601(2)
+          msg = msg_for(arg)
+
+          prefix = "### [#{ level.to_s.upcase } @ #{ ts }]"
+
+          if @io.tty?
+            @io.write(color)
+            @io.write(prefix)
+            @io.write(clear)
+          else
+            @io.write(prefix)
+          end
+
+          @io.write("\n#{ msg }\n")
+          @io.flush
+        end
+      end
+
+      Levels.each do |level|
+        define_method(level){|arg, *args| log(arg, *args, level:)}
+      end
+
+      def color_for(level)
+        Colors.fetch(level.to_s.to_sym){ Colors.fetch(:default) }
+      end
+
+      def msg_for(arg)
+        case
+          when arg.is_a?(String)
+            arg.strip
+          when arg.is_a?(Exception)
+            "#{ e.message } (#{ e.class.name })\n#{ Array(e.backtrace).join(10.chr) }"
+          else
+            arg.pretty_inspect
+        end
+      end
+    end
+
+    def Clee.logger
+      @@logger ||= Logger.new
+    end
+
+    def logger
+      klass.logger
+    end
+
+    def log(*args, **kws, &block)
+      return logger if args.empty? && kws.empty? && block.nil?
+
+      logger.message(*args, **kws, &block)
+    end
+
+    def emsg(e)
+      if e.is_a?(Exception)
+        "#{ e.message } (#{ e.class.name })\n#{ Array(e.backtrace).join(10.chr) }"
+      else
+        e.to_s
+      end
+    end
+
+  #
+    def Clee.parse_spec(list, *args, **kws, &block)
+      return list if args.empty? && kws.empty? && block.nil?
+
+      argv = []
+
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          kws.update(Clee.symbolize_keys(arg))
+        else
+          argv.push(arg)
+        end
+      end
+
+      long = kws.fetch(:long){ argv.shift }
+      raise ArgumentError.new('long=nil') unless long
+      long = long.to_s.to_sym
+
+      short = kws.fetch(:short){ argv.shift }
+
+      value = kws.fetch(:value){ :none }.to_s.to_sym
+
+      values = [:none, :required, :optional]
+
+      raise ArgumentError.new("value=#{ value }") unless values.include?(value)
+
+      keys = [long, short].compact
+
+      opts = [(long && "--#{ long }"), (short &&"-#{ short}")].compact
+
+      spec = {long:, short:, value:, keys:, opts:}
+
+      list.push(spec).uniq!
+    end
+
+    def Clee.options(*args, **kws, &block)
+      parse_spec(@@options ||= [], *args, **kws, &block)
+    end
+
+    def Clee.option(*args, **kws, &block)
+      options(*args, **kws, &block)
+    end
+
+    def Clee.opt(*args, **kws, &block)
+      options(*args, **kws, &block)
+    end
+
+    def Clee.envs(*args, **kws, &block)
+      parse_spec(@@envs ||= [], *args, **kws, &block)
+    end
+
+    def Clee.env(*args, **kws, &block)
+      envs(*args, **kws, &block)
+    end
+
+    def Clee.params(*args, **kws, &block)
+      parse_spec(@@options ||= [], *args, **kws, &block)
+      parse_spec(@@envs ||= [], *args, **kws, &block)
+
+      @@options + @@envs
+    end
+
+    def Clee.param(*args, **kws, &block)
+      params(*args, **kws, &block)
+    end
+
+    def Clee.help(*args)
+      @help ||= nil
+
+      unless args.empty?
+        @help = args.join("\n")
+      end
+
+      @help
+    end
+
+    def Clee.tldr(*args)
+      @tldr ||= nil
+
+      unless args.empty?
+        @tldr = args.join("\n")
+      end
+
+      @tldr
+    end
+
+    def Clee.run(*args, **kws, &block)
+      if args.empty?
+        method = :run
+      else
+        mode = mode_for(*args)
+        klass.modes.push(mode).uniq!
+        method = mode_method_for(mode)
+      end
+
+      define_method(method, &block)
+    end
+
+    def Clee.mode_for(*args)
+      args.flatten!
+      args.compact!
+
+      return nil if args.empty?
+
+      args.map(&:to_s).map(&:to_sym)
+    end
+
+    def Clee.modes
+      @@modes ||= []
+    end
+
+    def modes
+      klass.modes
+    end
+
+    def Clee.mode?(*args)
+      mode = mode_for(*args)
+      return mode if modes.include?(mode)
+    end
+
+    def Clee.mode_method_for(mode)
+      "__mode__#{ [mode].join('__') }"
+    end
+
+  #
+    def Clee.klass_for(name = 'clee', &block)
+      Class.new(Clee).tap do |klass|
+        klass.class_eval do
+          define_singleton_method(:name){ "#{ name }" }
+
+          option(:help, :h, value: :none)
+        end
+
+        klass.class_eval(&block)
+      end
+    end
+
+    def Clee._run!(name = 'clee', *args, &block)
+      $stdout.sync = true
+      $stderr.sync = true
+
+      %w[ PIPE INT ].each{|signal| Signal.trap(signal, "EXIT")}
+
+      klass = Clee.klass_for(name, &block)
+
+      clee = klass.new
+
+      clee._run!(*args)
+    end
+  end
+
+BEGIN { 
+  Object.send(:remove_const, :Clee) if Object.const_defined?(:Clee)
+
+  def Clee(*args, &block)
+    clee(*args, &block)
+  end
+
+  def clee(name = 'clee', *args, &block)
+    Clee._run!(name, *args, &block)
+  end
+}

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: clee
+version: !ruby/object:Gem::Version
+  version: 0.4.2
+platform: ruby
+authors:
+- Ara T. Howard
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-03-09 00:00:00.000000000 Z
+dependencies: []
+description: "`clee` has everything you need, and nothing you don't"
+email: ara.t.howard@gmail.com
+executables:
+- clee
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- Rakefile
+- TODO.md
+- bin/clee
+- clee.gemspec
+- docs/sunwukong.md
+- lib/clee.rb
+- lib/clee/_lib.rb
+homepage: https://github.com/ahoward/clee
+licenses:
+- LicenseRef-LICENSE.md
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: "`clee` is a tiny, 0 dependency, DSL for building über clean CLIs in Ruby"
+test_files: []