cli-kit 3.0.0 → 4.0.0

data/gen/lib/gen.rb

@@ -8,7 +8,10 @@ module Gen
 
   TOOL_NAME = 'cli-kit'
   ROOT      = File.expand_path('../../..', __FILE__)
-  LOG_FILE  = '/tmp/cli-kit.log'
+
+  TOOL_CONFIG_PATH = File.expand_path(File.join('~', '.config', TOOL_NAME))
+  LOG_FILE = File.join(TOOL_CONFIG_PATH, 'logs', 'log.log')
+  DEBUG_LOG_FILE = File.join(TOOL_CONFIG_PATH, 'logs', 'debug.log')
 
   autoload(:Generator, 'gen/generator')
 
@@ -17,6 +20,7 @@ module Gen
 
   autocall(:Config)  { CLI::Kit::Config.new(tool_name: TOOL_NAME) }
   autocall(:Command) { CLI::Kit::BaseCommand }
+  autocall(:Logger)  { CLI::Kit::Logger.new(debug_log_file: DEBUG_LOG_FILE) }
 
   autocall(:Executor) { CLI::Kit::Executor.new(log_file: LOG_FILE) }
   autocall(:Resolver) do

data/gen/template/Gemfile

@@ -2,3 +2,9 @@ source 'https://rubygems.org'
 
 gem 'cli-kit', '~> __cli-kit-version__'
 gem 'cli-ui', '~> __cli-ui-version__'
+
+group :test do
+  gem 'mocha', '~> 1.5.0', require: false
+  gem 'minitest', '>= 5.0.0', require: false
+  gem 'minitest-reporters', require: false
+end

data/gen/template/bin/testunit

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+root = File.expand_path('../..', __FILE__)
+TEST_ROOT = root + '/test'
+
+$LOAD_PATH.unshift(TEST_ROOT)
+
+def test_files
+  Dir.glob(TEST_ROOT + "/**/*_test.rb")
+end
+
+if ARGV.empty?
+  test_files.each { |f| require(f) }
+  exit 0
+end
+
+# A list of files is presumed to be specified
+ARGV.each do |a|
+  require a.sub(%r{^test/}, '')
+end

data/gen/template/bin/update-deps

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby --disable-gems
+#!/usr/bin/env ruby
 
 $LOAD_PATH.unshift(File.expand_path("../../vendor/deps/cli-ui/lib", __FILE__))
 require 'open3'
@@ -39,6 +39,7 @@ deps.each do |dep|
     bail(
       "dependency is not checked out: {{yellow:#{dep}}}.\n" \
       "  This repo {{bold_blue:(github.com/shopify/#{dep})}} must be cloned at {{bold_blue:#{path}}} for this script to succeed.\n" \
+      "  Currently, SOURCE_ROOT is set to {{bold_blue:#{source_path}}}.\n" \
       "  Alternatively, you can set {{bold_blue:SOURCE_ROOT}} to a directory containing {{yellow:#{dep}}}.\n" \
       "  {{bold_blue:SOURCE_ROOT}} defaults to {{bold_blue:../}}."
     )

data/gen/template/lib/__app__/commands/example.rb

@@ -1,5 +1,4 @@
 require '__app__'
-require 'json'
 
 module __App__
   module Commands

data/gen/template/test/example_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module __App__
+  class ExampleTest < MiniTest::Test
+    include CLI::Kit::Support::TestHelper
+
+    def test_example
+      CLI::Kit::System.fake("ls -al", stdout: "a\nb", success: true)
+
+      out, = CLI::Kit::System.capture2('ls', '-al')
+      assert_equal %w(a b), out.split("\n")
+
+      errors = assert_all_commands_run(should_raise: false)
+      assert_nil errors, "expected command to run successfully"
+    end
+  end
+end

data/gen/template/test/test_helper.rb

@@ -0,0 +1,22 @@
+begin
+  addpath = lambda do |p|
+    path = File.expand_path("../../#{p}", __FILE__)
+    $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+  end
+  addpath.call("lib")
+end
+
+require 'cli/kit'
+
+require 'fileutils'
+require 'tmpdir'
+require 'tempfile'
+
+require 'rubygems'
+require 'bundler/setup'
+
+CLI::UI::StdoutRouter.enable
+
+require 'minitest/autorun'
+require "minitest/unit"
+require 'mocha/minitest'

data/lib/cli/kit/base_command.rb

@@ -17,22 +17,28 @@ module CLI
 
       def self.call(args, command_name)
         cmd = new
-        stats_tags = ["task:#{cmd.class}"]
-        stats_tags << "subcommand:#{args.first}" if args && args.first && cmd.has_subcommands?
+        stats_tags = cmd.stats_tags(args, command_name)
         begin
-          statsd_increment("cli.command.invoked", tags: stats_tags)
-          statsd_time("cli.command.time", tags: stats_tags) do
+          statsd_increment('cli.command.invoked', tags: stats_tags)
+          statsd_time('cli.command.time', tags: stats_tags) do
             cmd.call(args, command_name)
           end
-          statsd_increment("cli.command.success", tags: stats_tags)
-        rescue => e
-          statsd_increment("cli.command.exception", tags: stats_tags + ["exception:#{e.class}"])
+          statsd_increment('cli.command.success', tags: stats_tags)
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          statsd_increment('cli.command.exception', tags: stats_tags + ["exception:#{e.class}"])
           raise e
         end
       end
 
+      def stats_tags(args, command_name)
+        tags = ["task:#{self.class}"]
+        tags << "command:#{command_name}" if command_name
+        tags << "subcommand:#{args.first}" if args&.first && has_subcommands?
+        tags
+      end
+
       def call(_args, _command_name)
-        raise NotImplementedError
+        raise NotImplementedError, "#{self.class.name} must implement #{__method__}"
       end
 
       def has_subcommands?

data/lib/cli/kit/command_registry.rb

@@ -68,7 +68,7 @@ module CLI
 
       def resolve_global_command(name)
         klass = resolve_class(commands.fetch(name, nil))
-        return nil unless klass
+        return nil unless klass&.defined?
         [klass, name]
       rescue NameError
         nil

data/lib/cli/kit/config.rb

@@ -18,13 +18,27 @@ module CLI
       # `name` : the name of the config value you are looking for
       #
       # #### Returns
-      # `value` : the value of the config variable (false if none)
+      # `value` : the value of the config variable (nil if none)
       #
       # #### Example Usage
       # `config.get('name.of.config')`
       #
-      def get(section, name)
-        all_configs.dig("[#{section}]", name) || false
+      def get(section, name, default: nil)
+        all_configs.dig("[#{section}]", name) || default
+      end
+
+      # Coalesce and enforce the value of a config to a boolean
+      def get_bool(section, name, default: false)
+        case get(section, name, default: default)
+        when 'true'
+          true
+        when 'false'
+          false
+        when default
+          default
+        else
+          raise CLI::Kit::Abort, "Invalid config: #{section}.#{name} is expected to be true or false"
+        end
       end
 
       # Sets the config value in the config file
@@ -43,6 +57,27 @@ module CLI
         write_config
       end
 
+      # Unsets a config value in the config file
+      #
+      # #### Parameters
+      # `section` : the section of the config you are deleting
+      # `name` : the name of the config you are deleting
+      #
+      # #### Example Usage
+      # `config.unset('section', 'name.of.config')`
+      #
+      def unset(section, name)
+        set(section, name, nil)
+      end
+
+      # Gets the hash for the entire section
+      #
+      # #### Parameters
+      # `section` : the section of the config you are getting
+      #
+      # #### Example Usage
+      # `config.get_section('section')`
+      #
       def get_section(section)
         (all_configs["[#{section}]"] || {}).dup
       end
@@ -83,7 +118,7 @@ module CLI
 
       def ini
         @ini ||= CLI::Kit::Ini
-          .new(file, default_section: "[global]", convert_types: false)
+          .new(file, default_section: '[global]', convert_types: false)
           .tap(&:parse)
       end
 

data/lib/cli/kit/error_handler.rb

@@ -4,9 +4,10 @@ require 'English'
 module CLI
   module Kit
     class ErrorHandler
-      def initialize(log_file:, exception_reporter:)
+      def initialize(log_file:, exception_reporter:, tool_name: nil)
         @log_file = log_file
         @exception_reporter_or_proc = exception_reporter || NullExceptionReporter
+        @tool_name = tool_name
       end
 
       module NullExceptionReporter
@@ -20,65 +21,84 @@ module CLI
         handle_abort(&block)
       end
 
-      private
-
-      def install!
-        at_exit { handle_final_exception(@exception || $ERROR_INFO) }
+      def handle_exception(error)
+        if (notify_with = exception_for_submission(error))
+          logs = begin
+            File.read(@log_file)
+          rescue => e
+            "(#{e.class}: #{e.message})"
+          end
+          exception_reporter.report(notify_with, logs)
+        end
       end
 
-      def handle_abort
-        yield
-        CLI::Kit::EXIT_SUCCESS
-      rescue CLI::Kit::GenericAbort => e
-        is_bug    = e.is_a?(CLI::Kit::Bug) || e.is_a?(CLI::Kit::BugSilent)
-        is_silent = e.is_a?(CLI::Kit::AbortSilent) || e.is_a?(CLI::Kit::BugSilent)
-
-        print_error_message(e) unless is_silent
-        (@exception = e) if is_bug
-
-        CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
-      rescue Interrupt
-        $stderr.puts(format_error_message("Interrupt"))
-        return CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
-      end
+      # maybe we can get rid of this.
+      attr_writer :exception
 
-      def handle_final_exception(error)
-        notify_with = nil
+      private
 
+      def exception_for_submission(error)
         case error
         when nil         # normal, non-error termination
+          nil
         when Interrupt   # ctrl-c
+          nil
         when CLI::Kit::Abort, CLI::Kit::AbortSilent # Not a bug
+          nil
         when SignalException
-          skip = %w(SIGTERM SIGHUP SIGINT)
-          unless skip.include?(error.message)
-            notify_with = error
-          end
+          skip = ['SIGTERM', 'SIGHUP', 'SIGINT']
+          skip.include?(error.message) ? nil : error
         when SystemExit # "exit N" called
           case error.status
           when CLI::Kit::EXIT_SUCCESS # submit nothing if it was `exit 0`
+            nil
           when CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
             # if it was `exit 30`, translate the exit code to 1, and submit nothing.
             # 30 is used to signal normal failures that are not indicative of bugs.
             # However, users should see it presented as 1.
-            exit 1
+            exit(1)
           else
             # A weird termination status happened. `error.exception "message"` will maintain backtrace
             # but allow us to set a message
-            notify_with = error.exception "abnormal termination status: #{error.status}"
+            error.exception("abnormal termination status: #{error.status}")
           end
         else
-          notify_with = error
+          error
         end
+      end
 
-        if notify_with
-          logs = begin
-            File.read(@log_file)
-          rescue => e
-            "(#{e.class}: #{e.message})"
-          end
-          exception_reporter.report(notify_with, logs)
+      def install!
+        at_exit { handle_exception(@exception || $ERROR_INFO) }
+      end
+
+      def handle_abort
+        yield
+        CLI::Kit::EXIT_SUCCESS
+      rescue CLI::Kit::GenericAbort => e
+        is_bug    = e.is_a?(CLI::Kit::Bug) || e.is_a?(CLI::Kit::BugSilent)
+        is_silent = e.is_a?(CLI::Kit::AbortSilent) || e.is_a?(CLI::Kit::BugSilent)
+
+        print_error_message(e) unless is_silent
+        (@exception = e) if is_bug
+
+        CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+      rescue Interrupt
+        stderr_puts_message('Interrupt')
+        CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+      rescue Errno::ENOSPC
+        message = if @tool_name
+          "Your disk is full - {{command:#{@tool_name}}} requires free space to operate"
+        else
+          'Your disk is full - free space is required to operate'
         end
+        stderr_puts_message(message)
+        CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
+      end
+
+      def stderr_puts_message(message)
+        $stderr.puts(format_error_message(message))
+      rescue Errno::EPIPE
+        nil
       end
 
       def exception_reporter

data/lib/cli/kit/executor.rb

@@ -1,37 +1,66 @@
 require 'cli/kit'
 require 'English'
+require 'fileutils'
 
 module CLI
   module Kit
     class Executor
       def initialize(log_file:)
+        FileUtils.mkpath(File.dirname(log_file))
         @log_file = log_file
       end
 
       def call(command, command_name, args)
-        with_traps { with_logging { command.call(args, command_name) } }
+        with_traps do
+          with_logging do |id|
+            command.call(args, command_name)
+          rescue => e
+            begin
+              $stderr.puts "This command ran with ID: #{id}"
+              $stderr.puts 'Please include this information in any issues/report along with relevant logs'
+            rescue SystemCallError
+              # Outputting to stderr is best-effort.  Avoid raising another error when outputting debug info so that
+              # we can detect and log the original error, which may even be the source of this error.
+              nil
+            end
+            raise e
+          end
+        end
       end
 
       private
 
       def with_logging(&block)
         return yield unless @log_file
-        CLI::UI.log_output_to(@log_file, &block)
+        CLI::UI.log_output_to(@log_file) do
+          CLI::UI::StdoutRouter.with_id(on_streams: [CLI::UI::StdoutRouter.duplicate_output_to]) do |id|
+            block.call(id)
+          end
+        end
       end
 
-      def with_traps
+      def with_traps(&block)
         twrap('QUIT', method(:quit_handler)) do
-          twrap('INFO', method(:info_handler)) do
-            yield
-          end
+          twrap('INFO', method(:info_handler), &block)
         end
       end
 
       def twrap(signal, handler)
-        prev_handler = trap(signal, handler)
-        yield
-      ensure
-        trap(signal, prev_handler)
+        return yield unless Signal.list.key?(signal)
+
+        begin
+          begin
+            prev_handler = trap(signal, handler)
+            installed = true
+          rescue ArgumentError
+            # If we couldn't install a signal handler because the signal is
+            # reserved, remember not to uninstall it later.
+            installed = false
+          end
+          yield
+        ensure
+          trap(signal, prev_handler) if installed
+        end
       end
 
       def quit_handler(_sig)

data/lib/cli/kit/ini.rb

@@ -15,8 +15,12 @@ module CLI
     class Ini
       attr_accessor :ini
 
-      def initialize(path = nil, default_section: nil, convert_types: true)
-        @config = File.readlines(path) if path && File.exist?(path)
+      def initialize(path = nil, config: nil, default_section: nil, convert_types: true)
+        @config = if path && File.exist?(path)
+          File.readlines(path)
+        elsif config
+          config.lines
+        end
         @ini = {}
         @current_key = nil
         @default_section = default_section
@@ -39,28 +43,33 @@ module CLI
 
           # Otherwise set the values
           else
-            k, v = l.split('=').map(&:strip)
+            k, v = l.split('=', 2).map(&:strip)
             set_val(k, v)
           end
         end
         @ini
       end
 
+      def git_format
+        to_ini(@ini, git_format: true).flatten.join("\n")
+      end
+
       def to_s
         to_ini(@ini).flatten.join("\n")
       end
 
       private
 
-      def to_ini(h)
+      def to_ini(h, git_format: false)
+        optional_tab = git_format ? "\t" : ''
         str = []
         h.each do |k, v|
           if section_designator?(k)
-            str << "" unless str.empty?
+            str << '' unless str.empty? || git_format
             str << k
-            str << to_ini(v)
+            str << to_ini(v, git_format: git_format)
           else
-            str << "#{k} = #{v}"
+            str << "#{optional_tab}#{k} = #{v}"
           end
         end
         str

data/lib/cli/kit/logger.rb

@@ -0,0 +1,82 @@
+require 'logger'
+require 'fileutils'
+
+module CLI
+  module Kit
+    class Logger
+      MAX_LOG_SIZE = 5 * 1024 * 1000 # 5MB
+      MAX_NUM_LOGS = 10
+
+      # Constructor for CLI::Kit::Logger
+      #
+      # @param debug_log_file [String] path to the file where debug logs should be stored
+      def initialize(debug_log_file:, env_debug_name: 'DEBUG')
+        FileUtils.mkpath(File.dirname(debug_log_file))
+        @debug_logger = ::Logger.new(debug_log_file, MAX_NUM_LOGS, MAX_LOG_SIZE)
+        @env_debug_name = env_debug_name
+      end
+
+      # Functionally equivalent to Logger#info
+      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
+      #
+      # @param msg [String] the message to log
+      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
+      def info(msg, debug: true)
+        $stdout.puts CLI::UI.fmt(msg)
+        @debug_logger.info(format_debug(msg)) if debug
+      end
+
+      # Functionally equivalent to Logger#warn
+      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
+      #
+      # @param msg [String] the message to log
+      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
+      def warn(msg, debug: true)
+        $stdout.puts CLI::UI.fmt("{{yellow:#{msg}}}")
+        @debug_logger.warn(format_debug(msg)) if debug
+      end
+
+      # Functionally equivalent to Logger#error
+      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
+      #
+      # @param msg [String] the message to log
+      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
+      def error(msg, debug: true)
+        $stderr.puts CLI::UI.fmt("{{red:#{msg}}}")
+        @debug_logger.error(format_debug(msg)) if debug
+      end
+
+      # Functionally equivalent to Logger#fatal
+      # Also logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
+      #
+      # @param msg [String] the message to log
+      # @param debug [Boolean] determines if the debug logger will receive the log (default true)
+      def fatal(msg, debug: true)
+        $stderr.puts CLI::UI.fmt("{{red:{{bold:Fatal:}} #{msg}}}")
+        @debug_logger.fatal(format_debug(msg)) if debug
+      end
+
+      # Similar to Logger#debug, however will not output to STDOUT unless DEBUG env var is set
+      # Logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
+      #
+      # @param msg [String] the message to log
+      def debug(msg)
+        $stdout.puts CLI::UI.fmt(msg) if debug?
+        @debug_logger.debug(format_debug(msg))
+      end
+
+      private
+
+      def format_debug(msg)
+        msg = CLI::UI.fmt(msg)
+        return msg unless CLI::UI::StdoutRouter.current_id
+        "[#{CLI::UI::StdoutRouter.current_id[:id]}] #{msg}"
+      end
+
+      def debug?
+        val = ENV[@env_debug_name]
+        val && val != '0' && val != ''
+      end
+    end
+  end
+end

data/lib/cli/kit/resolver.rb

@@ -25,7 +25,7 @@ module CLI
       private
 
       def command_not_found(name)
-        CLI::UI::Frame.open("Command not found", color: :red, timing: false) do
+        CLI::UI::Frame.open('Command not found', color: :red, timing: false) do
           $stderr.puts(CLI::UI.fmt("{{command:#{@tool_name} #{name}}} was not found"))
         end
 
@@ -43,7 +43,7 @@ module CLI
 
           # If we have any matches left, tell the user
           if possible_matches.any?
-            CLI::UI::Frame.open("{{bold:Did you mean?}}", timing: false, color: :blue) do
+            CLI::UI::Frame.open('{{bold:Did you mean?}}', timing: false, color: :blue) do
               possible_matches.each do |possible_match|
                 $stderr.puts CLI::UI.fmt("{{command:#{@tool_name} #{possible_match}}}")
               end