cli_base 0.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4e6c9333d54368e8012669ea89d3b1ec55fba5f5a8851dfaa4c44df9d922bb41
+  data.tar.gz: 91a489bfed668142eb0efda172b5b4ea6d4441e5d93a34783a2e78c13f12f5e6
+SHA512:
+  metadata.gz: 4a586009ff6a6c1f94476b65c529763c20a2303253072ea31762c6f390049518d437944b0a43184ec86218d40c1d58e63694fd69c49aa4cf127d2b35732ae367
+  data.tar.gz: bdbf99d8468944e32d86d1107e4cf786e5c51d52e507eb6adfa9344b7d765c793b4ee285a665cfa97828dd51075113098439b59fa8f1d48b7be63ddd6cf529d1

data/HISTORY.md

@@ -0,0 +1,48 @@
+# RELEASE HISTORY
+
+## 0.5.1 / 2026-04-01
+
+Maintenance release. Modernized project tooling.
+
+Changes:
+
+* Replace custom metadata system with standard gemspec.
+* Simplify version handling.
+* Update README to markdown.
+* Clean up obsolete files and .gitignore.
+
+
+## 0.5.0 / 2011-10-08
+
+The library has been renamed to CLI::Base (gem name `cli_base`).
+
+Changes:
+
+* Renamed to CLI::Base.
+
+
+## 0.4.0 / 2010-10-12
+
+New API uses nested classes instead of methods for subcommands.
+
+Changes:
+
+* New API!
+
+
+## 0.3.0 / 2010-09-12
+
+The most significant change is the use of bang methods (foo!) for option flags.
+
+Changes:
+
+* Allow bang methods for option flags.
+
+
+## 0.2.0 / 2010-03-02
+
+Initial (non-public) release. Rebranding of older library called TieClip.
+
+Changes:
+
+* Happy Birthday!

data/README.md

@@ -0,0 +1,65 @@
+# CLI::Base
+
+[Source Code](https://github.com/rubyworks/cli_base) |
+[Report Issue](https://github.com/rubyworks/cli_base/issues)
+
+[![Gem Version](https://img.shields.io/gem/v/cli_base.svg?style=flat)](https://rubygems.org/gems/cli_base)
+
+
+## Description
+
+CLI::Base is a quick-and-dirty CLI framework for Ruby. Need a command-line
+interface without the ceremony? Just subclass `CLI::Base` and define methods —
+writer methods (`=`) become options, query methods (`?`) become flags, and
+nested classes become subcommands. No DSL to learn.
+
+Think of it as a COM (Command-to-Object Mapper).
+
+
+## Synopsis
+
+```ruby
+require 'cli/base'
+
+class MyCLI < CLI::Base
+  # Require LIBRARY before executing your script.
+  def require=(lib)
+    require lib
+  end
+  alias :r= :require=
+
+  # Include PATH in $LOAD_PATH.
+  def include=(path)
+    $:.unshift path
+  end
+  alias :I= :include=
+
+  # Run in DEBUG mode.
+  def debug?
+    $DEBUG = true
+  end
+
+  # Show this message.
+  def help?
+    puts self
+    exit
+  end
+  alias :h? :help?
+
+  # Run the command.
+  def main(script)
+    load(script)
+  end
+end
+```
+
+That's it. The comments above each method become the help text automatically.
+
+
+## Copyright
+
+Copyright (c) 2008 Thomas Sawyer, Rubyworks
+
+Distributed under the terms of the **BSD-2-Clause** license.
+
+See COPYING.rdoc for details.

data/lib/cli/base.rb

@@ -0,0 +1,182 @@
+module CLI
+
+  # = CLI::Base
+  #
+  #   class MyCLI < CLI::Base
+  #
+  #     # cmd --debug
+  #
+  #     def debug?
+  #       $DEBUG
+  #     end
+  #
+  #     def debug=(bool)
+  #       $DEBUG = bool
+  #     end
+  #
+  #     # $ foo remote
+  #
+  #     class Remote < CLI::Base
+  #
+  #       # $ foo remote --verbose
+  #
+  #       def verbose?
+  #         @verbose
+  #       end
+  #
+  #       def verbose=(bool)
+  #         @verbose = bool
+  #       end
+  #
+  #       # $ foo remote --force
+  #
+  #       def force?
+  #         @force
+  #       end
+  #
+  #       def force=(bool)
+  #         @force = bool
+  #       end
+  #
+  #       # $ foo remote --output <path>
+  #
+  #       def output=(path)
+  #         @path = path
+  #       end
+  #
+  #       # $ foo remote -o <path>
+  #
+  #       alias_method :o=, :output=
+  #
+  #       # $ foo remote add
+  #
+  #       class Add < self
+  #
+  #         def main(name, branch)
+  #           # ...
+  #         end
+  #
+  #       end
+  #
+  #       # $ foo remote show
+  #
+  #       class Show < self
+  #
+  #         def main(name)
+  #           # ...
+  #         end
+  #
+  #       end
+  #
+  #     end
+  #
+  #   end
+  #
+  class Base
+
+    require 'cli/errors'
+    require 'cli/parser'
+    require 'cli/help'
+    require 'cli/config'
+    require 'cli/utils'
+
+    # TODO: Should #main be called #call instead?
+
+    #
+    def main(*args)
+      #puts self.class  # TODO: fix help
+      raise NoCommandError
+    end
+
+    # Override option_missing if needed. This receives the name of the option
+    # and the remaining argumentslist. It must consume any arguments it uses
+    # from the begining of the list (i.e. in-place manipulation).
+    #
+    def option_missing(opt, argv)
+      raise NoOptionError, opt
+    end
+
+    # Access the help instance of the class of the command object.
+    def cli_help
+      self.class.help
+    end
+
+    class << self
+
+      # Helper method for creating switch attributes.
+      #
+      # This is equivalent to:
+      #
+      #   def name=(val)
+      #     @name = val
+      #   end
+      #
+      #   def name?
+      #     @name
+      #   end
+      #
+      def attr_switch(name)
+        attr_writer name
+        module_eval %{
+          def #{name}?
+            @#{name}
+          end
+        }
+      end
+
+      # Run the command.
+      #
+      # @param argv [Array] command-line arguments
+      #
+      def execute(argv=ARGV)
+        cli, args = parser.parse(argv)
+        cli.main(*args)
+        return cli
+      end
+
+      # CLI::Base classes don't run, they execute! But...
+      alias_method :run, :execute
+
+      # Command configuration options.
+      #
+      # @todo: This isn't used yet. Eventually the idea is to allow
+      #   some additional flexibility in the parser behavior.
+      def config
+        @config ||= Config.new
+      end
+
+      # The parser for this command.
+      def parser
+        @parser ||= Parser.new(self)
+      end
+
+      # List of subcommands.
+      def subcommands
+        parser.subcommands
+      end
+
+      # Interface with cooresponding help object.
+      def help
+        @help ||= Help.new(self)
+      end
+
+      #
+      def inspect
+        name
+      end
+
+      # When inherited, setup up the +file+ and +line+ of the 
+      # subcommand via +caller+. If for some odd reason this
+      # does not work then manually use +setup+ method.
+      #
+      def inherited(subclass)
+        file, line, _ = *caller.first.split(':')
+        file = File.expand_path(file)
+        subclass.help.setup(file,line.to_i)
+      end
+
+    end
+
+  end
+
+end

data/lib/cli/config.rb

@@ -0,0 +1,16 @@
+module CLI
+
+  # Config is essentially an OpenHash.
+  class Config < Hash
+    def method_missing(s, *a, &b)
+      name = s.to_s
+      case name
+      when /=$/
+        self[name.chomp('=')] = a.first
+      else
+        self[name]
+      end
+    end
+  end
+
+end

data/lib/cli/core_ext.rb

@@ -0,0 +1,20 @@
+class UnboundMethod
+  if !method_defined?(:source_location)
+    if Proc.method_defined? :__file__  # /ree/
+      def source_location
+        [__file__, __line__] rescue nil
+      end
+    elsif defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
+      require 'java'
+      def source_location
+        to_java.source_location(Thread.current.to_java.getContext())
+      end
+    end
+  end
+
+  #
+  def comment
+    Source.get_above_comment(*source_location)
+  end
+end
+

data/lib/cli/errors.rb

@@ -0,0 +1,26 @@
+module CLI
+
+  class Base
+
+    class NoOptionError < ::NoMethodError # ArgumentError ?
+      def initialize(name, *arg)
+        super("unknown option -- #{name}", name, *args)
+      end
+    end
+
+    #class NoCommandError < ::NoMethodError
+    #  def initialize(name, *args)
+    #    super("unknown command -- #{name}", name, *args)
+    #  end
+    #end
+
+    class NoCommandError < ::NoMethodError
+      def initialize(*args)
+        super("missing command", *args)
+      end
+    end
+
+  end
+
+end
+

data/lib/cli/help.rb

@@ -0,0 +1,295 @@
+module CLI
+
+  require 'cli/source'
+  require 'cli/core_ext'
+
+  # Encpsulates command help for deefining and displaying well formated help
+  # output in plain text or via manpages if found.
+  class Help
+
+    # Setup new help object.
+    def initialize(cli_class)
+      @cli_class = cli_class
+
+      @usage  = nil
+      @footer = nil
+
+      @options = {}
+      @subcmds = {}
+    end
+
+    # Set file and line under which the CLI::Base subclass is defined.
+    def setup(file, line=nil)
+      @file = file
+      @line = line
+    end
+
+    # The CLI::Base subclass to which this help applies.
+    attr :cli_class
+
+    # Get or set command name.
+    # 
+    # By default the name is assumed to be the class name, substituting
+    # dashes for double colons.
+    def name(name=nil)
+      @name = name if name
+      @name ||= cli_class.name.downcase.gsub('::','-')
+                #File.basename($0)
+      @name
+    end
+
+    # Get or set command usage.
+    def usage(text=nil)
+      @usage ||= "Usage: " + File.basename($0) + ' [options...] [subcommand]'
+      @usage = text unless text.nil?
+      @usage
+    end
+
+    # Set command usage.
+    def usage=(text)
+      @usage = text
+    end
+
+    # Get or set command description.
+    def description(text=nil)
+      @description = text unless text.nil?
+    end
+    alias_method :header, :description
+
+    # Get or set command help footer.
+    def footer(text=nil)
+      @footer = text unless text.nil?
+      @footer
+    end
+
+    # Set comamnd help footer.
+    def footer=(text)
+      @footer = text
+    end
+
+    # Set description of an option.
+    def option(name, description)
+      @options[name.to_s] = description
+    end
+
+    # Set desciption of a subcommand.
+    def subcommand(name, description)
+      @subcmds[name.to_s] = description
+    end
+
+    #alias_method :inspect, :to_s
+
+    # Show help.
+    #
+    # @todo man-pages will probably fail on Windows
+    def show_help(hint=nil)
+      if file = manpage(hint)
+        system "man #{file}"
+      else
+        puts text
+      end
+    end
+
+    # M A N P A G E
+
+    # Get man-page if there is one.
+    def manpage(hint=nil)
+      @manpage ||= (
+        man  = []
+        dir  = @file ? File.dirname(@file) : nil
+        glob = "man/#{name}.1"
+
+        if hint
+          if File.exist?(hint)
+            return hint
+          elsif File.directory?(hint)
+            dir = hint
+          else
+            glob = hint if hint
+          end
+        end
+
+        if dir
+          while dir != '/'
+            man.concat(Dir[File.join(dir, glob)])
+            #man.concat(Dir[File.join(dir, "man/man1/#{name}.1")])
+            #man.concat(Dir[File.join(dir, "man/#{name}.1.ronn")])
+            #man.concat(Dir[File.join(dir, "man/man1/#{name}.1")])
+            break unless man.empty?
+            dir = File.dirname(dir)
+          end
+        end
+
+        man.first
+      )
+    end
+
+    # H E L P  T E X T
+
+    #
+    def to_s; text; end
+
+    #
+    def text(file=nil)
+      s = []
+      s << text_usage
+      s << text_description
+      s << text_subcommands
+      s << text_options
+      s << text_footer
+      s.compact.join("\n\n")
+    end
+
+    # Command usage.
+    def text_usage
+      usage
+    end
+
+    # TODO: Maybe default description should always come from `main`
+    # instead of the the class comment ?
+
+    # Description of command in printable form.
+    # But will return +nil+ if there is no description.
+    #
+    # @return [String,NilClass] command description
+    def text_description
+      if @description
+        @description
+      elsif @file
+        Source.get_above_comment(@file, @line)
+      elsif main = method_list.find{ |m| m.name == 'main' }
+        main.comment
+      else
+        nil
+      end
+    end
+
+    # List of subcommands converted to a printable string.
+    # But will return +nil+ if there are no subcommands.
+    #
+    # @return [String,NilClass] subcommand list text
+    def text_subcommands
+      commands = @cli_class.subcommands
+      s = []
+      if !commands.empty?
+        s << "COMMANDS"
+        commands.each do |cmd, klass|
+          desc = klass.help.text_description.to_s.split("\n").first
+          s << "  %-17s %s" % [cmd, desc]
+        end
+      end
+      return nil if s.empty?
+      return s.join("\n")
+    end
+
+    # List of options coverted to a printable string.
+    # But will return +nil+ if there are no options.
+    # 
+    # @return [String,NilClass] option list text
+    def text_options
+      option_list.each do |opt|
+        if @options.key?(opt.name)
+          opt.description = @options[opt.name]
+        end
+      end    
+
+      max = option_list.map{ |opt| opt.usage.size }.max + 2
+
+      s = []
+      s << "OPTIONS"
+      option_list.each do |opt|
+        mark = (opt.name.size == 1 ? ' -' : '--')
+        s << "  #{mark}%-#{max}s %s" % [opt.usage, opt.description]
+      end
+      s.join("\n")
+    end
+
+    #
+    def text_footer
+      footer
+    end
+
+    #
+    #def text_common_options
+      #s << "\nCOMMON OPTIONS:\n\n"
+      #global_options.each do |(name, meth)|
+      #  if name.size == 1
+      #    s << "   -%-15s %s\n" % [name, descriptions[meth]]
+      #  else
+      #    s << "  --%-15s %s\n" % [name, descriptions[meth]]
+      #  end
+      #end
+    #end
+
+    #
+    def option_list
+      @option_list ||= (
+        method_list.map do |meth|
+          case meth.name
+          when /^(.*?)[\!\=]$/
+            Option.new(meth)
+          end
+        end.compact.sort
+      )
+    end
+
+  private
+
+    # Produce a list relavent methods.
+    #
+    def method_list
+      list      = []
+      methods   = []
+      stop_at   = cli_class.ancestors.index(CLI::Base) || -1
+      ancestors = cli_class.ancestors[0...stop_at]
+      ancestors.reverse_each do |a|
+        a.instance_methods(false).each do |m|
+          list << cli_class.instance_method(m)
+        end
+      end
+      list
+    end
+
+    # Encapsualtes a command line option.
+    class Option
+      def initialize(method)
+        @method = method
+      end
+
+      def name
+        @method.name.to_s.chomp('!').chomp('=')
+      end
+
+      def comment
+        @method.comment
+      end
+
+      def description
+        @description ||= comment.split("\n").first
+      end
+
+      # Set description manually.
+      def description=(desc)
+        @description = desc
+      end
+
+      def parameter
+        param = @method.parameters.first
+        param.last if param
+      end
+
+      def usage
+        if parameter
+          "#{name}=#{parameter.to_s.upcase}"
+        else
+          "#{name}"
+        end
+      end
+
+      def <=>(other)
+        self.name <=> other.name
+      end
+    end
+  end
+
+end

data/lib/cli/parser.rb

@@ -0,0 +1,211 @@
+module CLI
+
+  # The Parse class does all the heavy lifting for CLI::Base.
+  #
+  class Parser
+
+    # 
+    # @param cli_class [CLI::Base] command class
+    #
+    def initialize(cli_class)
+      @cli_class = cli_class
+    end
+
+    attr :cli_class
+
+    # Parse command-line.
+    #
+    # @param argv [Array,String] command-line arguments
+    #
+    def parse(argv=ARGV)
+      argv = parse_shellwords(argv)
+
+      cmd, argv = parse_subcommand(argv)
+      cli  = cmd.new
+      args = parse_arguments(cli, argv)
+
+      return cli, args
+    end
+
+    # Make sure arguments are an array. If argv is a String,
+    # then parse using Shellwords module.
+    #
+    # @param argv [Array,String] commmand-line arguments
+    def parse_shellwords(argv)
+      if String === argv
+        require 'shellwords'
+        argv = Shellwords.shellwords(argv)
+      end
+      argv.to_a
+    end
+
+    #
+    #
+    #
+    def parse_subcommand(argv)
+      cmd = cli_class
+      arg = argv.first
+
+      while c = cmd.subcommands[arg]
+        cmd = c
+        argv.shift
+        arg = argv.first
+      end
+
+      return cmd, argv
+    end
+
+    #
+    # Parse command line options based on given object.
+    #
+    # @param obj [Object] basis for command-line parsing
+    # @param argv [Array,String] command-line arguments
+    # @param args [Array] pre-seeded arguments to add to
+    #
+    # @return [Array] parsed arguments
+    #
+    def parse_arguments(obj, argv, args=[])
+      case argv
+      when String
+        require 'shellwords'
+        argv = Shellwords.shellwords(argv)
+      #else
+      #  argv = argv.dup
+      end
+
+      #subc = nil
+      #@args = []  #opts, i = {}, 0
+
+      while argv.size > 0
+        case arg = argv.shift
+        when /=/
+          parse_equal(obj, arg, argv, args)
+        when /^--/
+          parse_long(obj, arg, argv, args)
+        when /^-/
+          parse_flags(obj, arg, argv, args)
+        else
+          #if CLI::Base === obj
+          #  if cmd_class = obj.class.subcommands[arg]
+          #    cmd  = cmd_class.new(obj)
+          #    subc = cmd
+          #    parse(cmd, argv, args)
+          #  else
+              args << arg
+          #  end
+          #end
+        end
+      end
+     
+      return args
+    end
+
+    #
+    # Parse equal setting comman-line option.
+    #
+    def parse_equal(obj, opt, argv, args)
+      if md = /^[-]*(.*?)=(.*?)$/.match(opt)
+        x, v = md[1], md[2]
+      else
+        raise ArgumentError, "#{x}"
+      end
+      if obj.respond_to?("#{x}=")
+        v = true  if v == 'true'   # yes or on ?
+        v = false if v == 'false'  # no or off ?
+        obj.send("#{x}=", v)
+      else
+        obj.option_missing(x, v) # argv?
+      end
+    end
+
+    #
+    # Parse double-dash command-line option.
+    #
+    def parse_long(obj, opt, argv, args)
+      x = opt.sub(/^\-+/, '') # remove '--'
+      if obj.respond_to?("#{x}=")
+        m = obj.method("#{x}=")
+        if obj.respond_to?("#{x}?")
+          m.call(true)
+        else
+          invoke(obj, m, argv)
+        end
+      elsif obj.respond_to?("#{x}!")
+        invoke(obj, "#{x}!", argv)
+      else
+        obj.option_missing(x, argv)
+      end
+    end
+
+    #
+    # Parse single-dash command-line option.
+    #
+    # TODO: This needs some thought concerning character spliting and arguments.
+    def parse_flags(obj, opt, argv, args)
+      x = opt[1..-1]
+      c = 0
+      x.split(//).each do |k|
+        if obj.respond_to?("#{k}=")
+          m = obj.method("#{k}=")
+          if obj.respond_to?("#{x}?")
+            m.call(true)
+          else
+            invoke(obj, m, argv) #m.call(argv.shift)
+          end
+        elsif obj.respond_to?("#{k}!")
+          invoke(obj, "#{k}!", argv)
+        else
+          long = find_longer_option(obj, k)
+          if long
+            if long.end_with?('=') && obj.respond_to?(long.chomp('=')+'?')
+              invoke(obj, long, [true])
+            else
+              invoke(obj, long, argv)
+            end
+          else
+            obj.option_missing(x, argv)
+          end
+        end
+      end
+    end
+
+    #
+    #
+    # TODO: Sort alphabetically?
+    def find_longer_option(obj, char)
+      meths = obj.methods.map{ |m| m.to_s }
+      meths = meths.select do |m|
+        m.start_with?(char) and (m.end_with?('=') or m.end_with?('!'))
+      end
+      meths.first
+    end
+
+    #
+    #
+    def invoke(obj, meth, argv)
+      m = Method === meth ? meth : obj.method(meth)
+      a = []
+      m.arity.abs.times{ a << argv.shift }
+      m.call(*a)
+    end
+
+    # Index of subcommands.
+    #
+    # @return [Hash] name mapped to subcommnd class
+    def subcommands
+      @subcommands ||= (
+        consts = @cli_class.constants - @cli_class.superclass.constants
+        consts.inject({}) do |h, c|
+          c = @cli_class.const_get(c)
+          if Class === c && CLI::Base > c
+            n = c.name.split('::').last.downcase
+            h[n] = c
+          end
+          h
+        end
+      )
+    end
+
+  end
+
+end

data/lib/cli/source.rb

@@ -0,0 +1,81 @@
+# Manage source lookup.
+module Source
+  extend self
+
+  # Read and cache file.
+  #
+  # @param file [String] filename, should be full path
+  #
+  # @return [Array] file content in array of lines
+  def read(file)
+    @read ||= {}
+    @read[file] ||= File.readlines(file)
+  end
+
+  # Get comment from file searching up from given line number.
+  #
+  # @param file [String] filename, should be full path
+  # @param line [Integer] line number in file
+  #
+  def get_above_comment(file, line)
+    get_above_comment_lines(file, line).join("\n").strip
+  end
+
+  # Get comment from file searching up from given line number.
+  #
+  # @param file [String] filename, should be full path
+  # @param line [Integer] line number in file
+  #
+  def get_above_comment_lines(file, line)
+    text  = read(file)
+    index = line - 1
+    while index >= 0 && text[index] !~ /^\s*\#/
+      return [] if text[index] =~ /^\s*end/
+      index -= 1
+    end
+    rindex = index
+    while text[index] =~ /^\s*\#/
+      index -= 1
+    end
+    result = text[index..rindex]
+    result = result.map{ |s| s.strip }
+    result = result.reject{ |s| s[0,1] != '#' }
+    result = result.map{ |s| s.sub(/^#/,'').strip }
+    #result = result.reject{ |s| s == "" }
+    result
+  end
+
+  # Get comment from file searching down from given line number.
+  #
+  # @param file [String] filename, should be full path
+  # @param line [Integer] line number in file
+  #
+  def get_following_comment(file, line)
+    get_following_comment_lines(file, line).join("\n").strip
+  end
+
+  # Get comment from file searching down from given line number.
+  #
+  # @param file [String] filename, should be full path
+  # @param line [Integer] line number in file
+  #
+  def get_following_comment_lines(file, line)
+    text  = read(file)
+    index = line || 0
+    while text[index] !~ /^\s*\#/
+      return nil if text[index] =~ /^\s*(class|module)/
+      index += 1
+    end
+    rindex = index
+    while text[rindex] =~ /^\s*\#/
+      rindex += 1
+    end
+    result = text[index..(rindex-2)]
+    result = result.map{ |s| s.strip }
+    result = result.reject{ |s| s[0,1] != '#' }
+    result = result.map{ |s| s.sub(/^#/,'').strip }
+    result.join("\n").strip
+  end
+
+end
+

data/lib/cli/utils.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module CLI
+
+  # Some handy-dandy CLI utility methods.
+  #
+  module Utils
+    extend self
+
+    # TODO: Maybe #ask chould serve all purposes depending on degfault?
+    # e.g. `ask?("ok?", default=>true)`, would be same as `yes?("ok?")`.
+
+    # Strings to interprest as boolean values.
+    BOOLEAN_MAP = {"y"=>true, "yes"=>true, "n"=>false, "no"=>false}
+
+    # Query the user for a yes/no answer, defaulting to yes.
+    def yes?(question, options={})
+      print "#{question} [Y/n] "
+      input  = STDIN.readline.chomp.downcase
+      BOOLEAN_MAP[input] || true
+    end
+
+    # Query the user for a yes/no answer, defaulting to no.
+    def no?(question, options={})
+      print "#{question} [y/N] "
+      input  = STDIN.readline.chomp.downcase
+      BOOLEAN_MAP[input] || false
+    end
+
+    # Query the user for an answer.
+    def ask(question, options={})
+      print "#{question} [default: #{options[:default]}] "
+      reply = STDIN.readline.chomp
+      if reply.empty?
+        options[:default]
+      else
+        reply
+      end
+    end
+
+  end
+
+end

data/lib/cli/version.rb

@@ -0,0 +1,5 @@
+module CLI
+  class Base
+    VERSION = '0.5.1'
+  end
+end

data/lib/cli_base.rb

@@ -0,0 +1,2 @@
+require 'cli/base'
+

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: cli_base
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+platform: ruby
+authors:
+- Thomas Sawyer
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+description: Think of CLI::Base as a COM, a Commandline Object Mapper, in much the
+  same way that ActiveRecord::Base is an ORM. A subclass of CLI::Base can define a
+  complete command line tool using nothing more than Ruby method definitions.
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- HISTORY.md
+- README.md
+- lib/cli/base.rb
+- lib/cli/config.rb
+- lib/cli/core_ext.rb
+- lib/cli/errors.rb
+- lib/cli/help.rb
+- lib/cli/parser.rb
+- lib/cli/source.rb
+- lib/cli/utils.rb
+- lib/cli/version.rb
+- lib/cli_base.rb
+homepage: https://github.com/rubyworks/cli_base
+licenses:
+- BSD-2-Clause
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Command line tools, meet your Executioner!
+test_files: []