cli-kit 5.1.0 → 5.2.0

data/lib/cli/kit/args/parser/node.rb

@@ -7,27 +7,23 @@ module CLI
     module Args
       class Parser
         class Node
-          extend T::Sig
-
-          sig { void }
+          #: -> void
           def initialize
           end
 
-          sig { params(other: T.untyped).returns(T::Boolean) }
+          #: (untyped other) -> bool
           def ==(other)
             self.class == other.class
           end
 
           class Option < Node
-            extend T::Sig
-
-            sig { returns(String) }
+            #: String
             attr_reader :name
 
-            sig { returns(String) }
+            #: String
             attr_reader :value
 
-            sig { params(name: String, value: String).void }
+            #: (String name, String value) -> void
             def initialize(name, value)
               @name = name
               @value = value
@@ -35,12 +31,12 @@ module CLI
             end
             private_class_method(:new) # don't instantiate this class directly
 
-            sig { returns(String) }
+            #: -> String
             def inspect
               "#<#{self.class.name} #{@name}=#{@value}>"
             end
 
-            sig { params(other: T.untyped).returns(T::Boolean) }
+            #: (untyped other) -> bool
             def ==(other)
               !!(super(other) && @value == other.value && @name == other.name)
             end
@@ -55,22 +51,22 @@ module CLI
           end
 
           class Flag < Node
-            sig { returns(String) }
+            #: String
             attr_reader :value
 
-            sig { params(value: String).void }
+            #: (String value) -> void
             def initialize(value)
               @value = value
               super()
             end
             private_class_method(:new) # don't instantiate this class directly
 
-            sig { returns(String) }
+            #: -> String
             def inspect
               "#<#{self.class.name} #{@value}>"
             end
 
-            sig { params(other: T.untyped).returns(T::Boolean) }
+            #: (untyped other) -> bool
             def ==(other)
               !!(super(other) && @value == other.value)
             end
@@ -85,42 +81,42 @@ module CLI
           end
 
           class Argument < Node
-            sig { returns(String) }
+            #: String
             attr_reader :value
 
-            sig { params(value: String).void }
+            #: (String value) -> void
             def initialize(value)
               @value = value
               super()
             end
 
-            sig { returns(String) }
+            #: -> String
             def inspect
               "#<#{self.class.name} #{@value}>"
             end
 
-            sig { params(other: T.untyped).returns(T::Boolean) }
+            #: (untyped other) -> bool
             def ==(other)
               !!(super(other) && @value == other.value)
             end
           end
 
           class Unparsed < Node
-            sig { returns(T::Array[String]) }
+            #: Array[String]
             attr_reader :value
 
-            sig { params(value: T::Array[String]).void }
+            #: (Array[String] value) -> void
             def initialize(value)
               @value = value
               super()
             end
 
-            sig { returns(String) }
+            #: -> String
             def inspect
               "#<#{self.class.name} #{@value.join(" ")}>"
             end
 
-            sig { params(other: T.untyped).returns(T::Boolean) }
+            #: (untyped other) -> bool
             def ==(other)
               !!(super(other) && @value == other.value)
             end

data/lib/cli/kit/args/parser.rb

@@ -6,32 +6,28 @@ module CLI
   module Kit
     module Args
       class Parser
-        extend T::Sig
-
         autoload :Node, 'cli/kit/args/parser/node'
 
         Error = Class.new(Args::Error)
 
         class InvalidOptionError < Error
-          extend T::Sig
-          sig { params(option: String).void }
+          #: (String option) -> void
           def initialize(option)
             super("invalid option -- '#{option}'")
           end
         end
 
         class OptionRequiresAnArgumentError < Error
-          extend T::Sig
-          sig { params(option: String).void }
+          #: (String option) -> void
           def initialize(option)
             super("option requires an argument -- '#{option}'")
           end
         end
 
-        sig { params(tokens: T::Array[Tokenizer::Token]).returns(T::Array[Node]) }
+        #: (Array[Tokenizer::Token] tokens) -> Array[Node]
         def parse(tokens)
-          nodes = T.let([], T::Array[Node])
-          args = T.let(tokens, T::Array[T.nilable(Tokenizer::Token)])
+          nodes = [] #: Array[Node]
+          args = tokens #: Array[Tokenizer::Token?]
           args << nil # to make each_cons pass (args.last, nil) on the final round.
           state = :init
           # TODO: test that "--height -- 3" is parsed correctly.
@@ -40,7 +36,10 @@ module CLI
             when :skip
               state = :init
             when :init
-              state, val = parse_token(T.must(arg), next_arg)
+              state, val = parse_token(
+                arg, #: as !nil
+                next_arg,
+              )
               nodes << val
             when :unparsed
               unless arg.is_a?(Tokenizer::Token::UnparsedArgument)
@@ -60,17 +59,14 @@ module CLI
           nodes
         end
 
-        sig { params(definition: Definition).void }
+        #: (Definition definition) -> void
         def initialize(definition)
           @defn = definition
         end
 
         private
 
-        sig do
-          params(token: Tokenizer::Token, next_token: T.nilable(Tokenizer::Token))
-            .returns([Symbol, Parser::Node])
-        end
+        #: (Tokenizer::Token token, Tokenizer::Token? next_token) -> [Symbol, Parser::Node]
         def parse_token(token, next_token)
           case token
           when Tokenizer::Token::LongOptionName
@@ -104,7 +100,7 @@ module CLI
           end
         end
 
-        sig { params(arg: Tokenizer::Token::OptionName, next_arg: T.nilable(Tokenizer::Token)).returns(Node) }
+        #: (Tokenizer::Token::OptionName arg, Tokenizer::Token? next_arg) -> Node
         def parse_option(arg, next_arg)
           case next_arg
           when nil, Tokenizer::Token::LongOptionName,

data/lib/cli/kit/args/tokenizer.rb

@@ -6,43 +6,37 @@ module CLI
   module Kit
     module Args
       module Tokenizer
-        extend T::Sig
-
         Error = Class.new(Args::Error)
 
         class InvalidShortOption < Error
-          extend T::Sig
-          sig { params(short_option: String).void }
+          #: (String short_option) -> void
           def initialize(short_option)
             super("invalid short option: '-#{short_option}'")
           end
         end
 
         class InvalidCharInShortOption < Error
-          extend T::Sig
-          sig { params(short_option: String, char: String).void }
+          #: (String short_option, String char) -> void
           def initialize(short_option, char)
             super("invalid character '#{char}' in short option: '-#{short_option}'")
           end
         end
 
         class Token
-          extend T::Sig
-
-          sig { returns(String) }
+          #: String
           attr_reader :value
 
-          sig { params(value: String).void }
+          #: (String value) -> void
           def initialize(value)
             @value = value
           end
 
-          sig { returns(String) }
+          #: -> String
           def inspect
             "#<#{self.class.name} #{@value}>"
           end
 
-          sig { params(other: T.untyped).returns(T::Boolean) }
+          #: (untyped other) -> bool
           def ==(other)
             self.class == other.class && @value == other.value
           end
@@ -58,9 +52,7 @@ module CLI
         end
 
         class << self
-          extend T::Sig
-
-          sig { params(raw_args: T::Array[String]).returns(T::Array[Token]) }
+          #: (Array[String] raw_args) -> Array[Token]
           def tokenize(raw_args)
             args = []
 
@@ -76,12 +68,17 @@ module CLI
                   mode = :unparsed
                 when /\A--./
                   name, value = arg.split('=', 2)
-                  args << Token::LongOptionName.new(T.must(T.must(name)[2..-1]))
+                  name = name #: as !nil
+                  args << Token::LongOptionName.new(
+                    name[2..-1], #: as !nil
+                  )
                   if value
                     args << Token::OptionValue.new(value)
                   end
                 when /\A-./
-                  args.concat(tokenize_short_option(T.must(arg[1..-1])))
+                  args.concat(tokenize_short_option(
+                    arg[1..-1], #: as !nil
+                  ))
                 else
                   args << if args.last.is_a?(Token::OptionName)
                     Token::OptionValueOrPositionalArgument.new(arg)
@@ -95,7 +92,7 @@ module CLI
             args
           end
 
-          sig { params(arg: String).returns(T::Array[Token]) }
+          #: (String arg) -> Array[Token]
           def tokenize_short_option(arg)
             args = []
             mode = :init

data/lib/cli/kit/base_command.rb

@@ -4,28 +4,24 @@ require 'cli/kit'
 
 module CLI
   module Kit
+    # @abstract
     class BaseCommand
-      extend T::Sig
-      extend T::Helpers
       include CLI::Kit::CommandHelp
       extend CLI::Kit::CommandHelp::ClassMethods
-      abstract!
 
       class << self
-        extend T::Sig
-
-        sig { returns(T::Boolean) }
+        #: -> bool
         def defined?
           true
         end
 
-        sig { params(args: T::Array[String], command_name: String).void }
+        #: (Array[String] args, String command_name) -> void
         def call(args, command_name)
           new.call(args, command_name)
         end
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def has_subcommands?
         false
       end

data/lib/cli/kit/command_help.rb

@@ -5,10 +5,9 @@ require 'cli/kit'
 module CLI
   module Kit
     module CommandHelp
-      extend T::Sig
       include Kernel # for sorbet
 
-      sig { params(args: T::Array[String], name: String).void }
+      #: (Array[String] args, String name) -> void
       def call(args, name)
         begin
           opts = self.class.opts_class
@@ -36,26 +35,24 @@ module CLI
       end
 
       # use to implement error handling
-      sig { params(op: T.untyped, name: String).void }
+      #: (untyped op, String name) -> void
       def invoke_wrapper(op, name)
         invoke(op, name)
       end
 
-      sig { params(op: T.untyped, name: String).void }
+      #: (untyped op, String name) -> void
       def invoke(op, name)
         raise(NotImplementedError, '#invoke must be implemented, or #call overridden')
       end
 
       class << self
-        extend T::Sig
-
-        sig { params(tool_name: String).void }
+        #: String
         attr_writer :tool_name
 
-        sig { params(max_desc_length: Integer).void }
+        #: Integer
         attr_writer :max_desc_length
 
-        sig { returns(String) }
+        #: -> String
         def _tool_name
           unless @tool_name
             raise 'You must set CLI::Kit::CommandHelp.tool_name='
@@ -64,14 +61,13 @@ module CLI
           @tool_name
         end
 
-        sig { returns(Integer) }
+        #: -> Integer
         def _max_desc_length
           @max_desc_length || 80
         end
       end
 
       module ClassMethods
-        extend T::Sig
         include Kernel # for sorbet
 
         DEFAULT_HELP_SECTIONS = [
@@ -82,7 +78,7 @@ module CLI
           :options,
         ]
 
-        sig { returns(String) }
+        #: -> String
         def build_help
           h = (@help_sections || DEFAULT_HELP_SECTIONS).map do |section|
             case section
@@ -103,7 +99,7 @@ module CLI
           CLI::UI.fmt(h)
         end
 
-        sig { returns(String) }
+        #: -> String
         def _command_name
           return @command_name if @command_name
 
@@ -111,12 +107,12 @@ module CLI
           last_camel.gsub(/([a-z])([A-Z])/, '\1-\2').downcase
         end
 
-        sig { returns(String) }
+        #: -> String
         def _desc
           @desc
         end
 
-        sig { returns(String) }
+        #: -> String
         def build_desc
           out = +"{{command:#{CommandHelp._tool_name} #{_command_name}}}"
           if @desc
@@ -125,14 +121,15 @@ module CLI
           "{{bold:#{out}}}"
         end
 
-        sig { returns(T.untyped) }
+        #: -> untyped
         def opts_class
-          T.unsafe(self).const_get(:Opts) # rubocop:disable Sorbet/ConstantsFromStrings
+          uself = self #: as untyped
+          uself.const_get(:Opts) # rubocop:disable Sorbet/ConstantsFromStrings
         rescue NameError
           Class.new(CLI::Kit::Opts)
         end
 
-        sig { returns(T.nilable(String)) }
+        #: -> String?
         def build_options
           opts = opts_class
           return unless opts
@@ -151,7 +148,7 @@ module CLI
 
           return if @defn.options.empty? && @defn.flags.empty?
 
-          merged = T.let(@defn.options, T::Array[T.any(Args::Definition::Option, Args::Definition::Flag)])
+          merged = @defn.options #: Array[(Args::Definition::Option | Args::Definition::Flag)]
           merged += @defn.flags
           merged.sort_by!(&:name)
           "{{bold:Options:}}\n" + merged.map do |o|
@@ -179,12 +176,12 @@ module CLI
           end.join("\n")
         end
 
-        sig { params(sections: T::Array[Symbol]).void }
+        #: (Array[Symbol] sections) -> void
         def help_sections(sections)
           @help_sections = sections
         end
 
-        sig { params(command_name: String).void }
+        #: (String command_name) -> void
         def command_name(command_name)
           if @command_name
             raise(ArgumentError, "Command name already set to #{@command_name}")
@@ -193,7 +190,7 @@ module CLI
           @command_name = command_name
         end
 
-        sig { params(desc: String).void }
+        #: (String desc) -> void
         def desc(desc)
           # A limit of 80 characters has been chosen to fit on standard terminal configurations. `long_desc` is
           # available when descriptions don't fit nicely in that space. If you're using CLI::Kit for an application
@@ -213,7 +210,7 @@ module CLI
           @desc = desc
         end
 
-        sig { params(long_desc: String).void }
+        #: (String long_desc) -> void
         def long_desc(long_desc)
           if @long_desc
             raise(ArgumentError, 'long description already set')
@@ -222,7 +219,7 @@ module CLI
           @long_desc = long_desc
         end
 
-        sig { returns(String) }
+        #: -> String
         def build_usage
           '{{bold:Usage:}}' + case (@usage || []).size
           when 0
@@ -236,7 +233,7 @@ module CLI
           end
         end
 
-        sig { returns(T.nilable(String)) }
+        #: -> String?
         def build_examples
           return unless @examples
 
@@ -254,13 +251,13 @@ module CLI
           end.join("\n\n")
         end
 
-        sig { params(usage: String).void }
+        #: (String usage) -> void
         def usage(usage)
           @usage ||= []
           @usage << usage
         end
 
-        sig { params(command: String, explanation: T.nilable(String)).void }
+        #: (String command, String? explanation) -> void
         def example(command, explanation)
           @examples ||= []
           @examples << [command, explanation]

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