cli-kit 3.0.0 → 4.0.0

data/lib/cli/kit/support/test_helper.rb

@@ -0,0 +1,244 @@
+module CLI
+  module Kit
+    module Support
+      module TestHelper
+        def setup
+          super
+          CLI::Kit::System.reset!
+        end
+
+        def assert_all_commands_run(should_raise: true)
+          errors = CLI::Kit::System.error_message
+          CLI::Kit::System.reset!
+          assert(false, errors) if should_raise && !errors.nil?
+          errors
+        end
+
+        def teardown
+          super
+          assert_all_commands_run
+        end
+
+        module FakeConfig
+          require 'tmpdir'
+          require 'fileutils'
+
+          def setup
+            super
+            @tmpdir = Dir.mktmpdir
+            @prev_xdg = ENV['XDG_CONFIG_HOME']
+            ENV['XDG_CONFIG_HOME'] = @tmpdir
+          end
+
+          def teardown
+            FileUtils.rm_rf(@tmpdir)
+            ENV['XDG_CONFIG_HOME'] = @prev_xdg
+            super
+          end
+        end
+
+        class FakeSuccess
+          def initialize(success)
+            @success = success
+          end
+
+          def success?
+            @success
+          end
+        end
+
+        module ::CLI
+          module Kit
+            module System
+              class << self
+                alias_method :original_system, :system
+                def system(*a, sudo: false, env: {}, **kwargs)
+                  expected_command = expected_command(*a, sudo: sudo, env: env)
+
+                  # In the case of an unexpected command, expected_command will be nil
+                  return FakeSuccess.new(false) if expected_command.nil?
+
+                  # Otherwise handle the command
+                  if expected_command[:allow]
+                    original_system(*a, sudo: sudo, env: env, **kwargs)
+                  else
+                    FakeSuccess.new(expected_command[:success])
+                  end
+                end
+
+                alias_method :original_capture2, :capture2
+                def capture2(*a, sudo: false, env: {}, **kwargs)
+                  expected_command = expected_command(*a, sudo: sudo, env: env)
+
+                  # In the case of an unexpected command, expected_command will be nil
+                  return [nil, FakeSuccess.new(false)] if expected_command.nil?
+
+                  # Otherwise handle the command
+                  if expected_command[:allow]
+                    original_capture2(*a, sudo: sudo, env: env, **kwargs)
+                  else
+                    [
+                      expected_command[:stdout],
+                      FakeSuccess.new(expected_command[:success]),
+                    ]
+                  end
+                end
+
+                alias_method :original_capture2e, :capture2e
+                def capture2e(*a, sudo: false, env: {}, **kwargs)
+                  expected_command = expected_command(*a, sudo: sudo, env: env)
+
+                  # In the case of an unexpected command, expected_command will be nil
+                  return [nil, FakeSuccess.new(false)] if expected_command.nil?
+
+                  # Otherwise handle the command
+                  if expected_command[:allow]
+                    original_capture2ecapture2e(*a, sudo: sudo, env: env, **kwargs)
+                  else
+                    [
+                      expected_command[:stdout],
+                      FakeSuccess.new(expected_command[:success]),
+                    ]
+                  end
+                end
+
+                alias_method :original_capture3, :capture3
+                def capture3(*a, sudo: false, env: {}, **kwargs)
+                  expected_command = expected_command(*a, sudo: sudo, env: env)
+
+                  # In the case of an unexpected command, expected_command will be nil
+                  return [nil, nil, FakeSuccess.new(false)] if expected_command.nil?
+
+                  # Otherwise handle the command
+                  if expected_command[:allow]
+                    original_capture3(*a, sudo: sudo, env: env, **kwargs)
+                  else
+                    [
+                      expected_command[:stdout],
+                      expected_command[:stderr],
+                      FakeSuccess.new(expected_command[:success]),
+                    ]
+                  end
+                end
+
+                # Sets up an expectation for a command and stubs out the call (unless allow is true)
+                #
+                # #### Parameters
+                # `*a` : the command, represented as a splat
+                # `stdout` : stdout to stub the command with (defaults to empty string)
+                # `stderr` : stderr to stub the command with (defaults to empty string)
+                # `allow` : allow determines if the command will be actually run, or stubbed. Defaults to nil (stub)
+                # `success` : success status to stub the command with (Defaults to nil)
+                # `sudo` : expectation of sudo being set or not (defaults to false)
+                # `env` : expectation of env being set or not (defaults to {})
+                #
+                # Note: Must set allow or success
+                #
+                def fake(*a, stdout: '', stderr: '', allow: nil, success: nil, sudo: false, env: {})
+                  raise ArgumentError, 'success or allow must be set' if success.nil? && allow.nil?
+
+                  @delegate_open3 ||= {}
+                  @delegate_open3[a.join(' ')] = {
+                    expected: {
+                      sudo: sudo,
+                      env: env,
+                    },
+                    actual: {
+                      sudo: nil,
+                      env: nil,
+                    },
+                    stdout: stdout,
+                    stderr: stderr,
+                    allow: allow,
+                    success: success,
+                    run: false,
+                  }
+                end
+
+                # Resets the faked commands
+                #
+                def reset!
+                  @delegate_open3 = {}
+                end
+
+                # Returns the errors associated to a test run
+                #
+                # #### Returns
+                # `errors` (String) a string representing errors found on this run, nil if none
+                def error_message
+                  errors = {
+                    unexpected: [],
+                    not_run: [],
+                    other: {},
+                  }
+
+                  @delegate_open3.each do |cmd, opts|
+                    if opts[:unexpected]
+                      errors[:unexpected] << cmd
+                    elsif opts[:run]
+                      error = []
+
+                      if opts[:expected][:sudo] != opts[:actual][:sudo]
+                        error << "- sudo was supposed to be #{opts[:expected][:sudo]} but was #{opts[:actual][:sudo]}"
+                      end
+
+                      if opts[:expected][:env] != opts[:actual][:env]
+                        error << "- env was supposed to be #{opts[:expected][:env]} but was #{opts[:actual][:env]}"
+                      end
+
+                      errors[:other][cmd] = error.join("\n") unless error.empty?
+                    else
+                      errors[:not_run] << cmd
+                    end
+                  end
+
+                  final_error = []
+
+                  unless errors[:unexpected].empty?
+                    final_error << CLI::UI.fmt(<<~EOF)
+                      {{bold:Unexpected command invocations:}}
+                      {{command:#{errors[:unexpected].join("\n")}}}
+                    EOF
+                  end
+
+                  unless errors[:not_run].empty?
+                    final_error << CLI::UI.fmt(<<~EOF)
+                      {{bold:Expected commands were not run:}}
+                      {{command:#{errors[:not_run].join("\n")}}}
+                    EOF
+                  end
+
+                  unless errors[:other].empty?
+                    final_error << CLI::UI.fmt(<<~EOF)
+                      {{bold:Commands were not run as expected:}}
+                      #{errors[:other].map { |cmd, msg| "{{command:#{cmd}}}\n#{msg}" }.join("\n\n")}
+                    EOF
+                  end
+
+                  return nil if final_error.empty?
+                  "\n" + final_error.join("\n") # Initial new line for formatting reasons
+                end
+
+                private
+
+                def expected_command(*a, sudo: raise, env: raise)
+                  expected_cmd = @delegate_open3[a.join(' ')]
+
+                  if expected_cmd.nil?
+                    @delegate_open3[a.join(' ')] = { unexpected: true }
+                    return nil
+                  end
+
+                  expected_cmd[:run] = true
+                  expected_cmd[:actual][:sudo] = sudo
+                  expected_cmd[:actual][:env] = env
+                  expected_cmd
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/kit/support.rb

@@ -0,0 +1,9 @@
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Support
+      autoload :TestHelper, 'cli/kit/support/test_helper'
+    end
+  end
+end

data/lib/cli/kit/system.rb

@@ -6,7 +6,7 @@ require 'English'
 module CLI
   module Kit
     module System
-      SUDO_PROMPT = CLI::UI.fmt("{{info:(sudo)}} Password: ")
+      SUDO_PROMPT = CLI::UI.fmt('{{info:(sudo)}} Password: ')
       class << self
         # Ask for sudo access with a message explaning the need for it
         # Will make subsequent commands capable of running with sudo for a period of time
@@ -19,7 +19,7 @@ module CLI
         #
         def sudo_reason(msg)
           # See if sudo has a cached password
-          `env SUDO_ASKPASS=/usr/bin/false sudo -A true`
+          %x(env SUDO_ASKPASS=/usr/bin/false sudo -A true)
           return if $CHILD_STATUS.success?
           CLI::UI.with_frame_color(:blue) do
             puts(CLI::UI.fmt("{{i}} #{msg}"))
@@ -90,6 +90,18 @@ module CLI
           delegate_open3(*a, sudo: sudo, env: env, method: :capture3, **kwargs)
         end
 
+        def popen2(*a, sudo: false, env: ENV, **kwargs, &block)
+          delegate_open3(*a, sudo: sudo, env: env, method: :popen2, **kwargs, &block)
+        end
+
+        def popen2e(*a, sudo: false, env: ENV, **kwargs, &block)
+          delegate_open3(*a, sudo: sudo, env: env, method: :popen2e, **kwargs, &block)
+        end
+
+        def popen3(*a, sudo: false, env: ENV, **kwargs, &block)
+          delegate_open3(*a, sudo: sudo, env: env, method: :popen3, **kwargs, &block)
+        end
+
         # Execute a command in the user's environment
         # Outputs result of the command without capturing it
         #
@@ -100,7 +112,7 @@ module CLI
         # - `**kwargs`: additional keyword arguments to pass to Process.spawn
         #
         # #### Returns
-        # - `status`: boolean success status of the command execution
+        # - `status`: The `Process:Status` result for the command execution
         #
         # #### Usage
         # `stat = CLI::Kit::System.system('ls', 'a_folder')`
@@ -116,11 +128,15 @@ module CLI
           err_w.close
 
           handlers = if block_given?
-            { out_r => ->(data) { yield(data.force_encoding(Encoding::UTF_8), '') },
-              err_r => ->(data) { yield('', data.force_encoding(Encoding::UTF_8)) }, }
+            {
+              out_r => ->(data) { yield(data.force_encoding(Encoding::UTF_8), '') },
+              err_r => ->(data) { yield('', data.force_encoding(Encoding::UTF_8)) },
+            }
           else
-            { out_r => ->(data) { STDOUT.write(data) },
-              err_r => ->(data) { STDOUT.write(data) }, }
+            {
+              out_r => ->(data) { STDOUT.write(data) },
+              err_r => ->(data) { STDOUT.write(data) },
+            }
           end
 
           previous_trailing = Hash.new('')
@@ -130,13 +146,11 @@ module CLI
 
             readers, = IO.select(ios)
             readers.each do |io|
-              begin
-                data, trailing = split_partial_characters(io.readpartial(4096))
-                handlers[io].call(previous_trailing[io] + data)
-                previous_trailing[io] = trailing
-              rescue IOError
-                io.close
-              end
+              data, trailing = split_partial_characters(io.readpartial(4096))
+              handlers[io].call(previous_trailing[io] + data)
+              previous_trailing[io] = trailing
+            rescue IOError
+              io.close
             end
           end
 
@@ -163,6 +177,14 @@ module CLI
           [data.byteslice(0...partial_character_index), data.byteslice(partial_character_index..-1)]
         end
 
+        def os
+          return :mac if /darwin/.match(RUBY_PLATFORM)
+          return :linux if /linux/.match(RUBY_PLATFORM)
+          return :windows if /mingw32/.match(RUBY_PLATFORM)
+
+          raise "Could not determine OS from platform #{RUBY_PLATFORM}"
+        end
+
         private
 
         def apply_sudo(*a, sudo)
@@ -171,11 +193,11 @@ module CLI
           a
         end
 
-        def delegate_open3(*a, sudo: raise, env: raise, method: raise, **kwargs)
+        def delegate_open3(*a, sudo: raise, env: raise, method: raise, **kwargs, &block)
           a = apply_sudo(*a, sudo)
-          Open3.send(method, env, *resolve_path(a, env), **kwargs)
+          Open3.send(method, env, *resolve_path(a, env), **kwargs, &block)
         rescue Errno::EINTR
-          raise(Errno::EINTR, "command interrupted: #{a.join(' ')}")
+          raise(Errno::EINTR, "command interrupted: #{a.join(" ")}")
         end
 
         # Ruby resolves the program to execute using its own PATH, but we want it to
@@ -189,14 +211,31 @@ module CLI
         # See https://github.com/Shopify/dev/pull/625 for more details.
         def resolve_path(a, env)
           # If only one argument was provided, make sure it's interpreted by a shell.
-          return ["true ; " + a[0]] if a.size == 1
-          return a if a.first.include?('/')
-          item = env.fetch('PATH', '').split(':').detect do |f|
-            File.exist?("#{f}/#{a.first}")
+          if a.size == 1
+            if os == :windows
+              return ['break && ' + a[0]]
+            else
+              return ['true ; ' + a[0]]
+            end
           end
-          a[0] = "#{item}/#{a.first}" if item
+          return a if a.first.include?('/')
+
+          item = which(a.first, env)
+          a[0] = item if item
           a
         end
+
+        def which(cmd, env)
+          exts = os == :windows ? env.fetch('PATHEXT').split(';') : ['']
+          env.fetch('PATH', '').split(File::PATH_SEPARATOR).each do |path|
+            exts.each do |ext|
+              exe = File.join(path, "#{cmd}#{ext}")
+              return exe if File.executable?(exe) && !File.directory?(exe)
+            end
+          end
+
+          nil
+        end
       end
     end
   end

data/lib/cli/kit/util.rb

@@ -0,0 +1,189 @@
+module CLI
+  module Kit
+    module Util
+      class << self
+        def snake_case(camel_case, seperator = '_')
+          camel_case.to_s # MyCoolThing::MyAPIModule
+            .gsub(/::/, '/') # MyCoolThing/MyAPIModule
+            .gsub(/([A-Z]+)([A-Z][a-z])/, "\\1#{seperator}\\2") # MyCoolThing::MyAPI_Module
+            .gsub(/([a-z\d])([A-Z])/, "\\1#{seperator}\\2") # My_Cool_Thing::My_API_Module
+            .downcase # my_cool_thing/my_api_module
+        end
+
+        def dash_case(camel_case)
+          snake_case(camel_case, '-')
+        end
+
+        # The following methods is taken from activesupport
+        # All credit for this method goes to the original authors.
+        # https://github.com/rails/rails/blob/d66e7835bea9505f7003e5038aa19b6ea95ceea1/activesupport/lib/active_support/core_ext/string/strip.rb
+        #
+        # Copyright (c) 2005-2018 David Heinemeier Hansson
+        #
+        # Permission is hereby granted, free of charge, to any person obtaining
+        # a copy of this software and associated documentation files (the
+        # "Software"), to deal in the Software without restriction, including
+        # without limitation the rights to use, copy, modify, merge, publish,
+        # distribute, sublicense, and/or sell copies of the Software, and to
+        # permit persons to whom the Software is furnished to do so, subject to
+        # the following conditions:
+        #
+        # The above copyright notice and this permission notice shall be
+        # included in all copies or substantial portions of the Software.
+        #
+        # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+        # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+        # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+        # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        #
+        # Strips indentation by removing the amount of leading whitespace in the least indented
+        # non-empty line in the whole string
+        #
+        def strip_heredoc(str)
+          str.gsub(/^#{str.scan(/^[ \t]*(?=\S)/).min}/, ''.freeze)
+        end
+
+        # Joins an array with commas and "and", using the Oxford comma.
+        def english_join(array)
+          return '' if array.nil?
+          return array.join(' and ') if array.length < 3
+
+          "#{array[0..-2].join(", ")}, and #{array[-1]}"
+        end
+
+        # Execute a block within the context of a variable enviroment
+        #
+        def with_environment(environment, value)
+          return yield unless environment
+
+          old_env = ENV[environment]
+          begin
+            ENV[environment] = value
+            yield
+          ensure
+            old_env ? ENV[environment] = old_env : ENV.delete(environment)
+          end
+        end
+
+        # Converts an integer representing bytes into a human readable format
+        #
+        def to_filesize(bytes, precision: 2, space: false)
+          to_si_scale(bytes, 'B', precision: precision, space: space, factor: 1024)
+        end
+
+        # Converts a number to a human readable format on the SI scale
+        #
+        def to_si_scale(number, unit = '', factor: 1000, precision: 2, space: false)
+          raise ArgumentError, 'factor should only be 1000 or 1024' unless [1000, 1024].include?(factor)
+
+          small_scale = ['m', 'µ', 'n', 'p', 'f', 'a', 'z', 'y']
+          big_scale = ['k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y']
+          negative = number < 0
+          number = number.abs.to_f
+
+          if number == 0 || number.between?(1, factor)
+            prefix = ''
+            scale = 0
+          else
+            scale = Math.log(number, factor).floor
+            if number < 1
+              index = [-scale - 1, small_scale.length].min
+              scale = -(index + 1)
+              prefix = small_scale[index]
+            else
+              index = [scale - 1, big_scale.length].min
+              scale = index + 1
+              prefix = big_scale[index]
+            end
+          end
+
+          divider = (factor**scale)
+          fnum = (number / divider).round(precision)
+
+          # Trim useless decimal
+          fnum = fnum.to_i if (fnum.to_i.to_f * divider) == number
+
+          fnum = -fnum if negative
+          prefix = ' ' + prefix if space
+
+          "#{fnum}#{prefix}#{unit}"
+        end
+
+        # Dir.chdir, when invoked in block form, complains when we call chdir
+        # again recursively. There's no apparent good reason for this, so we
+        # simply implement our own block form of Dir.chdir here.
+        def with_dir(dir)
+          prev = Dir.pwd
+          Dir.chdir(dir)
+          yield
+        ensure
+          Dir.chdir(prev)
+        end
+
+        def with_tmp_dir
+          require 'fileutils'
+          dir = Dir.mktmpdir
+          with_dir(dir) do
+            yield(dir)
+          end
+        ensure
+          FileUtils.remove_entry(dir)
+        end
+
+        # Standard way of checking for CI / Tests
+        def testing?
+          ci? || ENV['TEST']
+        end
+
+        # Set only in IntegrationTest#session; indicates that the process was
+        # called by `session.execute` from an IntegrationTest subclass.
+        def integration_test_session?
+          ENV['INTEGRATION_TEST_SESSION']
+        end
+
+        # Standard way of checking for CI
+        def ci?
+          ENV['CI']
+        end
+
+        # Must call retry_after on the result in order to execute the block
+        #
+        # Example usage:
+        #
+        # CLI::Kit::Util.begin do
+        #   might_raise_if_costly_prep_not_done()
+        # end.retry_after(ExpectedError) do
+        #   costly_prep()
+        # end
+        def begin(&block_that_might_raise)
+          Retrier.new(block_that_might_raise)
+        end
+      end
+
+      class Retrier
+        def initialize(block_that_might_raise)
+          @block_that_might_raise = block_that_might_raise
+        end
+
+        def retry_after(exception = StandardError, retries: 1, &before_retry)
+          @block_that_might_raise.call
+        rescue exception => e
+          raise if (retries -= 1) < 0
+          if before_retry
+            if before_retry.arity == 0
+              yield
+            else
+              yield e
+            end
+          end
+          retry
+        end
+      end
+
+      private_constant :Retrier
+    end
+  end
+end

data/lib/cli/kit/version.rb

@@ -1,5 +1,5 @@
 module CLI
   module Kit
-    VERSION = "3.0.0"
+    VERSION = '4.0.0'
   end
 end

data/lib/cli/kit.rb

@@ -11,8 +11,11 @@ module CLI
     autoload :Executor,        'cli/kit/executor'
     autoload :Ini,             'cli/kit/ini'
     autoload :Levenshtein,     'cli/kit/levenshtein'
+    autoload :Logger,          'cli/kit/logger'
     autoload :Resolver,        'cli/kit/resolver'
+    autoload :Support,         'cli/kit/support'
     autoload :System,          'cli/kit/system'
+    autoload :Util,            'cli/kit/util'
 
     EXIT_FAILURE_BUT_NOT_BUG = 30
     EXIT_BUG                 = 1
@@ -48,7 +51,7 @@ module CLI
     #       1. rescue Abort or Bug
     #       2. Print a contextualized error message
     #       3. Re-raise AbortSilent or BugSilent respectively.
-    GenericAbort = Class.new(Exception)
+    GenericAbort = Class.new(Exception) # rubocop:disable Lint/InheritException
     Abort        = Class.new(GenericAbort)
     Bug          = Class.new(GenericAbort)
     BugSilent    = Class.new(GenericAbort)