cli-kit 3.3.0 → 5.0.0

data/lib/cli/kit/sorbet_runtime_stub.rb

@@ -0,0 +1,156 @@
+# typed: ignore
+# frozen_string_literal: true
+
+module T
+  class << self
+    def absurd(value); end
+    def all(type_a, type_b, *types); end
+    def any(type_a, type_b, *types); end
+    def attached_class; end
+    def class_of(klass); end
+    def enum(values); end
+    def nilable(type); end
+    def noreturn; end
+    def self_type; end
+    def type_alias(type = nil, &_blk); end
+    def type_parameter(name); end
+    def untyped; end
+
+    def assert_type!(value, _type, _checked: true)
+      value
+    end
+
+    def cast(value, _type, _checked: true)
+      value
+    end
+
+    def let(value, _type, _checked: true)
+      value
+    end
+
+    def must(arg, _msg = nil)
+      arg
+    end
+
+    def proc
+      T::Proc.new
+    end
+
+    def reveal_type(value)
+      value
+    end
+
+    def unsafe(value)
+      value
+    end
+  end
+
+  module Sig
+    def sig(arg0 = nil, &blk); end
+  end
+
+  module Helpers
+    def abstract!; end
+    def interface!; end
+    def final!; end
+    def sealed!; end
+    def mixes_in_class_methods(mod); end
+  end
+
+  module Generic
+    include(T::Helpers)
+
+    def type_parameters(*params); end
+    def type_member(variance = :invariant, fixed: nil, lower: nil, upper: BasicObject); end
+    def type_template(variance = :invariant, fixed: nil, lower: nil, upper: BasicObject); end
+
+    def [](*types)
+      self
+    end
+  end
+
+  module Array
+    class << self
+      def [](type); end
+    end
+  end
+
+  Boolean = Object.new.freeze
+
+  module Configuration
+    class << self
+      def call_validation_error_handler(signature, opts); end
+      def call_validation_error_handler=(value); end
+      def default_checked_level=(default_checked_level); end
+      def enable_checking_for_sigs_marked_checked_tests; end
+      def enable_final_checks_on_hooks; end
+      def enable_legacy_t_enum_migration_mode; end
+      def reset_final_checks_on_hooks; end
+      def hard_assert_handler(str, extra); end
+      def hard_assert_handler=(value); end
+      def inline_type_error_handler(error); end
+      def inline_type_error_handler=(value); end
+      def log_info_handler(str, extra); end
+      def log_info_handler=(value); end
+      def scalar_types; end
+      def scalar_types=(values); end
+      # rubocop:disable Naming/InclusiveLanguage
+      def sealed_violation_whitelist; end
+      def sealed_violation_whitelist=(sealed_violation_whitelist); end
+      # rubocop:enable Naming/InclusiveLanguage
+      def sig_builder_error_handler=(value); end
+      def sig_validation_error_handler(error, opts); end
+      def sig_validation_error_handler=(value); end
+      def soft_assert_handler(str, extra); end
+      def soft_assert_handler=(value); end
+    end
+  end
+
+  module Enumerable
+    class << self
+      def [](type); end
+    end
+  end
+
+  module Enumerator
+    class << self
+      def [](type); end
+    end
+  end
+
+  module Hash
+    class << self
+      def [](keys, values); end
+    end
+  end
+
+  class Proc
+    def bind(*_)
+      self
+    end
+
+    def params(*_param)
+      self
+    end
+
+    def void
+      self
+    end
+
+    def returns(_type)
+      self
+    end
+  end
+
+  module Range
+    class << self
+      def [](type); end
+    end
+  end
+
+  module Set
+    class << self
+      def [](type); end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require 'cli/kit'
+
 module CLI
   module Kit
     module Support
@@ -10,7 +12,9 @@ module CLI
         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?
+          # this is in minitest, but sorbet doesn't know that. probably we
+          # could structure this better.
+          T.unsafe(self).assert(false, errors) if should_raise && !errors.nil?
           errors
         end
 
@@ -52,30 +56,32 @@ module CLI
             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)
+                def system(cmd, *a, sudo: false, env: {}, stdin: nil, **kwargs)
+                  a.unshift(cmd)
+                  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)
+                    T.unsafe(self).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)
+                def capture2(cmd, *a, sudo: false, env: {}, **kwargs)
+                  a.unshift(cmd)
+                  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)
+                    T.unsafe(self).original_capture2(*a, sudo: sudo, env: env, **kwargs)
                   else
                     [
                       expected_command[:stdout],
@@ -85,15 +91,16 @@ module CLI
                 end
 
                 alias_method :original_capture2e, :capture2e
-                def capture2e(*a, sudo: false, env: {}, **kwargs)
-                  expected_command = expected_command(*a, sudo: sudo, env: env)
+                def capture2e(cmd, *a, sudo: false, env: {}, **kwargs)
+                  a.unshift(cmd)
+                  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)
+                    T.unsafe(self).original_capture2e(*a, sudo: sudo, env: env, **kwargs)
                   else
                     [
                       expected_command[:stdout],
@@ -103,15 +110,16 @@ module CLI
                 end
 
                 alias_method :original_capture3, :capture3
-                def capture3(*a, sudo: false, env: {}, **kwargs)
-                  expected_command = expected_command(*a, sudo: sudo, env: env)
+                def capture3(cmd, *a, sudo: false, env: {}, **kwargs)
+                  a.unshift(cmd)
+                  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)
+                    T.unsafe(self).original_capture3(*a, sudo: sudo, env: env, **kwargs)
                   else
                     [
                       expected_command[:stdout],
@@ -134,8 +142,8 @@ module CLI
                 #
                 # 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?
+                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(' ')] = {
@@ -196,32 +204,33 @@ module CLI
 
                   unless errors[:unexpected].empty?
                     final_error << CLI::UI.fmt(<<~EOF)
-                    {{bold:Unexpected command invocations:}}
-                    {{command:#{errors[:unexpected].join("\n")}}}
+                      {{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")}}}
+                      {{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")}
+                      {{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)
+                def expected_command(a, sudo: raise, env: raise)
                   expected_cmd = @delegate_open3[a.join(' ')]
 
                   if expected_cmd.nil?

data/lib/cli/kit/support.rb

@@ -1,3 +1,5 @@
+# typed: true
+
 require 'cli/kit'
 
 module CLI

data/lib/cli/kit/system.rb

@@ -1,13 +1,16 @@
-require 'cli/kit'
+# typed: true
 
+require 'cli/kit'
 require 'open3'
 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
+        extend T::Sig
+
         # 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
         #
@@ -17,10 +20,12 @@ module CLI
         # #### Usage
         # `ctx.sudo_reason("We need to do a thing")`
         #
+        sig { params(msg: String).void }
         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 > /dev/null 2>&1)
           return if $CHILD_STATUS.success?
+
           CLI::UI.with_frame_color(:blue) do
             puts(CLI::UI.fmt("{{i}} #{msg}"))
           end
@@ -43,8 +48,18 @@ module CLI
         # #### Usage
         # `out, stat = CLI::Kit::System.capture2('ls', 'a_folder')`
         #
-        def capture2(*a, sudo: false, env: ENV, **kwargs)
-          delegate_open3(*a, sudo: sudo, env: env, method: :capture2, **kwargs)
+        sig do
+          params(
+            cmd: String,
+            args: String,
+            sudo: T.any(T::Boolean, String),
+            env: T::Hash[String, T.nilable(String)],
+            kwargs: T.untyped,
+          )
+            .returns([String, Process::Status])
+        end
+        def capture2(cmd, *args, sudo: false, env: ENV.to_h, **kwargs)
+          delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :capture2)
         end
 
         # Execute a command in the user's environment
@@ -64,8 +79,18 @@ module CLI
         # #### Usage
         # `out_and_err, stat = CLI::Kit::System.capture2e('ls', 'a_folder')`
         #
-        def capture2e(*a, sudo: false, env: ENV, **kwargs)
-          delegate_open3(*a, sudo: sudo, env: env, method: :capture2e, **kwargs)
+        sig do
+          params(
+            cmd: String,
+            args: String,
+            sudo: T.any(T::Boolean, String),
+            env: T::Hash[String, T.nilable(String)],
+            kwargs: T.untyped,
+          )
+            .returns([String, Process::Status])
+        end
+        def capture2e(cmd, *args, sudo: false, env: ENV.to_h, **kwargs)
+          delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :capture2e)
         end
 
         # Execute a command in the user's environment
@@ -86,8 +111,72 @@ module CLI
         # #### Usage
         # `out, err, stat = CLI::Kit::System.capture3('ls', 'a_folder')`
         #
-        def capture3(*a, sudo: false, env: ENV, **kwargs)
-          delegate_open3(*a, sudo: sudo, env: env, method: :capture3, **kwargs)
+        sig do
+          params(
+            cmd: String,
+            args: String,
+            sudo: T.any(T::Boolean, String),
+            env: T::Hash[String, T.nilable(String)],
+            kwargs: T.untyped,
+          )
+            .returns([String, String, Process::Status])
+        end
+        def capture3(cmd, *args, sudo: false, env: ENV.to_h, **kwargs)
+          delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :capture3)
+        end
+
+        sig do
+          params(
+            cmd: String,
+            args: String,
+            sudo: T.any(T::Boolean, String),
+            env: T::Hash[String, T.nilable(String)],
+            kwargs: T.untyped,
+            block: T.nilable(
+              T.proc.params(stdin: IO, stdout: IO, wait_thr: Process::Waiter)
+                .returns([IO, IO, Process::Waiter]),
+            ),
+          )
+            .returns([IO, IO, Process::Waiter])
+        end
+        def popen2(cmd, *args, sudo: false, env: ENV.to_h, **kwargs, &block)
+          delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :popen2, &block)
+        end
+
+        sig do
+          params(
+            cmd: String,
+            args: String,
+            sudo: T.any(T::Boolean, String),
+            env: T::Hash[String, T.nilable(String)],
+            kwargs: T.untyped,
+            block: T.nilable(
+              T.proc.params(stdin: IO, stdout: IO, wait_thr: Process::Waiter)
+                .returns([IO, IO, Process::Waiter]),
+            ),
+          )
+            .returns([IO, IO, Process::Waiter])
+        end
+        def popen2e(cmd, *args, sudo: false, env: ENV.to_h, **kwargs, &block)
+          delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :popen2e, &block)
+        end
+
+        sig do
+          params(
+            cmd: String,
+            args: String,
+            sudo: T.any(T::Boolean, String),
+            env: T::Hash[String, T.nilable(String)],
+            kwargs: T.untyped,
+            block: T.nilable(
+              T.proc.params(stdin: IO, stdout: IO, stderr: IO, wait_thr: Process::Waiter)
+                .returns([IO, IO, IO, Process::Waiter]),
+            ),
+          )
+            .returns([IO, IO, IO, Process::Waiter])
+        end
+        def popen3(cmd, *args, sudo: false, env: ENV.to_h, **kwargs, &block)
+          delegate_open3(cmd, args, kwargs, sudo: sudo, env: env, method: :popen3, &block)
         end
 
         # Execute a command in the user's environment
@@ -100,27 +189,50 @@ 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')`
         #
-        def system(*a, sudo: false, env: ENV, **kwargs)
-          a = apply_sudo(*a, sudo)
+        sig do
+          params(
+            cmd: String,
+            args: String,
+            sudo: T.any(T::Boolean, String),
+            env: T::Hash[String, T.nilable(String)],
+            stdin: T.nilable(T.any(IO, String, Integer, Symbol)),
+            kwargs: T.untyped,
+            block: T.nilable(T.proc.params(out: String, err: String).void),
+          )
+            .returns(Process::Status)
+        end
+        def system(cmd, *args, sudo: false, env: ENV.to_h, stdin: nil, **kwargs, &block)
+          cmd, args = apply_sudo(cmd, args, sudo)
 
           out_r, out_w = IO.pipe
           err_r, err_w = IO.pipe
-          in_stream = STDIN.closed? ? :close : STDIN
-          pid = Process.spawn(env, *resolve_path(a, env), 0 => in_stream, :out => out_w, :err => err_w, **kwargs)
+          in_stream = if stdin
+            stdin
+          elsif STDIN.closed?
+            :close
+          else
+            STDIN
+          end
+          cmd, args = resolve_path(cmd, args, env)
+          pid = T.unsafe(Process).spawn(env, cmd, *args, 0 => in_stream, :out => out_w, :err => err_w, **kwargs)
           out_w.close
           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('')
@@ -129,14 +241,12 @@ module CLI
             break if ios.empty?
 
             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
+            (readers || []).each do |io|
+              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
 
@@ -147,35 +257,94 @@ module CLI
         # Split off trailing partial UTF-8 Characters. UTF-8 Multibyte characters start with a 11xxxxxx byte that tells
         # how many following bytes are part of this character, followed by some number of 10xxxxxx bytes.  This simple
         # algorithm will split off a whole trailing multi-byte character.
+        sig { params(data: String).returns([String, String]) }
         def split_partial_characters(data)
-          last_byte = data.getbyte(-1)
+          last_byte = T.must(data.getbyte(-1))
           return [data, ''] if (last_byte & 0b1000_0000).zero?
 
-          # UTF-8 is up to 6 characters per rune, so we could never want to trim more than that, and we want to avoid
+          # UTF-8 is up to 4 characters per rune, so we could never want to trim more than that, and we want to avoid
           # allocating an array for the whole of data with bytes
-          min_bound = -[6, data.bytesize].min
-          final_bytes = data.byteslice(min_bound..-1).bytes
+          min_bound = -[4, data.bytesize].min
+          final_bytes = T.must(data.byteslice(min_bound..-1)).bytes
           partial_character_sub_index = final_bytes.rindex { |byte| byte & 0b1100_0000 == 0b1100_0000 }
+
           # Bail out for non UTF-8
           return [data, ''] unless partial_character_sub_index
+
+          start_byte = final_bytes[partial_character_sub_index]
+          full_size = if start_byte & 0b1111_1000 == 0b1111_0000
+            4
+          elsif start_byte & 0b1111_0000 == 0b1110_0000
+            3
+          elsif start_byte & 0b1110_0000 == 0b110_00000
+            2
+          else
+            nil # Not a valid UTF-8 character
+          end
+          return [data, ''] if full_size.nil? # Bail out for non UTF-8
+
+          if final_bytes.size - partial_character_sub_index == full_size
+            # We have a full UTF-8 character, so we can just return the data
+            return [data, '']
+          end
+
           partial_character_index = min_bound + partial_character_sub_index
 
-          [data.byteslice(0...partial_character_index), data.byteslice(partial_character_index..-1)]
+          [T.must(data.byteslice(0...partial_character_index)), T.must(data.byteslice(partial_character_index..-1))]
+        end
+
+        sig { returns(Symbol) }
+        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
+
+        sig { params(cmd: String, env: T::Hash[String, T.nilable(String)]).returns(T.nilable(String)) }
+        def which(cmd, env)
+          exts = os == :windows ? (env['PATHEXT'] || 'exe').split(';') : ['']
+          (env['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
 
         private
 
-        def apply_sudo(*a, sudo)
-          a.unshift('sudo', '-S', '-p', SUDO_PROMPT, '--') if sudo
+        sig do
+          params(cmd: String, args: T::Array[String], sudo: T.any(T::Boolean, String))
+            .returns([String, T::Array[String]])
+        end
+        def apply_sudo(cmd, args, sudo)
+          return [cmd, args] unless sudo
+
           sudo_reason(sudo) if sudo.is_a?(String)
-          a
+          ['sudo', args.unshift('-E', '-S', '-p', SUDO_PROMPT, '--', cmd)]
         end
 
-        def delegate_open3(*a, sudo: raise, env: raise, method: raise, **kwargs)
-          a = apply_sudo(*a, sudo)
-          Open3.send(method, env, *resolve_path(a, env), **kwargs)
+        sig do
+          params(
+            cmd: String,
+            args: T::Array[String],
+            kwargs: T::Hash[Symbol, T.untyped],
+            sudo: T.any(T::Boolean, String),
+            env: T::Hash[String, T.nilable(String)],
+            method: Symbol,
+            block: T.untyped,
+          ).returns(T.untyped)
+        end
+        def delegate_open3(cmd, args, kwargs, sudo: raise, env: raise, method: raise, &block)
+          cmd, args = apply_sudo(cmd, args, sudo)
+          cmd, args = resolve_path(cmd, args, env)
+          T.unsafe(Open3).send(method, env, cmd, *args, **kwargs, &block)
         rescue Errno::EINTR
-          raise(Errno::EINTR, "command interrupted: #{a.join(' ')}")
+          raise(Errno::EINTR, "command interrupted: #{cmd} #{args.join(" ")}")
         end
 
         # Ruby resolves the program to execute using its own PATH, but we want it to
@@ -187,19 +356,19 @@ module CLI
         # project.
         #
         # See https://github.com/Shopify/dev/pull/625 for more details.
-        def resolve_path(a, env)
+        sig do
+          params(cmd: String, args: T::Array[String], env: T::Hash[String, T.nilable(String)])
+            .returns([String, T::Array[String]])
+        end
+        def resolve_path(cmd, args, 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?('/')
-
-          paths = env.fetch('PATH', '').split(':')
-          item = paths.detect do |f|
-            command_path = "#{f}/#{a.first}"
-            File.executable?(command_path) && File.file?(command_path)
+          if args.empty?
+            prefix = os == :windows ? 'break && ' : 'true ; '
+            return [prefix + cmd, []]
           end
+          return [cmd, args] if cmd.include?('/')
 
-          a[0] = "#{item}/#{a.first}" if item
-          a
+          [which(cmd, env) || cmd, args]
         end
       end
     end