cli-ui 2.3.1 → 2.6.0

data/lib/cli/ui/stdout_router.rb

@@ -9,15 +9,13 @@ module CLI
   module UI
     module StdoutRouter
       class Writer
-        extend T::Sig
-
-        sig { params(stream: IOLike, name: Symbol).void }
+        #: (io_like stream, Symbol name) -> void
         def initialize(stream, name)
           @stream = stream
           @name = name
         end
 
-        sig { params(args: Object).returns(Integer) }
+        #: (*Object args) -> Integer
         def write(*args)
           strs = args.map do |obj|
             str = obj.to_s
@@ -36,10 +34,12 @@ module CLI
             return 0 if hook.call(strs.join, @name) == false
           end
 
-          ret = T.unsafe(@stream).write_without_cli_ui(*prepend_id(@stream, strs))
+          stream_args = prepend_id(@stream, strs) #: as untyped
+          ret = @stream.write_without_cli_ui(*stream_args) #: as Integer
           if (dup = StdoutRouter.duplicate_output_to)
             begin
-              T.unsafe(dup).write(*prepend_id(dup, strs))
+              dup_args = prepend_id(dup, strs) #: as untyped
+              dup.write(*dup_args) #: as Integer
             rescue IOError
               # Ignore
             end
@@ -49,7 +49,7 @@ module CLI
 
         private
 
-        sig { params(stream: IOLike, args: T::Array[String]).returns(T::Array[String]) }
+        #: (io_like stream, Array[String] args) -> Array[String]
         def prepend_id(stream, args)
           return args unless prepend_id_for_stream(stream)
 
@@ -60,7 +60,7 @@ module CLI
           end
         end
 
-        sig { params(stream: IOLike).returns(T::Boolean) }
+        #: (io_like stream) -> bool
         def prepend_id_for_stream(stream)
           return false unless Thread.current[:cliui_output_id]
           return true if Thread.current[:cliui_output_id][:streams].include?(stream)
@@ -68,12 +68,12 @@ module CLI
           false
         end
 
-        sig { returns(T::Boolean) }
+        #: -> bool
         def auto_frame_inset?
           !Thread.current[:no_cliui_frame_inset]
         end
 
-        sig { params(str: String, prefix: String).returns(String) }
+        #: (String str, String prefix) -> String
         def apply_line_prefix(str, prefix)
           return '' if str.empty?
 
@@ -92,27 +92,23 @@ module CLI
       end
 
       class Capture
-        extend T::Sig
-
         @capture_mutex = Mutex.new
         @stdin_mutex = CLI::UI::ReentrantMutex.new
         @active_captures = 0
         @saved_stdin = nil
 
         class << self
-          extend T::Sig
-
-          sig { returns(T.nilable(Capture)) }
+          #: -> Capture?
           def current_capture
             Thread.current[:cliui_current_capture]
           end
 
-          sig { returns(Capture) }
+          #: -> Capture
           def current_capture!
-            T.must(current_capture)
+            current_capture #: as !nil
           end
 
-          sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+          #: [T] { -> T } -> T
           def in_alternate_screen(&block)
             stdin_synchronize do
               previous_print_captured_output = current_capture&.print_captured_output
@@ -139,7 +135,7 @@ 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 stdin_synchronize(&block)
             @stdin_mutex.synchronize do
               case $stdin
@@ -153,7 +149,7 @@ 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_stdin_masked(&block)
             @capture_mutex.synchronize do
               if @active_captures.zero?
@@ -179,20 +175,13 @@ module CLI
 
           private
 
-          sig { returns(T::Boolean) }
+          #: -> bool
           def outermost_uncaptured?
             @stdin_mutex.count == 1 && $stdin.is_a?(BlockingInput)
           end
         end
 
-        sig do
-          params(
-            with_frame_inset: T::Boolean,
-            merged_output: T::Boolean,
-            duplicate_output_to: IO,
-            block: T.proc.void,
-          ).void
-        end
+        #: (?with_frame_inset: bool, ?merged_output: bool, ?duplicate_output_to: IO) { -> void } -> void
         def initialize(
           with_frame_inset: true,
           merged_output: false,
@@ -208,10 +197,10 @@ module CLI
           @err = StringIO.new
         end
 
-        sig { returns(T::Boolean) }
+        #: bool
         attr_accessor :print_captured_output
 
-        sig { returns(T.untyped) }
+        #: -> untyped
         def run
           require 'stringio'
 
@@ -249,26 +238,24 @@ module CLI
           Thread.current[:cliui_current_capture] = nil
         end
 
-        sig { returns(String) }
+        #: -> String
         def stdout
           @out.string
         end
 
-        sig { returns(String) }
+        #: -> String
         def stderr
           @err.string
         end
 
         class BlockingInput
-          extend T::Sig
-
-          sig { params(stream: IO).void }
+          #: (IO stream) -> void
           def initialize(stream)
             @stream = stream
             @m = CLI::UI::ReentrantMutex.new
           end
 
-          sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+          #: [T] { -> T } -> T
           def synchronize(&block)
             @m.synchronize do
               previous_allowed_to_read = Thread.current[:cliui_allowed_to_read]
@@ -317,43 +304,39 @@ module CLI
       end
 
       class << self
-        extend T::Sig
-
         WRITE_WITHOUT_CLI_UI = :write_without_cli_ui
 
         NotEnabled = Class.new(StandardError)
 
-        sig { returns(T.nilable(IOLike)) }
+        #: io_like?
         attr_accessor :duplicate_output_to
 
-        sig do
-          type_parameters(:T)
-            .params(on_streams: T::Array[IOLike], block: T.proc.params(id: String).returns(T.type_parameter(:T)))
-            .returns(T.type_parameter(:T))
-        end
+        #: [T] (on_streams: Array[io_like]) { (String id) -> T } -> T
         def with_id(on_streams:, &block)
           require 'securerandom'
           id = format('%05d', rand(10**5))
           Thread.current[:cliui_output_id] = {
             id: id,
-            streams: on_streams.map { |stream| T.cast(stream, IOLike) },
+            streams: on_streams.map do |stream|
+              stream #: as io_like
+            end,
           }
           yield(id)
         ensure
           Thread.current[:cliui_output_id] = nil
         end
 
-        sig { returns(T.nilable(T::Hash[Symbol, T.any(String, IOLike)])) }
+        #: -> Hash[Symbol, (String | io_like)]?
         def current_id
           Thread.current[:cliui_output_id]
         end
 
-        sig { void }
+        #: -> void
         def assert_enabled!
           raise NotEnabled unless enabled?
         end
 
-        sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+        #: [T] { -> T } -> T
         def with_enabled(&block)
           enable
           yield
@@ -362,12 +345,12 @@ module CLI
         end
 
         # TODO: remove this
-        sig { void }
+        #: -> void
         def ensure_activated
           enable unless enabled?
         end
 
-        sig { returns(T::Boolean) }
+        #: -> bool
         def enable
           return false if enabled?($stdout) || enabled?($stderr)
 
@@ -376,12 +359,12 @@ module CLI
           true
         end
 
-        sig { params(stream: IOLike).returns(T::Boolean) }
+        #: (?io_like stream) -> bool
         def enabled?(stream = $stdout)
           stream.respond_to?(WRITE_WITHOUT_CLI_UI)
         end
 
-        sig { returns(T::Boolean) }
+        #: -> bool
         def disable
           return false unless enabled?($stdout) && enabled?($stderr)
 
@@ -392,14 +375,14 @@ module CLI
 
         private
 
-        sig { params(stream: IOLike).void }
+        #: (io_like stream) -> void
         def deactivate(stream)
           sc = stream.singleton_class
           sc.send(:remove_method, :write)
           sc.send(:alias_method, :write, WRITE_WITHOUT_CLI_UI)
         end
 
-        sig { params(stream: IOLike, streamname: Symbol).void }
+        #: (io_like stream, Symbol streamname) -> void
         def activate(stream, streamname)
           writer = StdoutRouter::Writer.new(stream, streamname)
 

data/lib/cli/ui/table.rb

@@ -3,11 +3,7 @@
 module CLI
   module UI
     module Table
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
         # Prints a formatted table to the specified output
         # Automatically pads columns to align based on the longest cell in each column,
         # ignoring the width of ANSI color codes.
@@ -35,7 +31,7 @@ module CLI
         #   really_long_cell short
         #   row2             row2
         #
-        sig { params(table: T::Array[T::Array[String]], col_spacing: Integer, to: IOLike).void }
+        #: (Array[Array[String]] table, ?col_spacing: Integer, ?to: io_like) -> void
         def puts_table(table, col_spacing: 1, to: $stdout)
           col_sizes = table.transpose.map do |col|
             col.map { |cell| CLI::UI::ANSI.printing_width(CLI::UI.resolve_text(cell)) }.max
@@ -43,7 +39,7 @@ module CLI
 
           table.each do |row|
             padded_row = row.each_with_index.map do |cell, i|
-              col_size = T.must(col_sizes[i]) # guaranteed to be non-nil
+              col_size = col_sizes[i] #: as !nil # guaranteed to be non-nil
               cell_size = CLI::UI::ANSI.printing_width(CLI::UI.resolve_text(cell))
               padded_cell = cell + ' ' * (col_size - cell_size)
               padded_cell
@@ -75,7 +71,7 @@ module CLI
         #     ["row2",              "row2"]
         #   ])
         #
-        sig { params(table: T::Array[T::Array[String]], col_spacing: Integer).returns(T::Array[String]) }
+        #: (Array[Array[String]] table, ?col_spacing: Integer) -> Array[String]
         def capture_table(table, col_spacing: 1)
           strio = StringIO.new
           puts_table(table, col_spacing: col_spacing, to: strio)

data/lib/cli/ui/terminal.rb

@@ -7,18 +7,14 @@ require 'io/console'
 module CLI
   module UI
     module Terminal
-      extend T::Sig
-
       DEFAULT_WIDTH = 80
       DEFAULT_HEIGHT = 24
 
       class << self
-        extend T::Sig
-
         # Returns the width of the terminal, if possible
         # Otherwise will return DEFAULT_WIDTH
         #
-        sig { returns(Integer) }
+        #: -> Integer
         def width
           winsize[1]
         end
@@ -26,12 +22,12 @@ module CLI
         # Returns the width of the terminal, if possible
         # Otherwise, will return DEFAULT_HEIGHT
         #
-        sig { returns(Integer) }
+        #: -> Integer
         def height
           winsize[0]
         end
 
-        sig { returns([Integer, Integer]) }
+        #: -> [Integer, Integer]
         def winsize
           @winsize ||= begin
             winsize = IO.console.winsize
@@ -47,7 +43,7 @@ module CLI
           end
         end
 
-        sig { void }
+        #: -> void
         def setup_winsize_trap
           @winsize_trap ||= Signal.trap('WINCH') do
             @winsize = nil

data/lib/cli/ui/truncater.rb

@@ -28,15 +28,13 @@ module CLI
       TRUNCATED = "\x1b[0m…"
 
       class << self
-        extend T::Sig
-
-        sig { params(text: String, printing_width: Integer).returns(String) }
+        #: (String text, Integer printing_width) -> String
         def call(text, printing_width)
           return text if text.size <= printing_width
 
           width            = 0
           mode             = PARSE_ROOT
-          truncation_index = T.let(nil, T.nilable(Integer))
+          truncation_index = nil #: Integer?
 
           codepoints = text.codepoints
           codepoints.each.with_index do |cp, index|
@@ -87,12 +85,13 @@ module CLI
           # the end of the string.
           return text if !truncation_index || width <= printing_width
 
-          T.must(codepoints[0...truncation_index]).pack('U*') + TRUNCATED
+          slice = codepoints[0...truncation_index] #: as !nil
+          slice.pack('U*') + TRUNCATED
         end
 
         private
 
-        sig { params(printable_codepoint: Integer).returns(Integer) }
+        #: (Integer printable_codepoint) -> Integer
         def width(printable_codepoint)
           case printable_codepoint
           when EMOJI_RANGE

data/lib/cli/ui/version.rb

@@ -3,6 +3,6 @@
 
 module CLI
   module UI
-    VERSION = '2.3.1'
+    VERSION = '2.6.0'
   end
 end

data/lib/cli/ui/widgets/base.rb

@@ -6,21 +6,16 @@ require('cli/ui')
 module CLI
   module UI
     module Widgets
+      # @abstract
       class Base
-        extend T::Sig
-        extend T::Helpers
-        abstract!
-
         class << self
-          extend T::Sig
-
-          sig { params(argstring: String).returns(String) }
+          #: (String argstring) -> String
           def call(argstring)
             new(argstring).render
           end
         end
 
-        sig { params(argstring: String).void }
+        #: (String argstring) -> void
         def initialize(argstring)
           pat = self.class.argparse_pattern
           unless (@match_data = pat.match(argstring))
@@ -33,14 +28,18 @@ module CLI
         end
 
         class << self
-          extend T::Sig
-
-          sig { abstract.returns(Regexp) }
-          def argparse_pattern; end
+          # @abstract
+          #: -> Regexp
+          def argparse_pattern
+            raise(NotImplementedError)
+          end
         end
 
-        sig { abstract.returns(String) }
-        def render; end
+        # @abstract
+        #: -> String
+        def render
+          raise(NotImplementedError)
+        end
       end
     end
   end

data/lib/cli/ui/widgets/status.rb

@@ -22,15 +22,15 @@ module CLI
         EMPTY_SET = '∅'
 
         class << self
-          extend T::Sig
-
-          sig { override.returns(Regexp) }
+          # @override
+          #: -> Regexp
           def argparse_pattern
             ARGPARSE_PATTERN
           end
         end
 
-        sig { override.returns(String) }
+        # @override
+        #: -> String
         def render
           if zero?(@succeeded) && zero?(@failed) && zero?(@working) && zero?(@pending)
             Color::RESET.code + Color::BOLD.code + EMPTY_SET + Color::RESET.code
@@ -42,34 +42,34 @@ module CLI
 
         private
 
-        sig { params(num_str: String).returns(T::Boolean) }
+        #: (String num_str) -> bool
         def zero?(num_str)
           num_str == '0'
         end
 
-        sig { params(num_str: String, rune: String, color: Color).returns(String) }
+        #: (String num_str, String rune, Color color) -> String
         def colorize_if_nonzero(num_str, rune, color)
           color = Color::GRAY if zero?(num_str)
           color.code + num_str + rune
         end
 
-        sig { returns(String) }
+        #: -> String
         def succeeded_part
           colorize_if_nonzero(@succeeded, Glyph::CHECK.char, Color::GREEN)
         end
 
-        sig { returns(String) }
+        #: -> String
         def failed_part
           colorize_if_nonzero(@failed, Glyph::X.char, Color::RED)
         end
 
-        sig { returns(String) }
+        #: -> String
         def working_part
           rune = zero?(@working) ? SPINNER_STOPPED : Spinner.current_rune
           colorize_if_nonzero(@working, rune, Color::BLUE)
         end
 
-        sig { returns(String) }
+        #: -> String
         def pending_part
           colorize_if_nonzero(@pending, Glyph::HOURGLASS.char, Color::WHITE)
         end

data/lib/cli/ui/widgets.rb

@@ -19,17 +19,13 @@ module CLI
     #   CLI::UI::Widgets.register('my-widget') { MyWidget }
     #   puts(CLI::UI.fmt("{{@widget/my-widget:args}}"))
     module Widgets
-      extend T::Sig
-
       MAP = {}
 
       autoload(:Base, 'cli/ui/widgets/base')
       autoload(:Status, 'cli/ui/widgets/status')
 
       class << self
-        extend T::Sig
-
-        sig { params(name: String, cb: T.proc.returns(T.class_of(Widgets::Base))).void }
+        #: (String name) { -> singleton(Widgets::Base) } -> void
         def register(name, &cb)
           MAP[name] = cb
         end
@@ -42,7 +38,7 @@ module CLI
         # ==== Returns
         # A callable widget, to be invoked like `.call(argstring)`
         #
-        sig { params(handle: String).returns(T.class_of(Widgets::Base)) }
+        #: (String handle) -> singleton(Widgets::Base)
         def lookup(handle)
           MAP.fetch(handle).call
         rescue KeyError, NameError
@@ -51,7 +47,7 @@ module CLI
 
         # All available widgets by name
         #
-        sig { returns(T::Array[String]) }
+        #: -> Array[String]
         def available
           MAP.keys
         end
@@ -60,15 +56,13 @@ module CLI
       register('status') { Widgets::Status }
 
       class InvalidWidgetHandle < ArgumentError
-        extend T::Sig
-
-        sig { params(handle: String).void }
+        #: (String handle) -> void
         def initialize(handle)
           super
           @handle = handle
         end
 
-        sig { returns(String) }
+        #: -> String
         def message
           keys = Widgets.available.join(',')
           "invalid widget handle: #{@handle} " \
@@ -77,16 +71,14 @@ module CLI
       end
 
       class InvalidWidgetArguments < ArgumentError
-        extend T::Sig
-
-        sig { params(argstring: String, pattern: Regexp).void }
+        #: (String argstring, Regexp pattern) -> void
         def initialize(argstring, pattern)
           super(nil)
           @argstring = argstring
           @pattern   = pattern
         end
 
-        sig { returns(String) }
+        #: -> String
         def message
           "invalid widget arguments: #{@argstring} " \
             "-- must match pattern: #{@pattern.inspect}"