cli-kit 5.1.0 → 5.3.0

data/lib/cli/kit/ini.rb

@@ -17,14 +17,10 @@ module CLI
     # See the ini_test.rb file for more examples
     #
     class Ini
-      extend T::Sig
-
-      sig { returns(T::Hash[String, T::Hash[String, String]]) }
+      #: Hash[String, Hash[String, String]]
       attr_accessor :ini
 
-      sig do
-        params(path: T.nilable(String), config: T.nilable(String), default_section: String).void
-      end
+      #: (?String? path, ?config: String?, ?default_section: String) -> void
       def initialize(path = nil, config: nil, default_section: '[global]')
         @config = if path && File.exist?(path)
           File.readlines(path)
@@ -35,7 +31,7 @@ module CLI
         @current_key = default_section
       end
 
-      sig { returns(T::Hash[String, T::Hash[String, String]]) }
+      #: -> Hash[String, Hash[String, String]]
       def parse
         return @ini if @config.nil?
 
@@ -53,19 +49,19 @@ module CLI
         @ini
       end
 
-      sig { returns(String) }
+      #: -> String
       def git_format
         to_ini(git_format: true)
       end
 
-      sig { returns(String) }
+      #: -> String
       def to_s
         to_ini
       end
 
       private
 
-      sig { params(git_format: T::Boolean).returns(String) }
+      #: (?git_format: bool) -> String
       def to_ini(git_format: false)
         optional_tab = git_format ? "\t" : ''
         str = []
@@ -79,14 +75,14 @@ module CLI
         str.join("\n")
       end
 
-      sig { params(key: String, val: String).void }
+      #: (String key, String val) -> void
       def set_val(key, val)
         current_key = @current_key
         @ini[current_key] ||= {}
         @ini[current_key][key] = val
       end
 
-      sig { params(k: String).returns(T::Boolean) }
+      #: (String k) -> bool
       def section_designator?(k)
         k.start_with?('[') && k.end_with?(']')
       end

data/lib/cli/kit/levenshtein.rb

@@ -28,13 +28,13 @@ require 'cli/kit'
 module CLI
   module Kit
     module Levenshtein
-      extend T::Sig
+      
 
       # This code is based directly on the Text gem implementation
       # Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher.
       #
       # Returns a value representing the "cost" of transforming str1 into str2
-      sig { params(str1: String, str2: String).returns(Integer) }
+      #: (String str1, String str2) -> Integer
       def distance(str1, str2)
         n = str1.length
         m = str2.length
@@ -51,10 +51,12 @@ module CLI
           j = 0
           while j < m
             cost = char1 == str2_codepoints[j] ? 0 : 1
+            a = d[j] #: as !nil
+            b = d[j + 1] #: as !nil
             x = min3(
-              T.must(d[j + 1]) + 1, # insertion
+              b + 1,
               i + 1, # deletion
-              T.must(d[j]) + cost, # substitution
+              a + cost, # substitution
             )
             d[j] = i
             i = x
@@ -74,7 +76,7 @@ module CLI
       # faster than `[a, b, c].min` and puts less GC pressure.
       # See https://github.com/yuki24/did_you_mean/pull/1 for a performance
       # benchmark.
-      sig { params(a: Integer, b: Integer, c: Integer).returns(Integer) }
+      #: (Integer a, Integer b, Integer c) -> Integer
       def min3(a, b, c)
         if a < b && a < c
           a

data/lib/cli/kit/logger.rb

@@ -7,15 +7,13 @@ require 'fileutils'
 module CLI
   module Kit
     class Logger
-      extend T::Sig
-
       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
-      sig { params(debug_log_file: String, env_debug_name: String).void }
+      #: (debug_log_file: String, ?env_debug_name: String) -> void
       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)
@@ -27,7 +25,7 @@ module CLI
       #
       # @param msg [String] the message to log
       # @param debug [Boolean] determines if the debug logger will receive the log (default true)
-      sig { params(msg: String, debug: T::Boolean).void }
+      #: (String msg, ?debug: bool) -> void
       def info(msg, debug: true)
         $stdout.puts CLI::UI.fmt(msg)
         @debug_logger.info(format_debug(msg)) if debug
@@ -38,7 +36,7 @@ module CLI
       #
       # @param msg [String] the message to log
       # @param debug [Boolean] determines if the debug logger will receive the log (default true)
-      sig { params(msg: String, debug: T::Boolean).void }
+      #: (String msg, ?debug: bool) -> void
       def warn(msg, debug: true)
         $stdout.puts CLI::UI.fmt("{{yellow:#{msg}}}")
         @debug_logger.warn(format_debug(msg)) if debug
@@ -49,7 +47,7 @@ module CLI
       #
       # @param msg [String] the message to log
       # @param debug [Boolean] determines if the debug logger will receive the log (default true)
-      sig { params(msg: String, debug: T::Boolean).void }
+      #: (String msg, ?debug: bool) -> void
       def error(msg, debug: true)
         $stderr.puts CLI::UI.fmt("{{red:#{msg}}}")
         @debug_logger.error(format_debug(msg)) if debug
@@ -60,7 +58,7 @@ module CLI
       #
       # @param msg [String] the message to log
       # @param debug [Boolean] determines if the debug logger will receive the log (default true)
-      sig { params(msg: String, debug: T::Boolean).void }
+      #: (String msg, ?debug: bool) -> void
       def fatal(msg, debug: true)
         $stderr.puts CLI::UI.fmt("{{red:{{bold:Fatal:}} #{msg}}}")
         @debug_logger.fatal(format_debug(msg)) if debug
@@ -70,7 +68,7 @@ module CLI
       # Logs to the debug file, taking into account CLI::UI::StdoutRouter.current_id
       #
       # @param msg [String] the message to log
-      sig { params(msg: String).void }
+      #: (String msg) -> void
       def debug(msg)
         $stdout.puts CLI::UI.fmt(msg) if debug?
         @debug_logger.debug(format_debug(msg))
@@ -78,7 +76,7 @@ module CLI
 
       private
 
-      sig { params(msg: String).returns(String) }
+      #: (String msg) -> String
       def format_debug(msg)
         msg = CLI::UI.fmt(msg)
         return msg unless CLI::UI::StdoutRouter.current_id
@@ -86,7 +84,7 @@ module CLI
         "[#{CLI::UI::StdoutRouter.current_id&.fetch(:id, nil)}] #{msg}"
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def debug?
         val = ENV[@env_debug_name]
         !!val && val != '0' && val != ''

data/lib/cli/kit/opts.rb

@@ -5,16 +5,11 @@ require 'cli/kit'
 module CLI
   module Kit
     class Opts
-      extend T::Sig
-
       module Mixin
-        extend T::Sig
         include Kernel
 
         module MixinClassMethods
-          extend T::Sig
-
-          sig { params(included_module: Module).void }
+          #: (Module included_module) -> void
           def include(included_module)
             super
             return unless included_module.is_a?(MixinClassMethods)
@@ -28,36 +23,26 @@ module CLI
             track_method(method_name)
           end
 
-          sig { params(method_name: Symbol).void }
+          #: (Symbol method_name) -> void
           def track_method(method_name)
             @tracked_methods ||= []
             @tracked_methods << method_name unless @tracked_methods.include?(method_name)
           end
 
-          sig { returns(T::Array[Symbol]) }
+          #: -> Array[Symbol]
           def tracked_methods
             @tracked_methods || []
           end
         end
 
         class << self
-          extend T::Sig
-
-          sig { params(klass: Module).void }
+          #: (Module klass) -> void
           def included(klass)
             klass.extend(MixinClassMethods)
           end
         end
 
-        sig do
-          params(
-            name: Symbol,
-            short: T.nilable(String),
-            long: T.nilable(String),
-            desc: T.nilable(String),
-            default: T.any(NilClass, String, T.proc.returns(String)),
-          ).returns(T.nilable(String))
-        end
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?, ?default: (String | ^-> String)?) -> String?
         def option(name: infer_name, short: nil, long: nil, desc: nil, default: nil)
           unless default.nil?
             raise(ArgumentError, 'declare options with non-nil defaults using `option!` instead of `option`')
@@ -74,15 +59,7 @@ module CLI
           end
         end
 
-        sig do
-          params(
-            name: Symbol,
-            short: T.nilable(String),
-            long: T.nilable(String),
-            desc: T.nilable(String),
-            default: T.any(NilClass, String, T.proc.returns(String)),
-          ).returns(String)
-        end
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?, ?default: (String | ^-> String)?) -> String
         def option!(name: infer_name, short: nil, long: nil, desc: nil, default: nil)
           case @obj
           when Args::Definition
@@ -95,15 +72,7 @@ module CLI
           end
         end
 
-        sig do
-          params(
-            name: Symbol,
-            short: T.nilable(String),
-            long: T.nilable(String),
-            desc: T.nilable(String),
-            default: T.any(T::Array[String], T.proc.returns(T::Array[String])),
-          ).returns(T::Array[String])
-        end
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?, ?default: (Array[String] | ^-> Array[String])) -> Array[String]
         def multi_option(name: infer_name, short: nil, long: nil, desc: nil, default: [])
           case @obj
           when Args::Definition
@@ -116,14 +85,7 @@ module CLI
           end
         end
 
-        sig do
-          params(
-            name: Symbol,
-            short: T.nilable(String),
-            long: T.nilable(String),
-            desc: T.nilable(String),
-          ).returns(T::Boolean)
-        end
+        #: (?name: Symbol, ?short: String?, ?long: String?, ?desc: String?) -> bool
         def flag(name: infer_name, short: nil, long: nil, desc: nil)
           case @obj
           when Args::Definition
@@ -134,7 +96,7 @@ module CLI
           end
         end
 
-        sig { params(name: Symbol, desc: T.nilable(String)).returns(String) }
+        #: (?name: Symbol, ?desc: String?) -> String
         def position!(name: infer_name, desc: nil)
           case @obj
           when Args::Definition
@@ -145,18 +107,7 @@ module CLI
           end
         end
 
-        sig do
-          params(
-            name: Symbol,
-            desc: T.nilable(String),
-            default: T.any(NilClass, String, T.proc.returns(String)),
-            skip: T.any(
-              NilClass,
-              T.proc.returns(T::Boolean),
-              T.proc.params(arg0: String).returns(T::Boolean),
-            ),
-          ).returns(T.nilable(String))
-        end
+        #: (?name: Symbol, ?desc: String?, ?default: (String | ^-> String)?, ?skip: (^-> bool | ^(String arg0) -> bool)?) -> String?
         def position(name: infer_name, desc: nil, default: nil, skip: nil)
           case @obj
           when Args::Definition
@@ -167,7 +118,7 @@ module CLI
           end
         end
 
-        sig { params(name: Symbol, desc: T.nilable(String)).returns(T::Array[String]) }
+        #: (?name: Symbol, ?desc: String?) -> Array[String]
         def rest(name: infer_name, desc: nil)
           case @obj
           when Args::Definition
@@ -180,14 +131,14 @@ module CLI
 
         private
 
-        sig { params(label: T.nilable(String)).returns(T.nilable(Symbol)) }
+        #: (String? label) -> Symbol?
         def symbolize(label)
           return if label.nil?
 
           label.split('#').last&.to_sym
         end
 
-        sig { returns(Symbol) }
+        #: -> Symbol
         def infer_name
           to_skip = 1
           Kernel.caller_locations.each do |loc|
@@ -197,7 +148,7 @@ module CLI
               to_skip -= 1
               next
             end
-            return T.must(symbolize(loc.label))
+            return symbolize(loc.label) #: as !nil
           end
           raise(ArgumentError, 'could not infer name')
         end
@@ -206,24 +157,18 @@ module CLI
 
       DEFAULT_OPTIONS = [:helpflag]
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def helpflag
         flag(name: :help, short: '-h', long: '--help', desc: 'Show this help message')
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def unparsed
         obj = assert_result!
         obj.unparsed
       end
 
-      sig do
-        params(
-          block: T.nilable(
-            T.proc.params(arg0: Symbol, arg1: T.nilable(String)).void,
-          ),
-        ).returns(T.untyped)
-      end
+      #: ?{ (Symbol arg0, String? arg1) -> void } -> untyped
       def each_option(&block)
         return enum_for(:each_option) unless block_given?
 
@@ -235,13 +180,7 @@ module CLI
         end
       end
 
-      sig do
-        params(
-          block: T.nilable(
-            T.proc.params(arg0: Symbol, arg1: T::Boolean).void,
-          ),
-        ).returns(T.untyped)
-      end
+      #: ?{ (Symbol arg0, bool arg1) -> void } -> untyped
       def each_flag(&block)
         return enum_for(:each_flag) unless block_given?
 
@@ -253,7 +192,7 @@ module CLI
         end
       end
 
-      sig { params(name: String).returns(T.nilable(T.any(String, T::Boolean))) }
+      #: (String name) -> (String | bool)?
       def [](name)
         obj = assert_result!
         if obj.opt.respond_to?(name)
@@ -263,7 +202,7 @@ module CLI
         end
       end
 
-      sig { params(name: String).returns(T.nilable(String)) }
+      #: (String name) -> String?
       def lookup_option(name)
         obj = assert_result!
         obj.opt.send(name)
@@ -272,7 +211,7 @@ module CLI
         nil
       end
 
-      sig { params(name: String).returns(T::Boolean) }
+      #: (String name) -> bool
       def lookup_flag(name)
         obj = assert_result!
         obj.flag.send(name)
@@ -280,17 +219,18 @@ module CLI
         false
       end
 
-      sig { returns(Args::Evaluation) }
+      #: -> Args::Evaluation
       def assert_result!
         raise(NotImplementedError, 'not implemented') if @obj.is_a?(Args::Definition)
 
         @obj
       end
 
-      sig { params(defn: Args::Definition).void }
+      #: (Args::Definition defn) -> void
       def define!(defn)
         @obj = defn
-        T.cast(self.class, Mixin::MixinClassMethods).tracked_methods.each do |m|
+        klass = self.class #: as Mixin::MixinClassMethods
+        klass.tracked_methods.each do |m|
           send(m)
         end
         DEFAULT_OPTIONS.each do |m|
@@ -298,7 +238,7 @@ module CLI
         end
       end
 
-      sig { params(ev: Args::Evaluation).void }
+      #: (Args::Evaluation ev) -> void
       def evaluate!(ev)
         @obj = ev
         ev.resolve_positions!

data/lib/cli/kit/parse_args.rb

@@ -6,18 +6,12 @@ module CLI
       # because sorbet type-checking takes the pedantic route that module doesn't include Kernel, therefore
       # this is necessary (even tho it's ~probably fine~)
       include Kernel
-      extend T::Sig
 
-      # T.untyped is used in two places. The interpretation of dynamic values from the provided `opts`
+      # untyped is used in two places. The interpretation of dynamic values from the provided `opts`
       # and the resulting args[:opts] is pretty broad. There seems to be minimal value in expressing a
-      # tighter subset of T.untyped.
+      # tighter subset of untyped.
 
-      sig do
-        params(
-          args: T.any(Array, String),
-          opts_defn: T::Hash[Symbol, T::Array[T.untyped]],
-        ).returns(T::Hash[Symbol, T.untyped])
-      end
+      #: ((Array | String) args, Hash[Symbol, Array[untyped]] opts_defn) -> Hash[Symbol, untyped]
       def parse_args(args, opts_defn)
         start_opts, parser_config = opts_defn.reduce([{}, []]) do |(ini, pcfg), (n, cfg)|
           (vals, desc, short, klass) = cfg
@@ -38,7 +32,8 @@ module CLI
             long = "--#{n.to_s.tr("_", "-")}" + (mark.nil? ? '' : " #{mark}")
             opt_args = klass.nil? ? [short, long, desc] : [short, long, klass, desc]
 
-            T.unsafe(opt_p).on(*opt_args) do |v|
+            unsafe_opt_p = opt_p #: as untyped
+            unsafe_opt_p.on(*opt_args) do |v|
               acc_opts[n] = if acc_opts.key?(n)
                 Array(acc_opts[n]) + Array(v || def_val)
               else

data/lib/cli/kit/resolver.rb

@@ -5,15 +5,13 @@ require 'cli/kit'
 module CLI
   module Kit
     class Resolver
-      extend T::Sig
-
-      sig { params(tool_name: String, command_registry: CLI::Kit::CommandRegistry).void }
+      #: (tool_name: String, command_registry: CLI::Kit::CommandRegistry) -> void
       def initialize(tool_name:, command_registry:)
         @tool_name = tool_name
         @command_registry = command_registry
       end
 
-      sig { params(args: T::Array[String]).returns([T.class_of(CLI::Kit::BaseCommand), String, T::Array[String]]) }
+      #: (Array[String] args) -> [singleton(CLI::Kit::BaseCommand), String, Array[String]]
       def call(args)
         args = args.dup
         command_name = args.shift
@@ -30,7 +28,7 @@ module CLI
 
       private
 
-      sig { params(name: T.nilable(String)).void }
+      #: (String? name) -> void
       def command_not_found(name)
         CLI::UI::Frame.open('Command not found', color: :red, timing: false) do
           $stderr.puts(CLI::UI.fmt("{{command:#{@tool_name} #{name}}} was not found"))
@@ -59,7 +57,7 @@ module CLI
         end
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def commands_and_aliases
         @command_registry.command_names + @command_registry.aliases.keys
       end

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

@@ -14,7 +14,8 @@ module CLI
           CLI::Kit::System.reset!
           # 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?
+          uself = self #: as untyped
+          uself.assert(false, errors) if should_raise && !errors.nil?
           errors
         end
 
@@ -67,7 +68,8 @@ module CLI
 
                   # Otherwise handle the command
                   if expected_command[:allow]
-                    T.unsafe(self).original_system(*a, sudo: sudo, env: env, **kwargs)
+                    uself = self #: as untyped
+                    uself.original_system(*a, sudo: sudo, env: env, **kwargs)
                   else
                     FakeSuccess.new(expected_command[:success])
                   end
@@ -83,7 +85,8 @@ module CLI
 
                   # Otherwise handle the command
                   if expected_command[:allow]
-                    T.unsafe(self).original_capture2(*a, sudo: sudo, env: env, **kwargs)
+                    uself = self #: as untyped
+                    uself.original_capture2(*a, sudo: sudo, env: env, **kwargs)
                   else
                     [
                       expected_command[:stdout],
@@ -102,7 +105,8 @@ module CLI
 
                   # Otherwise handle the command
                   if expected_command[:allow]
-                    T.unsafe(self).original_capture2e(*a, sudo: sudo, env: env, **kwargs)
+                    uself = self #: as untyped
+                    uself.original_capture2e(*a, sudo: sudo, env: env, **kwargs)
                   else
                     [
                       expected_command[:stdout],
@@ -121,7 +125,8 @@ module CLI
 
                   # Otherwise handle the command
                   if expected_command[:allow]
-                    T.unsafe(self).original_capture3(*a, sudo: sudo, env: env, **kwargs)
+                    uself = self #: as untyped
+                    uself.original_capture3(*a, sudo: sudo, env: env, **kwargs)
                   else
                     [
                       expected_command[:stdout],