simple-cli 0.3.0 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fdfd698a5315891e4d5dd96e5d3ce07fc075d17d5ced10eb06a9cb5733b4a8a
-  data.tar.gz: 9000f43f3dfceb572aae61b8907216c3dd7c9c4c468374587f56d5c433d84ecd
+  metadata.gz: 43c838ad9921bef80717cd3a61c33d68e794adb84799b7e764cc8f23e8fc30db
+  data.tar.gz: a3266ec697b770e68add5bbe8511db6253aa9453e4bde36cf86cddecc5577bff
 SHA512:
-  metadata.gz: 82f219944dc7ffecac5cae4975749732a6741ee676f5ffd8b4ca862c48717d20a56dfc363dbf7c486e5cb9d48ba376eecb67a7185557547da7824bd201fd524f
-  data.tar.gz: ee581a7eb68e35c9cc8a2560538f709a1c9ce8a90457338c14ef9446875563f6e9f9f4012844c5ada1f96486ef0945e9917cdda0434972b078c9dc22c5f2c9d1
+  metadata.gz: 198ffc917415a4221f1b2de93ff32f42e55dfb480b0bd8f51b2d191277ac3206c801d0cc14ada5bc6c18e2aad38447ddf93a1b303f0254e9f28e2821907f654b
+  data.tar.gz: cc2f55d0a681d4376eeff4b76f27f40199e3248b53736fe8f1061307328764477e212cff2e429a01c1dc28b7f214e0eb19f8839acc30e5e65d0d8196115c4c2d

data/.rubocop.yml

@@ -22,6 +22,9 @@ Style/StringLiterals:
   EnforcedStyle: double_quotes
   ConsistentQuotesInMultiline: false
 
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
 Style/ClassAndModuleChildren:
   Enabled: false
 

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in {gemname}.gemspec
 gemspec
+
+# gem "simple-service", path: "../simple-service"

data/VERSION

@@ -0,0 +1 @@
+0.3.3

data/lib/simple/cli.rb

@@ -1,29 +1,115 @@
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/CyclomaticComplexity
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/PerceivedComplexity
+
 module Simple; end
 module Simple::CLI; end
 
-require_relative "cli/pp"
-
-require_relative "cli/helpers"
+require_relative "cli/default_options"
 require_relative "cli/runner"
+require_relative "cli/helper"
 require_relative "cli/adapter"
 require_relative "cli/logger"
+require_relative "cli/on_exception"
+require_relative "cli/helpers"
+
+require "simple/service"
 
 module Simple::CLI
   extend ::Simple::CLI::Logger
 
+  # It is not strictly necessary to include this module into another module
+  # (the "target module") to be able to run the target module via the command
+  # line. It is sufficient to just include ::Simple::Service, which turns
+  # the target into a service module, and then
+  #
+  # However, just including Simple::CLI gives you access to the Simple::CLI::Helpers
+  # module as well.
   def self.included(base)
-    base.extend(::Simple::CLI::Adapter)
+    base.include(::Simple::Service)
     base.include(::Simple::CLI::Helpers)
   end
 
-  # Simple::CLI.run! is called from Runner.run. It is called with a method
-  # name, which is derived from the command passed in via the command line,
-  # and parsed arguments.
+  # Runs the service with the current command line arguments.
   #
-  # The default implementation just calls the respective method on self.
-  # Implementations might override this method to provide some before/after
-  # functionality.
-  def run!(command, *args)
-    send(command, *args)
+  # The +service+ argument must match a simple-service service module. The CLI
+  # application's subcommands and their arguments are derived from the actions
+  # provided by the service module.
+  def self.run!(service, args: nil)
+    ::Simple::Service.verify_service!(service)
+
+    # prepare arguments: we always duplicate the args array, to make guarantee
+    # we don't interfere with the caller's view of the world.
+    args ||= ARGV
+    args = args.dup
+
+    logger.level = ::Logger::DEBUG
+
+    # Extract default options. This returns the command to run, the verbosity
+    # setting, and the help flag.
+    options = DefaultOptions.new(args)
+
+    # Set logger verbosity. This happens before anything else - this way
+    # any further step which raises an exception will have the correct log
+    # level applied during exception handling.
+    logger.level = options.log_level
+
+    # Validate the command. If this command is invalid this will print a short
+    # help message.
+    if options.command
+      unless H.action_for_command(service, options.command)
+        logger.error "Invalid command '#{options.command}'."
+        Helper.short_help!(service)
+      end
+    end
+
+    # Run help if requested.
+    if options.help?
+      if options.command
+        Helper.help_on_command! service, options.command, verbose: options.verbose?
+      else
+        Helper.help! service, verbose: options.verbose?
+      end
+    end
+
+    # Run help if command is missing..
+    unless options.command
+      Helper.short_help! service
+    end
+
+    # Run service.
+    Runner.run! service, options.command, *args, verbose: options.verbose?
+  rescue ::Simple::Service::ArgumentError
+    Helper.help_on_command! service, command, verbose: false
+  rescue StandardError => e
+    on_exception(e)
+    exit 3
+  end
+
+  module H
+    def self.action_for_command(service, command)
+      actions = ::Simple::Service.actions(service)
+
+      action_name = H.command_to_action(command)
+      return nil unless actions.key?(action_name)
+      actions[action_name]
+    end
+
+    def self.action_to_command(action_name)
+      raise "action_name must by a Symbol" unless action_name.is_a?(Symbol)
+
+      action_name.to_s.tr("_", ":")
+    end
+
+    def self.command_to_action(command)
+      raise "command must by a String" unless command.is_a?(String)
+
+      command.tr(":", "_").to_sym
+    end
+
+    def self.binary_name
+      $0.gsub(/.*\//, "")
+    end
   end
 end

data/lib/simple/cli/adapter.rb

@@ -1,17 +1,25 @@
+# rubocop:disable Metrics/CyclomaticComplexity
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/PerceivedComplexity
+
 module Simple::CLI::Adapter
   # Run a Simple::CLI application
   #
   # This is usually called with as either
   #
   # - Application::CLI.run!: runs the Application's CLI with subcommand support.
-  # 
+  #
   # or
   #
   # - Application::CLI.run!("main"): runs the Application's CLI without subcommand support.
   #
-  def run!(main_command = nil)
+  def run!(*argv)
+    if argv.length == 1 && argv != ARGV
+      main_command = *argv
+    end
+
     runner = Simple::CLI::Runner.new(self)
-    
+
     if main_command && (ARGV.include?("--help") || ARGV.include?("-h"))
       runner.help(main_command)
     elsif main_command

data/lib/simple/cli/default_options.rb

@@ -0,0 +1,73 @@
+require "logger"
+
+module Simple::CLI
+  # A DefaultOptions object holds values for default options.
+  class DefaultOptions
+    # extract default CLI options and the  "help" command. Returns a DefaultOptions object
+    def extract!(args:)
+      new args
+    end
+
+    # verbosity (one of ::Logger::WARN, ::Logger::INFO, ::Logger::DEBUG)
+    attr_reader :log_level
+
+    # returns true if we run in verbose mode.
+    def verbose?
+      log_level == ::Logger::DEBUG
+    end
+
+    # command
+    attr_reader :command
+
+    # The help flag. Is set when
+    #
+    # - running the "help" command
+    # - when a "-h" or "--help" CLI flag was given.
+    def help?
+      @help
+    end
+
+    private
+
+    LOG_LEVEL_FLAGS = {
+      "--verbose" => ::Logger::DEBUG,
+      "-v" => ::Logger::DEBUG,
+      "--quiet" => ::Logger::WARN,
+      "-q" => ::Logger::WARN,
+      default: ::Logger::INFO
+    }
+
+    HELP_FLAGS = {
+      "--help" => true,
+      "-h" => true,
+      default: false
+    }
+
+    def initialize(args)
+      @args = args
+
+      @log_level = extract_w_lookup!(LOG_LEVEL_FLAGS)  # get -v/--verbose and -q7--quiet flags
+      @command   = extract_command!                    # extract the command
+      if @command == "help"
+        @help = true
+        @command = extract_command!
+      else
+        @help = extract_w_lookup!(HELP_FLAGS)          # extract --help flag
+      end
+    end
+
+    def extract_w_lookup!(hsh)
+      value = hsh[:default]
+      @args.reject! do |str|
+        next unless hsh.key?(str)
+        value = hsh[str]
+      end
+      value
+    end
+
+    def extract_command!
+      return nil if /^-/ =~ @args.first
+      @args.shift
+    end
+  end
+end

data/lib/simple/cli/helper.rb

@@ -0,0 +1,9 @@
+require_relative "helper/help_on_command"
+require_relative "helper/help"
+require_relative "helper/short_help"
+
+module Simple::CLI
+  module Helper
+    extend self
+  end
+end

data/lib/simple/cli/helper/help.rb

@@ -0,0 +1,60 @@
+module Simple::CLI
+  module Helper
+    def help!(service, verbose:)
+      STDERR.puts <<~MSG
+        #{H.binary_name} <command> [ options... ]
+
+        Commands:
+
+        #{format_usages usages(service, verbose: verbose), prefix: "    "}
+
+        Default options and commands include:
+
+        #{format_usages default_usages(service, verbose: verbose), prefix: "    "}
+
+      MSG
+
+      exit 2
+    end
+
+    private
+
+    def usages(service, verbose:)
+      actions = ::Simple::Service.actions(service).values
+      actions = actions.select(&:short_description) unless verbose
+      actions = actions.sort_by(&:name)
+
+      actions.map do |action|
+        [ action_usage(action), action.short_description ]
+      end
+    end
+
+    def default_usages(service, verbose:)
+      _ = service
+      _ = verbose
+
+      [
+        [ "#{H.binary_name} help [ <command> ]", "print help for all or a specific command" ],
+        [ "#{H.binary_name} help -v", "show help for internal commands as well"],
+        [ "#{H.binary_name} [ --verbose | -v ]", "run on DEBUG log level"],
+        [ "#{H.binary_name} [ --quiet | -q ]", "run on WARN log level"],
+      ]
+    end
+
+    def format_usages(ary, prefix:)
+      # each entry is an Array of one or two entries. The first entry is a command usage
+      # string, the second entry is the command's short_description.
+      max_cmd_length = ary.inject(45) do |max, (cmd, _description)|
+        cmd.length > max ? cmd.length : max
+      end
+
+      ary.map do |cmd, description|
+        if description
+          format("#{prefix}%-#{max_cmd_length}s    # %s", cmd, description)
+        else
+          format("#{prefix}%-#{max_cmd_length}s", cmd)
+        end
+      end.join("\n")
+    end
+  end
+end

data/lib/simple/cli/helper/help_on_command.rb

@@ -0,0 +1,55 @@
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/CyclomaticComplexity
+# rubocop:disable Metrics/MethodLength
+
+module Simple::CLI
+  module Helper
+    def help_on_command!(service, command, verbose:)
+      action = H.action_for_command(service, command)
+
+      parts = [
+        action.short_description,
+        action_usage(action),
+        action.full_description,
+      ].compact
+
+      STDERR.puts <<~MSG
+        #{parts.join("\n\n")}
+
+      MSG
+
+      exit 2
+    end
+
+    private
+
+    # Used in command_help.rb and in help.rb
+    def action_usage(action)
+      args = action.parameters.reject(&:keyword?).map do |param|
+        case param.kind
+        when :req   then "<#{param.name}>"
+        when :opt   then "[ <#{param.name}> ]"
+        when :rest  then "[ <#{param.name}> .. ]"
+        end
+      end.compact
+
+      options = action.parameters.select(&:keyword?).map do |param|
+        if param.required?
+          "--#{name}=<#{name}>"
+        else
+          case param.default_value
+          when false  then  "[ --#{param.name} ]"
+          when true   then  "[ --no-#{param.name} ]"
+          when nil    then  "[ --#{param.name}=<#{param.name}> ]"
+          else              "[ --#{param.name}=#{param.default_value} ]"
+          end
+        end
+      end
+
+      help = "#{H.binary_name} #{H.action_to_command(action.name)}"
+      help << " #{options.join(" ")}" unless options.empty?
+      help << " #{args.join(" ")}" unless args.empty?
+      help
+    end
+  end
+end

data/lib/simple/cli/helper/short_help.rb

@@ -0,0 +1,27 @@
+module Simple::CLI
+  module Helper
+    def short_help!(service)
+      # We check if we have only a few number of actions. In that case we just show the full help instead.
+      actions = ::Simple::Service.actions(service).values
+      actions, hidden_actions = actions.partition(&:short_description)
+
+      STDERR.puts <<~MSG
+        #{H.binary_name} <command> [ options... ]
+
+      MSG
+
+      subcommands = actions.map { |action| "'" + H.action_to_command(action.name)  + "'" }
+      msg = "Subcommands include #{subcommands.sort.join(", ")}"
+      msg += " (and an additional #{hidden_actions.count} internal commands)"
+
+      STDERR.puts <<~MSG
+        #{msg}. Default options and commands include:
+
+        #{format_usages default_usages(service, verbose: false), prefix: "    "}
+
+        MSG
+
+      exit 2
+    end
+  end
+end

data/lib/simple/cli/helpers.rb

@@ -1,7 +1,6 @@
 require "open3"
 
-# Helpers are mixed into all CLI modules. They implement the following methods,
-# mostly to help with integrating external commands:
+# This module defines various helpers that might be useful for many CLI applications.
 #
 # - sys
 # - sys!
@@ -9,6 +8,9 @@ require "open3"
 # - die!
 #
 module Simple::CLI::Helpers
+  # The methods here must be private, lest they not show up as subcommands.
+  private
+
   def die!(msg)
     STDERR.puts msg
     exit 1

data/lib/simple/cli/logger.rb

@@ -12,7 +12,9 @@ module Simple::CLI::Logger
   end
 
   def logger=(logger)
+    old_log_level = logger.level
     @logger = Adapter.new(logger)
+    @logger.level = old_log_level
   end
 
   private

data/lib/simple/cli/logger/colored_logger.rb

@@ -1,5 +1,6 @@
-# rubocop:disable Metrics/AbcSize
 # rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/ModuleLength
+# rubocop:disable Metrics/AbcSize
 # rubocop:disable Metrics/CyclomaticComplexity
 # rubocop:disable Metrics/PerceivedComplexity
 

data/lib/simple/cli/on_exception.rb

@@ -0,0 +1,23 @@
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/MethodLength
+
+module Simple::CLI
+  def self.on_exception(e)
+    msg = e.message
+    msg += " (#{e.class.name})" unless $!.class.name == "RuntimeError"
+
+    logger.error msg
+
+    raise(e) if Simple::CLI.logger.level == ::Logger::DEBUG
+
+    logger.info do
+      backtrace = e.backtrace.reject { |l| l =~ /simple-cli/ }
+      "called from\n    " + backtrace[0, 10].join("\n    ")
+    end
+
+    verbosity_hint = "(Backtraces are currently silenced. Run with --verbose to see backtraces.)"
+    logger.warn verbosity_hint
+
+    exit 2
+  end
+end

data/lib/simple/cli/runner.rb

@@ -1,213 +1,41 @@
-# rubocop:disable  Metrics/AbcSize
-# rubocop:disable  Metrics/ClassLength
-# rubocop:disable  Metrics/CyclomaticComplexity
-# rubocop:disable  Metrics/MethodLength
-# rubocop:disable  Metrics/PerceivedComplexity
+module Simple::CLI
+  module Runner
+    extend self
 
-class Simple::CLI::Runner
-end
-
-require_relative "runner/command_help"
+    def run!(service, command, *args, verbose:)
+      _ = verbose
 
-# A Runner object manages running a CLI application module with a set
-# of string arguments (usually taken from ARGV)
-class Simple::CLI::Runner
-  def self.run(app, *args)
-    new(app).run(*args)
-  end
-
-  def initialize(app)
-    @app = app
-  end
-
-  def extract_default_flags!(args)
-    args.reject! do |arg|
-      case arg
-      when "--verbose", "-v" then logger.level = Logger::DEBUG
-      when "--quiet", "-q"   then logger.level = Logger::WARN
+      action_name = H.command_to_action(command)
+      Simple::Service.with_context do
+        flags = extract_flags!(args)
+        ::Simple::Service.invoke(service, action_name, *args, **flags)
       end
     end
-  end
 
-  attr_accessor :subcommand
+    private
 
-  def help(command)
-    if command
-      run "help", command
-    else
-      run "help"
-    end
-  end
+    # extract options from the array. Note: simple-cli is the correct place
+    # for this, and not simple-service, because it deals with a conversion
+    # which is strictly related to command line applications, and simple-service
+    # doesn't have any knowledge of CLI applications.
+    #
+    # This returns a hash of flag values, as determined by a "--flagname[=<value>]"
+    # command line options, and removes all such options from the arg array.
+    def extract_flags!(args)
+      flags = {}
 
-  def run(*args)
-    extract_default_flags!(args)
+      args.reject! do |arg|
+        next false unless arg =~ /^--(no-)?([^=]+)(=(.+))?/
 
-    @instance = Object.new.extend(@app)
-    command_name = args.shift || help!
-    command = string_to_command(command_name)
-
-    if command == :help
-      do_help!(*args)
-    elsif commands.include?(command)
-      self.subcommand = command
-      @instance.run! command, *args_with_options(args)
-    else
-      help!
-    end
-  rescue StandardError => e
-    on_exception(e)
-  end
-
-  def has_subcommands?
-    commands.length > 1
-  end
-
-  def do_help!(subcommand = nil)
-    if !subcommand
-      help!
-    else
-      help_subcommand!(subcommand)
-    end
-  end
+        flag_name = $2.tr("-", "_")
+        flag_name = "no_#{flag_name}" if $4 && $1
+        value = $4 || ($1 ? false : true)
 
-  def help_subcommand!(subcommand)
-    edoc = CommandHelp.new(@app, string_to_command(subcommand))
-
-    puts <<~MSG
-      #{help_for_command(subcommand)}
-
-      #{edoc.full}
-    MSG
-
-    unless has_subcommands?
-
-      STDERR.puts <<~MSG
-
-        Default options include:
-
-        #{binary_name} [ --help | -h ]                  ... print this help
-        #{binary_name} [ --verbose | -v ]               ... run on DEBUG log level
-        #{binary_name} [ --quiet | -q ]                 ... run on WARN log level
-      MSG
-    end
-    exit 1
-  end
-
-  def logger
-    Simple::CLI.logger
-  end
-
-  def on_exception(e)
-    raise(e) if Simple::CLI.logger.level == Logger::DEBUG
-
-    verbosity_hint = "Backtraces are currently silenced. Run with --verbose to see backtraces."
-
-    case e
-    when ArgumentError
-      logger.error e.message
-      logger.warn verbosity_hint
-      if subcommand
-        help_subcommand! subcommand
-      else
-        help!
+        flags[flag_name.to_sym] = value
+        true
       end
-    else
-      msg = e.message
-      msg += " (#{e.class.name})" unless $!.class.name == "RuntimeError"
-      logger.error msg
-      logger.warn verbosity_hint
-      exit 2
-    end
-  end
 
-  def args_with_options(args)
-    r = []
-    options = {}
-    while (arg = args.shift)
-      case arg
-      when /^--(.*)=(.*)/ then options[$1.to_sym] = $2
-      when /^--no-(.*)/   then options[$1.to_sym] = false
-      when /^--(.*)/      then options[$1.to_sym] = true
-      else r << arg
-      end
+      flags
     end
-
-    r << options unless options.empty?
-    r
-  end
-
-  def command_to_string(sym)
-    sym.to_s.tr("_", ":")
-  end
-
-  def string_to_command(s)
-    s.to_s.tr(":", "_").to_sym
-  end
-
-  def commands
-    @app.public_instance_methods(false).grep(/^[_a-zA-Z0-9]+$/)
-  end
-
-  def help_for_command(sym)
-    cmd = string_to_command(sym)
-    CommandHelp.new(@app, cmd).interface(binary_name, cmd, include_subcommand: has_subcommands?)
-  end
-
-  def binary_name
-    $0.gsub(/.*\//, "")
-  end
-
-  def help!
-    # collect help information on individual comments; when not on DEBUG
-    # level skipping the commands that don't jave a command help.
-    command_helps = commands.inject({}) do |hsh, sym|
-      edoc = CommandHelp.new(@app, sym)
-      next hsh if !edoc.head && logger.level != ::Logger::DEBUG
-
-      hsh.update sym => help_for_command(sym)
-    end
-
-    # build a lambda which prints a help line with nice formatting
-    max_length = command_helps.values.map(&:length).max
-    print_help_line = lambda do |cmd, description|
-      if description
-        STDERR.puts format("    %-#{max_length}s    # %s", cmd, description)
-      else
-        STDERR.puts format("    %-#{max_length}s", cmd)
-      end
-    end
-
-    # print help for commands
-    STDERR.puts "Usage:\n\n"
-
-    command_helps.keys.sort.each do |sym|
-      command_help = command_helps[sym]
-      edoc = CommandHelp.new(@app, sym)
-      print_help_line.call command_help, edoc.head
-    end
-
-    # print help for default commands
-
-    STDERR.puts <<~DOC
-
-      Default options include:
-
-    DOC
-
-    print_help_line.call "#{binary_name} [ --verbose | -v ]", "run on DEBUG log level"
-    print_help_line.call "#{binary_name} [ --quiet | -q ]", "run on WARN log level"
-
-    STDERR.puts <<~DOC
-
-      Other commands:
-
-    DOC
-
-    print_help_line.call "#{binary_name} help [ subcommand ]", "print help on a specific subcommand"
-    print_help_line.call "#{binary_name} help -v", "show help for internal commands as well"
-
-    STDERR.puts "\n"
-
-    exit 1
   end
 end

data/simple-cli.gemspec

@@ -5,11 +5,10 @@
 
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'simple/cli/version'
 
 Gem::Specification.new do |gem|
   gem.name     = "simple-cli"
-  gem.version  = Simple::CLI::VERSION
+  gem.version  = File.read("VERSION")
 
   gem.authors  = [ "radiospiel", "mediapeers GmbH" ]
   gem.email    = "eno@radiospiel.org"
@@ -28,6 +27,7 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '~> 2.3'
 
   # optional gems (required by some of the parts)
+  gem.add_dependency "simple-service", "~> 0.1.2"
 
   # development gems
   gem.add_development_dependency 'rake', '~> 12'

data/spec/spec_helper.rb

@@ -16,6 +16,5 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run focus: (ENV["CI"] != "true")
   config.expect_with(:rspec) { |c| c.syntax = :expect }
-  config.include FactoryGirl::Syntax::Methods
   config.order = "random"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-cli
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.3
 platform: ruby
 authors:
 - radiospiel
@@ -9,8 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-16 00:00:00.000000000 Z
+date: 2019-11-29 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: simple-service
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -77,18 +91,22 @@ files:
 - ".rubocop.yml"
 - Gemfile
 - Rakefile
+- VERSION
 - bin/rake
 - lib/simple-cli.rb
 - lib/simple/cli.rb
 - lib/simple/cli/adapter.rb
+- lib/simple/cli/default_options.rb
+- lib/simple/cli/helper.rb
+- lib/simple/cli/helper/help.rb
+- lib/simple/cli/helper/help_on_command.rb
+- lib/simple/cli/helper/short_help.rb
 - lib/simple/cli/helpers.rb
 - lib/simple/cli/logger.rb
 - lib/simple/cli/logger/adapter.rb
 - lib/simple/cli/logger/colored_logger.rb
-- lib/simple/cli/pp.rb
+- lib/simple/cli/on_exception.rb
 - lib/simple/cli/runner.rb
-- lib/simple/cli/runner/command_help.rb
-- lib/simple/cli/runner/module_ex.rb
 - lib/simple/cli/version.rb
 - log/.gitkeep
 - simple-cli.gemspec

data/lib/simple/cli/pp.rb

@@ -1,12 +0,0 @@
-# rubocop:disable Lint/HandleExceptions
-
-require "pp"
-
-begin
-  require "awesome_print"
-
-  def pp(*args)
-    ap(*args)
-  end
-rescue LoadError
-end

data/lib/simple/cli/runner/command_help.rb

@@ -1,120 +0,0 @@
-# rubocop:disable Metrics/AbcSize
-# rubocop:disable Metrics/CyclomaticComplexity
-# rubocop:disable Metrics/MethodLength
-
-require_relative "./module_ex"
-
-class Simple::CLI::Runner::CommandHelp
-  def self.option_names(app, subcommand)
-    new(app, subcommand).option_names
-  rescue NameError
-    []
-  end
-
-  def initialize(mod, method_id)
-    raise(ArgumentError, "#{method_id.inspect} should be a Symbol") unless method_id.is_a?(Symbol)
-
-    @method_id            = method_id
-    @method               = mod.instance_method(@method_id)
-    @method_parameters_ex = mod.method_parameters_ex(@method_id)
-  end
-
-  # First line of the help as read from the method comments.
-  def head
-    comments.first
-  end
-
-  # Full help as read from the method comments
-  def full
-    comments.join("\n") if comments.first
-  end
-
-  def option_names
-    option_names = @method_parameters_ex.map do |mode, name, _|
-      case mode
-      when :key     then name
-      when :keyreq  then name
-      end
-    end.compact
-
-    option_names.map do |name|
-      ["--#{name}", "--#{name}="]
-    end.flatten
-  end
-
-  # A help string constructed from the commands method signature.
-  def interface(binary_name, command_name, include_subcommand: false)
-    args = @method_parameters_ex.map do |mode, name|
-      case mode
-      when :req   then "<#{name}>"
-      when :opt   then "[ <#{name}> ]"
-      when :rest  then "[ <#{name}> .. ]"
-      end
-    end.compact
-
-    options = @method_parameters_ex.map do |mode, name, default_value|
-      case mode
-      when :key     then
-        case default_value
-        when false  then  "[ --#{name} ]"
-        when true   then  "[ --no-#{name} ]"
-        when nil    then  "[ --#{name}=<#{name}> ]"
-        else              "[ --#{name}=#{default_value} ]"
-        end
-      when :keyreq  then
-        "--#{name}=<#{name}>"
-      end
-    end.compact
-
-    help = "#{binary_name}"
-    help << " #{command_to_string(command_name)}" if include_subcommand
-    help << " #{options.join(' ')}" unless options.empty?
-    help << " #{args.join(' ')}" unless args.empty?
-    help
-  end
-
-  private
-
-  def command_to_string(s)
-    s.to_s.tr("_", ":")
-  end
-
-  def comments
-    @comments ||= begin
-      file, line = @method.source_location
-      extract_comments(from: parsed_source(file), before_line: line)
-    end
-  end
-
-  # reads the source \a file and turns each non-comment into :code and each comment
-  # into a string without the leading comment markup.
-  def parsed_source(file)
-    File.readlines(file).map do |line|
-      case line
-      when /^\s*# ?(.*)$/ then $1
-      when /^\s*end/ then :end
-      end
-    end
-  end
-
-  def extract_comments(from:, before_line:)
-    parsed_source = from
-
-    # go down from before_line until we see a line which is either a comment
-    # or an :end. Note that the line at before_line-1 should be the first
-    # line of the method definition in question.
-    last_line = before_line - 1
-    last_line -= 1 while last_line >= 0 && !parsed_source[last_line]
-
-    first_line = last_line
-    first_line -= 1 while first_line >= 0 && parsed_source[first_line]
-    first_line += 1
-
-    comments = parsed_source[first_line..last_line]
-    if comments.include?(:end)
-      []
-    else
-      parsed_source[first_line..last_line]
-    end
-  end
-end

data/lib/simple/cli/runner/module_ex.rb

@@ -1,69 +0,0 @@
-# rubocop:disable Metrics/MethodLength
-# rubocop:disable Metrics/AbcSize
-
-class Module
-  #
-  # returns an array with entries like the following:
-  #
-  #  [ :key, name, default_value ]
-  #  [ :keyreq, name [, nil ] ]
-  #  [ :req, name [, nil ] ]
-  #  [ :opt, name [, nil ] ]
-  #  [ :rest, name [, nil ] ]
-  #
-  def method_parameters_ex(method_id)
-    method = instance_method(method_id)
-    parameters = method.parameters
-
-    # method parameters with a :key mode are optional keyword arguments. We only
-    # support defaults for those - if there are none we abort here already.
-    keys = parameters.map { |mode, name| name if mode == :key }.compact
-    return parameters if keys.empty?
-
-    # We are now doing a fake call to the method, with a minimal viable set of
-    # arguments, to let the ruby runtime fill in default values for arguments.
-    # We do not, however, let the call complete. Instead we use a TracePoint to
-    # abort as soon as the method is called, and use the its binding to determine
-    # the default values.
-
-    fake_recipient = Object.new.extend(self)
-    fake_call_args = minimal_arguments(method)
-
-    trace_point = TracePoint.trace(:call) do |tp|
-      throw :received_fake_call, tp.binding if tp.defined_class == self && tp.method_id == method_id
-    end
-
-    bnd = catch(:received_fake_call) do
-      fake_recipient.send(method_id, *fake_call_args)
-    end
-
-    trace_point.disable
-
-    # extract default values from the received binding, and merge with the
-    # parameters array.
-    default_values = keys.each_with_object({}) do |key_parameter, hsh|
-      hsh[key_parameter] = bnd.local_variable_get(key_parameter)
-    end
-
-    parameters.map do |mode, name|
-      [mode, name, default_values[name]]
-    end
-  end
-
-  private
-
-  # returns a minimal Array of arguments, which is suitable for a call to the method
-  def minimal_arguments(method)
-    # Build an arguments array with holds all required parameters. The actual
-    # values for these arguments doesn't matter at all.
-    args = method.parameters.select { |mode, _name| mode == :req }
-
-    # Add a hash with all required keyword arguments
-    required_keyword_args = method.parameters.each_with_object({}) do |(mode, name), hsh|
-      hsh[name] = :anything if mode == :keyreq
-    end
-    args << required_keyword_args if required_keyword_args
-
-    args
-  end
-end