cli-kit 5.0.1 → 5.2.0

data/lib/cli/kit/command_registry.rb

@@ -5,58 +5,60 @@ require 'cli/kit'
 module CLI
   module Kit
     class CommandRegistry
-      extend T::Sig
+      #: type command_or_proc = singleton(CLI::Kit::BaseCommand) | ^() -> singleton(CLI::Kit::BaseCommand)
 
-      CommandOrProc = T.type_alias do
-        T.any(T.class_of(CLI::Kit::BaseCommand), T.proc.returns(T.class_of(CLI::Kit::BaseCommand)))
-      end
-
-      sig { returns(T::Hash[String, CommandOrProc]) }
+      #: Hash[String, command_or_proc]
       attr_reader :commands
 
-      sig { returns(T::Hash[String, String]) }
+      #: Hash[String, String]
       attr_reader :aliases
 
+      # @interface
       module ContextualResolver
-        extend T::Sig
-        extend T::Helpers
-        interface!
-
-        sig { abstract.returns(T::Array[String]) }
-        def command_names; end
+        # @abstract
+        #: -> Array[String]
+        def command_names
+          raise(NotImplementedError)
+        end
 
-        sig { abstract.returns(T::Hash[String, String]) }
-        def aliases; end
+        # @abstract
+        #: -> Hash[String, String]
+        def aliases
+          raise(NotImplementedError)
+        end
 
-        sig { abstract.params(_name: String).returns(T.class_of(CLI::Kit::BaseCommand)) }
-        def command_class(_name); end
+        # @abstract
+        #: (String) -> singleton(CLI::Kit::BaseCommand)
+        def command_class(_name)
+          raise(NotImplementedError)
+        end
       end
 
       module NullContextualResolver
-        extend T::Sig
         extend ContextualResolver
 
         class << self
-          extend T::Sig
-
-          sig { override.returns(T::Array[String]) }
+          # @override
+          #: -> Array[String]
           def command_names
             []
           end
 
-          sig { override.returns(T::Hash[String, String]) }
+          # @override
+          #: -> Hash[String, String]
           def aliases
             {}
           end
 
-          sig { override.params(_name: String).returns(T.class_of(CLI::Kit::BaseCommand)) }
+          # @override
+          #: (String _name) -> singleton(CLI::Kit::BaseCommand)
           def command_class(_name)
             raise(CLI::Kit::Abort, 'Cannot be called on the NullContextualResolver since command_names is empty')
           end
         end
       end
 
-      sig { params(default: String, contextual_resolver: ContextualResolver).void }
+      #: (default: String, ?contextual_resolver: ContextualResolver) -> void
       def initialize(default:, contextual_resolver: NullContextualResolver)
         @commands = {}
         @aliases  = {}
@@ -64,47 +66,49 @@ module CLI
         @contextual_resolver = contextual_resolver
       end
 
-      sig { returns(T::Hash[String, T.class_of(CLI::Kit::BaseCommand)]) }
+      #: -> Hash[String, singleton(CLI::Kit::BaseCommand)]
       def resolved_commands
         @commands.each_with_object({}) do |(k, v), a|
           a[k] = resolve_class(v)
         end
       end
 
-      sig { params(const: CommandOrProc, name: String).void }
+      #: (command_or_proc const, String name) -> void
       def add(const, name)
         commands[name] = const
       end
 
-      sig { params(name: T.nilable(String)).returns([T.nilable(T.class_of(CLI::Kit::BaseCommand)), String]) }
+      #: (String? name) -> [singleton(CLI::Kit::BaseCommand)?, String]
       def lookup_command(name)
         name = @default if name.to_s.empty?
-        resolve_command(T.must(name))
+        resolve_command(
+          name, #: as !nil
+        )
       end
 
-      sig { params(from: String, to: String).void }
+      #: (String from, String to) -> void
       def add_alias(from, to)
         aliases[from] = to unless aliases[from]
       end
 
-      sig { returns(T::Array[String]) }
+      #: -> Array[String]
       def command_names
         @contextual_resolver.command_names + commands.keys
       end
 
-      sig { params(name: String).returns(T::Boolean) }
+      #: (String name) -> bool
       def exist?(name)
         !resolve_command(name).first.nil?
       end
 
       private
 
-      sig { params(name: String).returns(String) }
+      #: (String name) -> String
       def resolve_alias(name)
         aliases[name] || @contextual_resolver.aliases.fetch(name, name)
       end
 
-      sig { params(name: String).returns([T.nilable(T.class_of(CLI::Kit::BaseCommand)), String]) }
+      #: (String name) -> [singleton(CLI::Kit::BaseCommand)?, String]
       def resolve_command(name)
         name = resolve_alias(name)
         resolve_global_command(name) ||
@@ -112,7 +116,7 @@ module CLI
           [nil, name]
       end
 
-      sig { params(name: String).returns(T.nilable([T.class_of(CLI::Kit::BaseCommand), String])) }
+      #: (String name) -> [singleton(CLI::Kit::BaseCommand), String]?
       def resolve_global_command(name)
         klass = resolve_class(commands.fetch(name, nil))
         return unless klass
@@ -122,7 +126,7 @@ module CLI
         nil
       end
 
-      sig { params(name: String).returns(T.nilable([T.class_of(CLI::Kit::BaseCommand), String])) }
+      #: (String name) -> [singleton(CLI::Kit::BaseCommand), String]?
       def resolve_contextual_command(name)
         found = @contextual_resolver.command_names.include?(name)
         return unless found
@@ -130,7 +134,7 @@ module CLI
         [@contextual_resolver.command_class(name), name]
       end
 
-      sig { params(class_or_proc: T.nilable(CommandOrProc)).returns(T.nilable(T.class_of(CLI::Kit::BaseCommand))) }
+      #: (command_or_proc? class_or_proc) -> singleton(CLI::Kit::BaseCommand)?
       def resolve_class(class_or_proc)
         case class_or_proc
         when nil

data/lib/cli/kit/config.rb

@@ -6,11 +6,9 @@ require 'fileutils'
 module CLI
   module Kit
     class Config
-      extend T::Sig
-
       XDG_CONFIG_HOME = 'XDG_CONFIG_HOME'
 
-      sig { params(tool_name: String).void }
+      #: (tool_name: String) -> void
       def initialize(tool_name:)
         @tool_name = tool_name
       end
@@ -28,13 +26,13 @@ module CLI
       # #### Example Usage
       # `config.get('name.of.config')`
       #
-      sig { params(section: String, name: String, default: T.nilable(String)).returns(T.nilable(String)) }
+      #: (String section, String name, ?default: String?) -> String?
       def get(section, name, default: nil)
         all_configs.dig("[#{section}]", name) || default
       end
 
       # Coalesce and enforce the value of a config to a boolean
-      sig { params(section: String, name: String, default: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+      #: (String section, String name, ?default: bool?) -> bool?
       def get_bool(section, name, default: false)
         case get(section, name)
         when 'true'
@@ -58,14 +56,15 @@ module CLI
       # #### Example Usage
       # `config.set('section', 'name.of.config', 'value')`
       #
-      sig { params(section: String, name: String, value: T.nilable(T.any(String, T::Boolean))).void }
+      #: (String section, String name, (String | bool)? value) -> void
       def set(section, name, value)
         all_configs["[#{section}]"] ||= {}
+        section = all_configs["[#{section}]"] #: as !nil
         case value
         when nil
-          T.must(all_configs["[#{section}]"]).delete(name)
+          section.delete(name)
         else
-          T.must(all_configs["[#{section}]"])[name] = value.to_s
+          section[name] = value.to_s
         end
         write_config
       end
@@ -79,7 +78,7 @@ module CLI
       # #### Example Usage
       # `config.unset('section', 'name.of.config')`
       #
-      sig { params(section: String, name: String).void }
+      #: (String section, String name) -> void
       def unset(section, name)
         set(section, name, nil)
       end
@@ -92,12 +91,12 @@ module CLI
       # #### Example Usage
       # `config.get_section('section')`
       #
-      sig { params(section: String).returns(T::Hash[String, String]) }
+      #: (String section) -> Hash[String, String]
       def get_section(section)
         (all_configs["[#{section}]"] || {}).dup
       end
 
-      sig { returns(String) }
+      #: -> String
       def to_s
         ini.to_s
       end
@@ -107,7 +106,7 @@ module CLI
       # if ENV['XDG_CONFIG_HOME'] is not set, we default to ~/.config, e.g.:
       #   ~/.config/tool/config
       #
-      sig { returns(String) }
+      #: -> String
       def file
         config_home = ENV.fetch(XDG_CONFIG_HOME, '~/.config')
         File.expand_path(File.join(@tool_name, 'config'), config_home)
@@ -115,17 +114,17 @@ module CLI
 
       private
 
-      sig { returns(T::Hash[String, T::Hash[String, String]]) }
+      #: -> Hash[String, Hash[String, String]]
       def all_configs
         ini.ini
       end
 
-      sig { returns(CLI::Kit::Ini) }
+      #: -> CLI::Kit::Ini
       def ini
         @ini ||= CLI::Kit::Ini.new(file).tap(&:parse)
       end
 
-      sig { void }
+      #: -> void
       def write_config
         all_configs.each do |section, sub_config|
           all_configs.delete(section) if sub_config.empty?

data/lib/cli/kit/core_ext.rb

@@ -2,28 +2,26 @@
 # frozen_string_literal: true
 
 class Exception
-  extend(T::Sig)
-
   # You'd think instance variables @bug and @silent would work here. They
   # don't. I'm not sure why. If you, the reader, want to take some time to
   # figure it out, go ahead and refactor to that.
 
-  sig { returns(T::Boolean) }
+  #: -> bool
   def bug?
     true
   end
 
-  sig { returns(T::Boolean) }
+  #: -> bool
   def silent?
     false
   end
 
-  sig { params(bug: T::Boolean).void }
+  #: (?bool bug) -> void
   def bug!(bug = true)
     singleton_class.define_method(:bug?) { bug }
   end
 
-  sig { params(silent: T::Boolean).void }
+  #: (?bool silent) -> void
   def silent!(silent = true)
     singleton_class.define_method(:silent?) { silent }
   end

data/lib/cli/kit/error_handler.rb

@@ -6,23 +6,12 @@ require 'English'
 module CLI
   module Kit
     class ErrorHandler
-      extend T::Sig
+      #: type exception_reporter_or_proc = singleton(ExceptionReporter) | ^() -> singleton(ExceptionReporter)
 
-      ExceptionReporterOrProc = T.type_alias do
-        T.any(T.class_of(ExceptionReporter), T.proc.returns(T.class_of(ExceptionReporter)))
-      end
-
-      sig { params(override_exception_handler: T.proc.params(arg0: Exception).returns(Integer)).void }
+      #: ^(Exception arg0) -> Integer
       attr_writer :override_exception_handler
 
-      sig do
-        params(
-          log_file: T.nilable(String),
-          exception_reporter: ExceptionReporterOrProc,
-          tool_name: T.nilable(String),
-          dev_mode: T::Boolean,
-        ).void
-      end
+      #: (?log_file: String?, ?exception_reporter: exception_reporter_or_proc, ?tool_name: String?, ?dev_mode: bool) -> void
       def initialize(log_file: nil, exception_reporter: NullExceptionReporter, tool_name: nil, dev_mode: false)
         @log_file = log_file
         @exception_reporter_or_proc = exception_reporter
@@ -30,33 +19,28 @@ module CLI
         @dev_mode = dev_mode
       end
 
+      # @abstract
       class ExceptionReporter
-        extend T::Sig
-        extend T::Helpers
-        abstract!
-
         class << self
-          extend T::Sig
-
-          sig { abstract.params(exception: T.nilable(Exception), logs: T.nilable(String)).void }
-          def report(exception, logs = nil); end
+          # @abstract
+          #: (Exception?, ?String?) -> void
+          def report(exception, logs = nil)
+            raise(NotImplementedError)
+          end
         end
       end
 
       class NullExceptionReporter < ExceptionReporter
-        extend T::Sig
-
         class << self
-          extend T::Sig
-
-          sig { override.params(_exception: T.nilable(Exception), _logs: T.nilable(String)).void }
+          # @override
+          #: (Exception? _exception, ?String? _logs) -> void
           def report(_exception, _logs = nil)
             nil
           end
         end
       end
 
-      sig { params(block: T.proc.void).returns(Integer) }
+      #: { -> void } -> Integer
       def call(&block)
         # @at_exit_exception is set if handle_abort decides to submit an error.
         # $ERROR_INFO is set if we terminate because of a signal.
@@ -64,7 +48,7 @@ module CLI
         triage_all_exceptions(&block)
       end
 
-      sig { params(error: T.nilable(Exception)).void }
+      #: (Exception? error) -> void
       def report_exception(error)
         if (notify_with = exception_for_submission(error))
           logs = nil
@@ -92,7 +76,7 @@ module CLI
       # they're #bug?
       #
       # Returns an exit status for the program.
-      sig { params(block: T.proc.void).returns(Integer) }
+      #: { -> void } -> Integer
       def triage_all_exceptions(&block)
         begin
           block.call
@@ -130,12 +114,12 @@ module CLI
         e.bug? ? CLI::Kit::EXIT_BUG : CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG
       end
 
-      sig { params(error: T.nilable(Exception)).returns(T.nilable(Exception)) }
+      #: (Exception? error) -> Exception?
       def exception_for_submission(error)
         # happens on normal non-error termination
-        return(nil) if error.nil?
+        return if error.nil?
 
-        return(nil) unless error.bug?
+        return unless error.bug?
 
         case error
         when SignalException
@@ -161,14 +145,14 @@ module CLI
         end
       end
 
-      sig { params(message: String).void }
+      #: (String message) -> void
       def stderr_puts(message)
         $stderr.puts(CLI::UI.fmt("{{red:#{message}}}"))
       rescue Errno::EPIPE, Errno::EIO
         nil
       end
 
-      sig { returns(T.class_of(ExceptionReporter)) }
+      #: -> singleton(ExceptionReporter)
       def exception_reporter
         case @exception_reporter_or_proc
         when Proc

data/lib/cli/kit/executor.rb

@@ -7,15 +7,13 @@ require 'fileutils'
 module CLI
   module Kit
     class Executor
-      extend T::Sig
-
-      sig { params(log_file: String).void }
+      #: (log_file: String) -> void
       def initialize(log_file:)
         FileUtils.mkpath(File.dirname(log_file))
         @log_file = log_file
       end
 
-      sig { params(command: T.class_of(CLI::Kit::BaseCommand), command_name: String, args: T::Array[String]).void }
+      #: (singleton(CLI::Kit::BaseCommand) command, String command_name, Array[String] args) -> void
       def call(command, command_name, args)
         with_traps do
           with_logging do |id|
@@ -36,10 +34,7 @@ module CLI
 
       private
 
-      sig do
-        type_parameters(:T).params(block: T.proc.params(id: String).returns(T.type_parameter(:T)))
-          .returns(T.type_parameter(:T))
-      end
+      #: [T] { (String id) -> T } -> T
       def with_logging(&block)
         CLI::UI.log_output_to(@log_file) do
           CLI::UI::StdoutRouter.with_id(on_streams: [CLI::UI::StdoutRouter.duplicate_output_to].compact) do |id|
@@ -48,18 +43,14 @@ module CLI
         end
       end
 
-      sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+      #: [T] { -> T } -> T
       def with_traps(&block)
         twrap('QUIT', method(:quit_handler)) do
           twrap('INFO', method(:info_handler), &block)
         end
       end
 
-      sig do
-        type_parameters(:T)
-          .params(signal: String, handler: Method, block: T.proc.returns(T.type_parameter(:T)))
-          .returns(T.type_parameter(:T))
-      end
+      #: [T] (String signal, Method handler) { -> T } -> T
       def twrap(signal, handler, &block)
         return yield unless Signal.list.key?(signal)
 
@@ -78,7 +69,7 @@ module CLI
         end
       end
 
-      sig { params(_sig: T.untyped).void }
+      #: (untyped _sig) -> void
       def quit_handler(_sig)
         z = caller
         CLI::UI.raw do
@@ -88,7 +79,7 @@ module CLI
         exit(CLI::Kit::EXIT_FAILURE_BUT_NOT_BUG)
       end
 
-      sig { params(_sig: T.untyped).void }
+      #: (untyped _sig) -> void
       def info_handler(_sig)
         z = caller
         CLI::UI.raw do

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 != ''