bogo-cli 0.2.18 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9fab210ebb0f9a9f7d1a1877fa7abacf6cfb89398c23ee7602e086628523a85
-  data.tar.gz: 3d5913b9aa21d962c3868276031719a19582216195a71abdf6e3ba262c58d7f0
+  metadata.gz: c3d995cac00e17670f4b08c185c248f79a5bc4da9dfd99f5cd3ee38740c37045
+  data.tar.gz: c381604451c5b15fc8d2d521ed4dee69e52b73684895f8c94827d3f30db71ca1
 SHA512:
-  metadata.gz: b4e72a675b1ba15da4cc87236f3ead957da814c7246692d00a69ef55d26bfdb857d58cbafee830e8cf03ed11681bce016be238155bef9f0367b46f6c28f0bd63
-  data.tar.gz: 2c77c1be0fdbb2f6f4b5df7eb58c2ef423c50366a8bf7b2869ec4e5c2ac996468aa20de6c7020f73c2592068678323492ce0f8f1074d1e10b0d7a91287689cb2
+  metadata.gz: b27998591ca5eeef1eacb675d53232028328b11d28164eb93563c0fe37ec1464333d3ad002a13a8304e602b02e3d6eecf5a3e463ae0232f7744e780af5158293
+  data.tar.gz: 1c2faafec7efb8f6cc1f17f188b903ee2ebca11ba30ce040244e1c292cc0dc07474cf5a53d9b794cc078c4d6685a0d383282614c95b6dfdfcbc0713eed2f0350

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# v0.3.1
+* Add context for option parsing (#15)
+
+# v0.3.0
+* Remove dependency on slop library (#14)
+
 # v0.2.18
 * Include original error message when available
 

data/CONTRIBUTING.md

@@ -1,22 +1,18 @@
 # Contributing
 
-## Branches
+## Fixes
 
-### `master` branch
+Have a fix to some bug you want to submit? Well you're
+awesome. Please just include a description of the bug
+(or link to originating issue) and test coverage on the
+modifications.
 
-The master branch is the current stable released version.
+## New Features
 
-### `develop` branch
-
-The develop branch is the current edge of development.
-
-## Pull requests
-
-* https://github.com/spox/bogo-cli/pulls
-
-Please base all pull requests of the `develop` branch. Merges to
-`master` only occur through the `develop` branch. Pull requests
-based on `master` will likely be cherry picked.
+Have a new feature you want to add? Well you're awesome
+too! It may be a good idea to submit an issue first to
+describe the desired feature and get any feedback. Please
+be sure to include tests.
 
 ## Issues
 

data/LICENSE

@@ -1,4 +1,4 @@
-   Copyright 2014 Chris Roberts
+   Copyright 2022 Chris Roberts
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -10,4 +10,4 @@
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
-   limitations under the License.
+   limitations under the License.

data/bogo-cli.gemspec

@@ -1,5 +1,5 @@
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + "/lib/"
-require "bogo-cli/version"
+require "bogo-cli"
 Gem::Specification.new do |s|
   s.name = "bogo-cli"
   s.version = Bogo::Cli::VERSION.version
@@ -13,8 +13,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "bogo", ">= 0.2.14", "< 0.6"
   s.add_runtime_dependency "bogo-config", ">= 0.1.15", "< 0.5"
   s.add_runtime_dependency "bogo-ui"
-  s.add_runtime_dependency "slop", "~> 3"
-  s.add_development_dependency "rake", "~> 10"
+  s.add_development_dependency "rake"
   s.add_development_dependency "minitest"
   s.files = Dir["lib/**/*"] + %w(bogo-cli.gemspec README.md CHANGELOG.md CONTRIBUTING.md LICENSE)
 end

data/lib/bogo-cli/command.rb

@@ -1,6 +1,7 @@
+require "bogo"
 require "bogo-ui"
 require "bogo-config"
-require "bogo-cli"
+require "ostruct"
 
 module Bogo
   module Cli
@@ -30,21 +31,25 @@ module Bogo
       #
       # @return [self]
       def initialize(cli_opts, args)
-        if (cli_opts.is_a?(Slop))
+        @defaults = Smash.new
+        @options = Smash.new
+        case cli_opts
+        when Bogo::Cli::Parser::OptionValues
           process_cli_options(cli_opts)
+        when Bogo::Cli::Parser::Command
+          @options = cli_opts.parse(args).first
         else
-          @defaults = Smash.new
-          @options = cli_opts.to_hash.to_smash(:snake)
-          [@options, *@options.values].compact.each do |hsh|
-            next unless hsh.is_a?(Hash)
-            hsh.delete_if { |k, v| v.nil? }
-          end
+          @options = cli_opts.to_h.to_smash(:snake)
+        end
+        [@options, *@options.values].compact.each do |hsh|
+          next unless hsh.is_a?(Hash)
+          hsh.delete_if { |k, v| v.nil? }
         end
         @arguments = validate_arguments!(args)
         load_config!
         ui_args = Smash.new(
           :app_name => options.fetch(:app_name,
-                                     self.class.name.split("::").first),
+            self.class.name.split("::").first),
         ).merge(config)
         @ui = options.delete(:ui) || Ui.new(ui_args)
         Bogo::Cli::Command.ui(ui)
@@ -89,7 +94,7 @@ module Bogo
             ),
             Hash.new
           ).map { |k, v|
-            unless (v.nil?)
+            unless v.nil?
               [k, v]
             end
           }.compact
@@ -101,16 +106,16 @@ module Bogo
       #
       # @return [Hash]
       def load_config!
-        if (options[:config])
+        if options[:config]
           config_inst = Config.new(options[:config])
-        elsif (self.class.const_defined?(:DEFAULT_CONFIGURATION_FILES))
+        elsif self.class.const_defined?(:DEFAULT_CONFIGURATION_FILES)
           path = self.class.const_get(:DEFAULT_CONFIGURATION_FILES).detect do |check|
             full_check = File.expand_path(check)
             File.exists?(full_check)
           end
           config_inst = Config.new(path) if path
         end
-        if (config_inst)
+        if config_inst
           options.delete(:config)
           defaults_inst = Smash[
             config_class.new(
@@ -165,7 +170,7 @@ module Bogo
         begin
           result = yield
           ui.puts ui.color("complete!", :green, :bold)
-          if (result)
+          if result
             ui.puts "---> Results:"
             case result
             when Hash
@@ -190,18 +195,14 @@ module Bogo
       # @param cli_opts [Slop]
       # @return [NilClass]
       def process_cli_options(cli_opts)
-        unless (cli_opts.is_a?(Slop))
-          raise TypeError.new "Expecting type `Slop` but received type `#{cli_opts.class}`"
-        end
         @options = Smash.new
         @defaults = Smash.new
-        cli_opts.each do |cli_opt|
-          unless (cli_opt.value.nil?)
-            opt_key = Bogo::Utility.snake(cli_opt.key)
-            if (cli_opt.default?)
-              @defaults[opt_key] = cli_opt.value
+        cli_opts.each_pair do |key, value|
+          unless value.nil?
+            if cli_opts.default?(key)
+              @defaults[key] = value
             else
-              @options[opt_key] = cli_opt.value
+              @options[key] = value
             end
           end
         end
@@ -216,11 +217,11 @@ module Bogo
         chk_idx = list.find_index do |item|
           item.start_with?("-")
         end
-        if (chk_idx)
+        if chk_idx
           marker = list.find_index do |item|
             item == "--"
           end
-          if (marker.nil? || chk_idx.to_i < marker)
+          if marker.nil? || chk_idx.to_i < marker
             raise ArgumentError.new "Unknown CLI option provided `#{list[chk_idx]}`"
           end
         end

data/lib/bogo-cli/parser.rb

@@ -0,0 +1,384 @@
+require 'forwardable'
+require 'optparse'
+require 'ostruct'
+
+module Bogo
+  module Cli
+    # Parser for CLI arguments
+    class Parser
+      # @return [Symbol] represent unset value
+      UNSET = :__unset__
+
+      class OptionValues
+        extend Forwardable
+
+        NONFORWARDABLE = [:is_a?, :respond_to?, :object_id, :inspect, :keys, :to_s, :[]=].freeze
+
+        Smash.public_instance_methods.each do |ifunc|
+          next if ifunc.to_s.start_with?("_") || NONFORWARDABLE.include?(ifunc)
+          def_delegator :composite, ifunc
+        end
+
+        def initialize
+          @defaults = Smash.new
+          @sets = Smash.new
+        end
+
+        def []=(key, value)
+          assign(key, value)
+        end
+
+        def assign(key, value)
+          @sets[key] = value
+          self
+        end
+
+        def set_default(key, value)
+          @defaults[key] = value
+          self
+        end
+
+        def keys
+          @sets.keys | @defaults.keys
+        end
+
+        def default?(key)
+          unless keys.include?(key)
+            raise KeyError,
+                  "Unknown option key '#{key}'"
+          end
+          !@sets.keys.include?(key)
+        end
+
+        def to_s
+          "<OptionValues: #{composite.inspect}>"
+        end
+
+        def inspect
+          "<OptionValues: #{@sets.inspect} | #{@defaults.inspect}>"
+        end
+
+        def is_a?(const)
+          super || composite.is_a?(const)
+        end
+
+        def respond_to?(method)
+          super || composite.respond_to?(method)
+        end
+
+        def composite
+          Smash.new.tap do |c|
+            keys.each do |k|
+              c[k] = @sets.fetch(k, @defaults[k])
+            end
+          end
+        end
+      end
+
+      # Modified option parser to include
+      # subcommand information
+      class OptionParser < ::OptionParser
+        attr_accessor :subcommands
+
+        def help
+          v = super
+          return v if Array(subcommands).empty?
+          v += "\n" + "Available Commands:\n\n"
+          Array(subcommands).each do |sc|
+            v += summary_indent + sc.name.to_s + "\t" + sc.description.to_s + "\n"
+          end
+          v + "\n" + 'See `<command> --help` for more information on a specific command.'
+        end
+      end
+
+      class Command
+        # @return [Array<Command>] list of subcommands
+        attr_reader :commands
+        # @return [String] name of command
+        attr_reader :name
+        # @return [Array<Flag>] flags for command
+        attr_reader :flags
+        # @return [Proc] callable to be executed
+        attr_reader :callable
+        # @return [OpenStruct] flag option values
+        attr_reader :options
+        # @return [OptionParser] command parser
+        attr_reader :parser
+
+        # Create a new command
+        #
+        # @param name [String, Symbol] name of command
+        # @return [Command]
+        def initialize(name)
+          @name = name.to_sym
+          @commands = []
+          @flags = []
+          @callable = nil
+          @options = OptionValues.new
+        end
+
+        # Add a new flag
+        #
+        # @param short [String, Symbol] short flag
+        # @param long [String, Symbol] long flag
+        # @param description [String] description of flag
+        # @param default [String] default flag value
+        def on(short, long, description=UNSET, opts={}, &block)
+          if short.to_s.size > 1
+            if description == UNSET
+              description = long
+              long = short
+              short = nil
+            elsif description.is_a?(Hash)
+              opts = description
+              description = long
+              long = short
+              short = nil
+            end
+          end
+          Flag.new(
+            short_name: short,
+            long_name: long,
+            description: description,
+            default: opts[:default],
+            callable: block,
+          ).tap do |f|
+            @flags << f
+          end
+        end
+
+        # Add a new command
+        #
+        # @param name [String, Symbol] name of command
+        def command(name, &block)
+          Command.new(name).load(&block).tap do |c|
+            @commands << c
+          end
+        end
+
+        # @return [String] description of command
+        def description(v=UNSET)
+          @description = v unless v == UNSET
+          @description
+        end
+
+        # Register callable for command
+        def run(&block)
+          @callable = block
+        end
+
+        # Load a command configuration block
+        def load(&block)
+          instance_exec(&block)
+          self
+        end
+
+        # @return [String] help output
+        def help
+          parser.help
+        end
+
+        # Parse the arguments
+        #
+        # @param arguments [Array<String>] CLI arguments
+        # @return [OpenStruct, Array<String>]
+        def parse(arguments)
+          raise "Must call #generate before #parse" if
+            parser.nil?
+          flags.each do |f|
+            next if f.default.nil?
+            options.set_default(f.option_name, f.default)
+          end
+          init = OpenStruct.new
+          parser.parse!(arguments, into: init)
+          init.each_pair do |k, v|
+            options.assign(k, v)
+          end
+          [options, arguments]
+        end
+
+        # Generate command parsers
+        #
+        # @param parents [Array<String,Symbol>] ancestors of command
+        # @return [Hash<string,OptParser>]
+        def generate(parents=[], add_help: true)
+          Hash.new.tap { |cmds|
+            @parser = OptionParser.new
+            full_name = parents + [name]
+            parser.program_name = full_name.join(' ')
+            parser.banner = description unless
+              description == UNSET
+            if add_help
+              parser.on('-h', '--help', "Display help information") do
+                $stderr.puts parser.help
+                exit
+              end
+            end
+            flags.each { |f|
+              if !f.boolean? && f.long_name.end_with?('=')
+                short = "-#{f.short_name}" if f.short_name
+                long = "--#{f.long_name[0, f.long_name.size - 1]} VALUE"
+              else
+                short = "-#{f.short_name}" if f.short_name
+                long = "--#{f.long_name}"
+              end
+              parser.on(short, long, f.description, &f.callable)
+            }
+
+            commands.map { |c|
+              c.generate(full_name, add_help: add_help)
+            }.inject(cmds) { |memo, list|
+              memo.merge!(list)
+            }
+
+            parser.subcommands = commands
+
+            cmds[full_name.join(' ')] = self
+          }
+        end
+
+        def to_hash
+          options.to_h
+        end
+      end
+
+      class Flag
+        # @return [String] short flag
+        attr_reader :short_name
+        # @return [String] long flag
+        attr_reader :long_name
+        # @return [String] default value
+        attr_reader :default
+        # @return [String] flag description
+        attr_reader :description
+        # @return [Proc] block to execute on flag called
+        attr_reader :callable
+
+        # Create a new flag
+        #
+        # @param short_name [String, Symbol] Single character flag
+        # @param long_name [String, Symbol] Full flag name
+        # @param description [String] Description of flag
+        # @param default [Object] Default value for flag
+        # @return Flag
+        def initialize(long_name:,
+          short_name: nil,
+          description: nil,
+          default: nil,
+          callable: nil
+        )
+          if short_name
+            short_name = short_name.to_s
+            short_name = short_name[1, short_name.size] if
+              short_name.start_with?('-')
+            raise ArgumentError,
+              "Flag short name must be single character (flag: #{short_name})" if
+              short_name.size > 1
+          end
+          @short_name = short_name
+          @long_name = long_name.to_s.sub(/^-+/, '').gsub('_', '-')
+          @description = description
+          @default = default
+          @callable = callable
+        end
+
+        # @return [Symbol] option compatible name
+        def option_name
+          long_name.split('=').first.gsub('-', '_').to_sym
+        end
+
+        # @return [Boolean] flag is boolean value
+        def boolean?
+          !long_name.include?('=')
+        end
+      end
+
+      # @return [Boolean] generate help content
+      attr_accessor :generate_help
+
+      # Parse a command setup block, process arguments
+      # and execute command if match found
+      #
+      # @param help [Boolean] generate help content
+      # @return [Object] result
+      def self.parse(help: true, &block)
+        parser = self.new
+        parser.generate_help = !!help
+        parser.load(&block)
+        parser.execute
+      end
+
+      # Create a new parser
+      #
+      # @param name [String, Symbol] name of root command
+      # @return [Parser]
+      def initialize(name: nil)
+        name = self.class.root_name unless name
+        @root = Command.new(name)
+      end
+
+      # Add a new command
+      #
+      # @param name [String, Symbol] name of command
+      def command(name, &block)
+        @root.command(name, &block)
+      end
+
+      # Add a new flag
+      #
+      # @param short [String, Symbol] short flag
+      # @param long [String, Symbol] long flag
+      # @param description [String] description of flag
+      # @param default [String] default flag value
+      def on(short, long, description, **options, &block)
+        @root.on(short, long, description, options, &block)
+      end
+
+      # Register callable for command
+      def run(&block)
+        @root.run(&block)
+      end
+
+      # Load a command configuration block
+      def load(&block)
+        @root.load(&block)
+      end
+
+      # Generate all parsers
+      #
+      # @return [Hash<String,Hash<Parser,Command>>]
+      def generate
+        @root.generate(add_help: generate_help)
+      end
+
+      # Execute command based on CLI arguments
+      def execute
+        cmds = @root.generate
+        base_args = arguments
+        line = base_args.join(' ')
+        cmd_key = cmds.keys.find_all { |k|
+          line.start_with?(k)
+        }.sort_by(&:size).last
+        if cmd_key.nil?
+          return cmds[@root.name].parser
+        end
+        base_args = base_args.slice(cmd_key.split(' ').size, base_args.size)
+        a = cmds[cmd_key].parse(base_args)
+        return cmds[cmd_key] unless cmds[cmd_key].callable
+        cmds[cmd_key].callable.call(*a)
+        exit 0
+      end
+
+      private
+
+      # @return [Array<String>]
+      def arguments
+        [self.class.root_name] + ARGV
+      end
+
+      def self.root_name
+        File.basename($0)
+      end
+    end
+  end
+end

data/lib/bogo-cli/setup.rb

@@ -1,7 +1,7 @@
 # Trigger shutdown on INT or TERM signals
 o_int = Signal.trap("INT") {
   o_int.call if o_int.respond_to?(:call)
-  if (Bogo::Cli.exit_on_signal == false)
+  if Bogo::Cli.exit_on_signal == false
     Thread.main.raise SignalException.new("SIGINT")
   else
     exit 0
@@ -9,49 +9,30 @@ o_int = Signal.trap("INT") {
 }
 
 o_term = Signal.trap("TERM") {
-  o_int.call if o_int.respond_to?(:call)
-  if (Bogo::Cli.exit_on_signal == false)
+  o_term.call if o_term.respond_to?(:call)
+  if Bogo::Cli.exit_on_signal == false
     Thread.main.raise SignalException.new("SIGTERM")
   else
     exit 0
   end
 }
 
-require "bogo-cli"
-
-class Slop
-  def bogo_cli_run(*args, &block)
-    slop_run(*args, &block)
-    old_runner = @runner
-    @runner = proc { |*args| old_runner.call(*args); exit 0 }
-  end
-
-  alias_method :slop_run, :run
-  alias_method :run, :bogo_cli_run
-
-  class Option
-    def default?
-      @value.nil?
-    end
-  end
-end
-
 module Bogo
   module Cli
     class Setup
       class << self
 
-        # Wrap slop setup for consistent usage
+        # Wrap parsing setup for consistent usage
         #
-        # @yield Slop setup block
+        # @yield CLI setup block
         # @return [TrueClass]
         def define(&block)
           begin
-            slop_result = Slop.parse(:help => true) do
+            result = Parser.parse(help: true) do
               instance_exec(&block)
             end
-            puts slop_result.help
-            exit -1
+            puts result.help
+            exit 255
           rescue StandardError, ScriptError => err
             err_msg = err.message
             if err.respond_to?(:original) && err.original

data/lib/bogo-cli/version.rb

@@ -1,6 +1,6 @@
 module Bogo
   module Cli
     # Current library version
-    VERSION = Gem::Version.new("0.2.18")
+    VERSION = Gem::Version.new("0.3.1")
   end
 end

data/lib/bogo-cli.rb

@@ -1,17 +1,12 @@
-require 'bogo'
-require 'slop'
-require 'bogo-config'
-
 module Bogo
   module Cli
     autoload :Command, 'bogo-cli/command'
+    autoload :Parser, 'bogo-cli/parser'
     autoload :Setup, 'bogo-cli/setup'
+    autoload :VERSION, 'bogo-cli/version'
 
     class << self
       attr_accessor :exit_on_signal
     end
-
   end
 end
-
-require 'bogo-cli/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bogo-cli
 version: !ruby/object:Gem::Version
-  version: 0.2.18
+  version: 0.3.1
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-08 00:00:00.000000000 Z
+date: 2022-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bogo
@@ -64,34 +64,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: slop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -119,6 +105,7 @@ files:
 - bogo-cli.gemspec
 - lib/bogo-cli.rb
 - lib/bogo-cli/command.rb
+- lib/bogo-cli/parser.rb
 - lib/bogo-cli/setup.rb
 - lib/bogo-cli/version.rb
 homepage: https://github.com/spox/bogo-cli
@@ -140,8 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.4.0.dev
 signing_key: 
 specification_version: 4
 summary: CLI Helper libraries