cli-kit 5.1.0 → 5.2.0

data/lib/cli/kit/util.rb

@@ -6,21 +6,17 @@ module CLI
   module Kit
     module Util
       class << self
-        extend T::Sig
         #
         # Converts an integer representing bytes into a human readable format
         #
-        sig { params(bytes: Integer, precision: Integer, space: T::Boolean).returns(String) }
+        #: (Integer bytes, ?precision: Integer, ?space: bool) -> String
         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
         #
-        sig do
-          params(number: Numeric, unit: String, factor: Integer, precision: Integer, space: T::Boolean)
-            .returns(String)
-        end
+        #: (Numeric number, ?String unit, ?factor: Integer, ?precision: Integer, ?space: bool) -> String
         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)
 
@@ -37,11 +33,11 @@ module CLI
             if number < 1
               index = [-scale - 1, small_scale.length].min
               scale = -(index + 1)
-              prefix = T.must(small_scale[index])
+              prefix = small_scale[index] #: as !nil
             else
               index = [scale - 1, big_scale.length].min
               scale = index + 1
-              prefix = T.must(big_scale[index])
+              prefix = big_scale[index] #: as !nil
             end
           end
 
@@ -62,10 +58,7 @@ module CLI
         # 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.
-        sig do
-          type_parameters(:T).params(dir: String, block: T.proc.returns(T.type_parameter(:T)))
-            .returns(T.type_parameter(:T))
-        end
+        #: [T] (String dir) { -> T } -> T
         def with_dir(dir, &block)
           prev = Dir.pwd
           begin
@@ -85,44 +78,35 @@ module CLI
         # end.retry_after(ExpectedError) do
         #   costly_prep()
         # end
-        sig do
-          type_parameters(:T).params(block_that_might_raise: T.proc.returns(T.type_parameter(:T)))
-            .returns(Retrier[T.type_parameter(:T)])
-        end
+        #: [T] { -> T } -> Retrier[T]
         def begin(&block_that_might_raise)
           Retrier.new(block_that_might_raise)
         end
       end
 
+      #: [BlockReturnType]
       class Retrier
-        extend T::Sig
-        extend T::Generic
-
-        BlockReturnType = type_member
-
-        sig { params(block_that_might_raise: T.proc.returns(BlockReturnType)).void }
+        #: (^-> BlockReturnType block_that_might_raise) -> void
         def initialize(block_that_might_raise)
           @block_that_might_raise = block_that_might_raise
         end
 
-        sig do
-          params(
-            exception: T.class_of(Exception),
-            retries: Integer,
-            before_retry: T.nilable(T.proc.params(e: Exception).void),
-          ).returns(BlockReturnType)
-        end
+        #: (?singleton(Exception) exception, ?retries: Integer) ?{ (Exception e) -> void } -> BlockReturnType
         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
+            # rubocop:disable Style/IdenticalConditionalBranches
             if before_retry.arity == 0
-              T.cast(before_retry, T.proc.void).call
+              prc = before_retry #: as ^() -> void
+              prc.call
             else
-              T.cast(before_retry, T.proc.params(e: Exception).void).call(e)
+              prc = before_retry #: as ^(Exception) -> void
+              prc.call(e)
             end
+            # rubocop:enable Style/IdenticalConditionalBranches
           end
           retry
         end

data/lib/cli/kit/version.rb

@@ -2,6 +2,6 @@
 
 module CLI
   module Kit
-    VERSION = '5.1.0'
+    VERSION = '5.2.0'
   end
 end

data/lib/cli/kit.rb

@@ -1,17 +1,10 @@
 # typed: true
 
 require 'cli/ui'
-
-unless defined?(T)
-  require('cli/kit/sorbet_runtime_stub')
-end
-
 require 'cli/kit/core_ext'
 
 module CLI
   module Kit
-    extend T::Sig
-
     autoload :Args,            'cli/kit/args'
     autoload :BaseCommand,     'cli/kit/base_command'
     autoload :CommandRegistry, 'cli/kit/command_registry'
@@ -33,6 +26,9 @@ module CLI
     EXIT_BUG                 = 1
     EXIT_SUCCESS             = 0
 
+    UNTYPED_NIL = nil #: untyped
+    private_constant(:UNTYPED_NIL)
+
     # Abort, Bug, AbortSilent, and BugSilent are four ways of immediately bailing
     # on command-line execution when an unrecoverable error occurs.
     #
@@ -76,9 +72,7 @@ module CLI
     GenericAbort = Class.new(Exception) # rubocop:disable Lint/InheritException
 
     class Abort < GenericAbort # bug:false; silent: false
-      extend(T::Sig)
-
-      sig { returns(T::Boolean) }
+      #: -> bool
       def bug?
         false
       end
@@ -88,31 +82,25 @@ module CLI
     end
 
     class BugSilent < GenericAbort # bug:true; silent:true
-      extend(T::Sig)
-
-      sig { returns(T::Boolean) }
+      #: -> bool
       def silent?
         true
       end
     end
 
     class AbortSilent < GenericAbort # bug:false; silent:true
-      extend(T::Sig)
-
-      sig { returns(T::Boolean) }
+      #: -> bool
       def bug?
         false
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def silent?
         true
       end
     end
 
     class << self
-      extend T::Sig
-
       # Mirrors the API of Kernel#raise, but with the addition of a few new
       # optional keyword arguments. `bug` and `silent` attach metadata to the
       # exception being raised, which is interpreted later in the ErrorHandler to
@@ -121,31 +109,25 @@ module CLI
       # `depth` is used to trim leading elements of the backtrace. If you wrap
       # this method in your own wrapper, you'll want to pass `depth: 2`, for
       # example.
-      sig do
-        params(
-          exception: T.any(Class, String, Exception),
-          string: T.untyped,
-          array: T.nilable(T::Array[String]),
-          cause: T.nilable(Exception),
-          bug: T.nilable(T::Boolean),
-          silent: T.nilable(T::Boolean),
-          depth: Integer,
-        ).returns(T.noreturn)
-      end
+      #: (?(Class | String | Exception) exception, ?untyped string, ?Array[String]? array, ?cause: Exception?, ?bug: bool?, ?silent: bool?, ?depth: Integer) -> bot
       def raise(
         # default arguments
-        exception = T.unsafe(nil), string = T.unsafe(nil), array = T.unsafe(nil), cause: $ERROR_INFO,
+        exception = UNTYPED_NIL,
+        string = UNTYPED_NIL,
+        array = UNTYPED_NIL,
+        cause: $ERROR_INFO,
         # new arguments
         bug: nil, silent: nil, depth: 1
       )
+        k = Kernel #: as untyped
         if array
-          T.unsafe(Kernel).raise(exception, string, array, cause: cause)
+          k.raise(exception, string, array, cause: cause)
         elsif string
-          T.unsafe(Kernel).raise(exception, string, Kernel.caller(depth), cause: cause)
+          k.raise(exception, string, Kernel.caller(depth), cause: cause)
         elsif exception.is_a?(String)
-          T.unsafe(Kernel).raise(RuntimeError, exception, Kernel.caller(depth), cause: cause)
+          k.raise(RuntimeError, exception, Kernel.caller(depth), cause: cause)
         else
-          T.unsafe(Kernel).raise(exception, exception.message, Kernel.caller(depth), cause: cause)
+          k.raise(exception, exception.message, Kernel.caller(depth), cause: cause)
         end
       rescue Exception => e # rubocop:disable Lint/RescueException
         e.bug!(bug) unless bug.nil?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cli-kit
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Burke Libbey
@@ -148,7 +148,6 @@ files:
 - lib/cli/kit/opts.rb
 - lib/cli/kit/parse_args.rb
 - lib/cli/kit/resolver.rb
-- lib/cli/kit/sorbet_runtime_stub.rb
 - lib/cli/kit/support.rb
 - lib/cli/kit/support/test_helper.rb
 - lib/cli/kit/system.rb

data/lib/cli/kit/sorbet_runtime_stub.rb

@@ -1,154 +0,0 @@
-# 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
-      def sealed_violation_whitelist; end
-      def sealed_violation_whitelist=(sealed_violation_whitelist); end
-      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