cli-ui 1.5.1 → 2.0.0

data/lib/cli/ui/stdout_router.rb

@@ -1,19 +1,21 @@
+# typed: true
+
 require 'cli/ui'
 require 'stringio'
 
 module CLI
   module UI
     module StdoutRouter
-      class << self
-        attr_accessor :duplicate_output_to
-      end
-
       class Writer
+        extend T::Sig
+
+        sig { params(stream: IOLike, name: Symbol).void }
         def initialize(stream, name)
           @stream = stream
           @name = name
         end
 
+        sig { params(args: String).void }
         def write(*args)
           args = args.map do |str|
             if auto_frame_inset?
@@ -31,34 +33,42 @@ module CLI
             return if hook.call(args.map(&:to_s).join, @name) == false
           end
 
-          @stream.write_without_cli_ui(*prepend_id(@stream, args))
+          T.unsafe(@stream).write_without_cli_ui(*prepend_id(@stream, args))
           if (dup = StdoutRouter.duplicate_output_to)
-            dup.write(*prepend_id(dup, args))
+            T.unsafe(dup).write(*prepend_id(dup, args))
           end
         end
 
         private
 
+        sig { params(stream: IOLike, args: T::Array[String]).returns(T::Array[String]) }
         def prepend_id(stream, args)
           return args unless prepend_id_for_stream(stream)
+
           args.map do |a|
             next a if a.chomp.empty? # allow new lines to be new lines
+
             "[#{Thread.current[:cliui_output_id][:id]}] #{a}"
           end
         end
 
+        sig { params(stream: IOLike).returns(T::Boolean) }
         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)
+
           false
         end
 
+        sig { returns(T::Boolean) }
         def auto_frame_inset?
           !Thread.current[:no_cliui_frame_inset]
         end
 
+        sig { params(str: String, prefix: String).returns(String) }
         def apply_line_prefix(str, prefix)
           return '' if str.empty?
+
           prefixed = +''
           str.force_encoding(Encoding::UTF_8).lines.each do |line|
             if @pending_newline
@@ -74,39 +84,52 @@ module CLI
       end
 
       class Capture
+        extend T::Sig
+
         @m = Mutex.new
         @active_captures = 0
         @saved_stdin = nil
 
-        def self.with_stdin_masked
-          @m.synchronize do
-            if @active_captures.zero?
-              @saved_stdin = $stdin
-              $stdin, w = IO.pipe
-              $stdin.close
-              w.close
+        class << self
+          extend T::Sig
+
+          sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+          def with_stdin_masked(&block)
+            @m.synchronize do
+              if @active_captures.zero?
+                @saved_stdin = $stdin
+                $stdin, w = IO.pipe
+                $stdin.close
+                w.close
+              end
+              @active_captures += 1
             end
-            @active_captures += 1
-          end
 
-          yield
-        ensure
-          @m.synchronize do
-            @active_captures -= 1
-            if @active_captures.zero?
-              $stdin = @saved_stdin
+            yield
+          ensure
+            @m.synchronize do
+              @active_captures -= 1
+              if @active_captures.zero?
+                $stdin = @saved_stdin
+              end
             end
           end
         end
 
-        def initialize(*block_args, with_frame_inset: true, &block)
+        sig do
+          params(with_frame_inset: T::Boolean, block: T.proc.void).void
+        end
+        def initialize(with_frame_inset: true, &block)
           @with_frame_inset = with_frame_inset
-          @block_args = block_args
           @block = block
+          @stdout = ''
+          @stderr = ''
         end
 
+        sig { returns(String) }
         attr_reader :stdout, :stderr
 
+        sig { returns(T.untyped) }
         def run
           require 'stringio'
 
@@ -134,7 +157,7 @@ module CLI
             end
 
             begin
-              @block.call(*@block_args)
+              @block.call
             ensure
               @stdout = out.string
               @stderr = err.string
@@ -147,39 +170,44 @@ module CLI
       end
 
       class << self
+        extend T::Sig
+
         WRITE_WITHOUT_CLI_UI = :write_without_cli_ui
 
         NotEnabled = Class.new(StandardError)
 
-        def with_id(on_streams:)
-          unless on_streams.is_a?(Array) && on_streams.all? { |s| s.respond_to?(:write) }
-            raise ArgumentError, <<~EOF
-            on_streams must be an array of objects that respond to `write`
-            These do not respond to write
-            #{on_streams.reject { |s| s.respond_to?(:write) }.map.with_index { |s| s.class.to_s }.join("\n")}
-            EOF
-          end
+        sig { returns(T.nilable(IOLike)) }
+        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
+        def with_id(on_streams:, &block)
           require 'securerandom'
           id = format('%05d', rand(10**5))
           Thread.current[:cliui_output_id] = {
             id: id,
-            streams: on_streams,
+            streams: on_streams.map { |stream| T.cast(stream, IOLike) },
           }
           yield(id)
         ensure
           Thread.current[:cliui_output_id] = nil
         end
 
+        sig { returns(T.nilable(T::Hash[Symbol, T.any(String, IOLike)])) }
         def current_id
           Thread.current[:cliui_output_id]
         end
 
+        sig { void }
         def assert_enabled!
           raise NotEnabled unless enabled?
         end
 
-        def with_enabled
+        sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+        def with_enabled(&block)
           enable
           yield
         ensure
@@ -187,23 +215,29 @@ module CLI
         end
 
         # TODO: remove this
+        sig { void }
         def ensure_activated
           enable unless enabled?
         end
 
+        sig { returns(T::Boolean) }
         def enable
           return false if enabled?($stdout) || enabled?($stderr)
+
           activate($stdout, :stdout)
           activate($stderr, :stderr)
           true
         end
 
+        sig { params(stream: IOLike).returns(T::Boolean) }
         def enabled?(stream = $stdout)
           stream.respond_to?(WRITE_WITHOUT_CLI_UI)
         end
 
+        sig { returns(T::Boolean) }
         def disable
           return false unless enabled?($stdout) && enabled?($stderr)
+
           deactivate($stdout)
           deactivate($stderr)
           true
@@ -211,16 +245,19 @@ module CLI
 
         private
 
+        sig { params(stream: IOLike).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 }
         def activate(stream, streamname)
           writer = StdoutRouter::Writer.new(stream, streamname)
 
           raise if stream.respond_to?(WRITE_WITHOUT_CLI_UI)
+
           stream.singleton_class.send(:alias_method, WRITE_WITHOUT_CLI_UI, :write)
           stream.define_singleton_method(:write) do |*args|
             writer.write(*args)

data/lib/cli/ui/terminal.rb

@@ -1,44 +1,56 @@
+# typed: true
+
 require 'cli/ui'
 require 'io/console'
 
 module CLI
   module UI
     module Terminal
+      extend T::Sig
+
       DEFAULT_WIDTH = 80
       DEFAULT_HEIGHT = 24
 
-      # Returns the width of the terminal, if possible
-      # Otherwise will return DEFAULT_WIDTH
-      #
-      def self.width
-        winsize[1]
-      end
+      class << self
+        extend T::Sig
 
-      # Returns the width of the terminal, if possible
-      # Otherwise, will return DEFAULT_HEIGHT
-      #
-      def self.height
-        winsize[0]
-      end
+        # Returns the width of the terminal, if possible
+        # Otherwise will return DEFAULT_WIDTH
+        #
+        sig { returns(Integer) }
+        def width
+          winsize[1]
+        end
 
-      def self.winsize
-        @winsize ||= begin
-          winsize = IO.console.winsize
-          setup_winsize_trap
+        # Returns the width of the terminal, if possible
+        # Otherwise, will return DEFAULT_HEIGHT
+        #
+        sig { returns(Integer) }
+        def height
+          winsize[0]
+        end
+
+        sig { returns([Integer, Integer]) }
+        def winsize
+          @winsize ||= begin
+            winsize = IO.console.winsize
+            setup_winsize_trap
 
-          if winsize.any?(&:zero?)
+            if winsize.any?(&:zero?)
+              [DEFAULT_HEIGHT, DEFAULT_WIDTH]
+            else
+              winsize
+            end
+          rescue
             [DEFAULT_HEIGHT, DEFAULT_WIDTH]
-          else
-            winsize
           end
-        rescue
-          [DEFAULT_HEIGHT, DEFAULT_WIDTH]
         end
-      end
 
-      def self.setup_winsize_trap
-        @winsize_trap ||= Signal.trap('WINCH') do
-          @winsize = nil
+        sig { void }
+        def setup_winsize_trap
+          @winsize_trap ||= Signal.trap('WINCH') do
+            @winsize = nil
+          end
         end
       end
     end

data/lib/cli/ui/truncater.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 require 'cli/ui'
@@ -27,12 +28,15 @@ module CLI
       TRUNCATED = "\x1b[0m…"
 
       class << self
+        extend T::Sig
+
+        sig { params(text: String, printing_width: Integer).returns(String) }
         def call(text, printing_width)
           return text if text.size <= printing_width
 
           width            = 0
           mode             = PARSE_ROOT
-          truncation_index = nil
+          truncation_index = T.let(nil, T.nilable(Integer))
 
           codepoints = text.codepoints
           codepoints.each.with_index do |cp, index|
@@ -83,11 +87,12 @@ module CLI
           # the end of the string.
           return text if !truncation_index || width <= printing_width
 
-          codepoints[0...truncation_index].pack('U*') + TRUNCATED
+          T.must(codepoints[0...truncation_index]).pack('U*') + TRUNCATED
         end
 
         private
 
+        sig { params(printable_codepoint: Integer).returns(Integer) }
         def width(printable_codepoint)
           case printable_codepoint
           when EMOJI_RANGE

data/lib/cli/ui/version.rb

@@ -1,5 +1,7 @@
+# typed: true
+
 module CLI
   module UI
-    VERSION = '1.5.1'
+    VERSION = '2.0.0'
   end
 end

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

@@ -1,26 +1,45 @@
+# typed: true
+
 require('cli/ui')
 
 module CLI
   module UI
     module Widgets
       class Base
-        def self.call(argstring)
-          new(argstring).render
+        extend T::Sig
+        extend T::Helpers
+        abstract!
+
+        class << self
+          extend T::Sig
+
+          sig { params(argstring: String).returns(String) }
+          def call(argstring)
+            new(argstring).render
+          end
         end
 
+        sig { params(argstring: String).void }
         def initialize(argstring)
           pat = self.class.argparse_pattern
           unless (@match_data = pat.match(argstring))
             raise(Widgets::InvalidWidgetArguments.new(argstring, pat))
           end
+
           @match_data.names.each do |name|
             instance_variable_set(:"@#{name}", @match_data[name])
           end
         end
 
-        def self.argparse_pattern
-          const_get(:ARGPARSE_PATTERN)
+        class << self
+          extend T::Sig
+
+          sig { abstract.returns(Regexp) }
+          def argparse_pattern; end
         end
+
+        sig { abstract.returns(String) }
+        def render; end
       end
     end
   end

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

@@ -1,4 +1,6 @@
-# frozen-string-literal: true
+# typed: true
+# frozen_string_literal: true
+
 require('cli/ui')
 
 module CLI
@@ -19,6 +21,16 @@ module CLI
         SPINNER_STOPPED = '⠿'
         EMPTY_SET = '∅'
 
+        class << self
+          extend T::Sig
+
+          sig { override.returns(Regexp) }
+          def argparse_pattern
+            ARGPARSE_PATTERN
+          end
+        end
+
+        sig { override.returns(String) }
         def render
           if zero?(@succeeded) && zero?(@failed) && zero?(@working) && zero?(@pending)
             Color::RESET.code + Color::BOLD.code + EMPTY_SET + Color::RESET.code
@@ -30,28 +42,34 @@ module CLI
 
         private
 
+        sig { params(num_str: String).returns(T::Boolean) }
         def zero?(num_str)
           num_str == '0'
         end
 
+        sig { params(num_str: String, rune: String, color: Color).returns(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) }
         def succeeded_part
           colorize_if_nonzero(@succeeded, Glyph::CHECK.char, Color::GREEN)
         end
 
+        sig { returns(String) }
         def failed_part
           colorize_if_nonzero(@failed, Glyph::X.char, Color::RED)
         end
 
+        sig { returns(String) }
         def working_part
           rune = zero?(@working) ? SPINNER_STOPPED : Spinner.current_rune
           colorize_if_nonzero(@working, rune, Color::BLUE)
         end
 
+        sig { returns(String) }
         def pending_part
           colorize_if_nonzero(@pending, Glyph::HOURGLASS.char, Color::WHITE)
         end

data/lib/cli/ui/widgets.rb

@@ -1,3 +1,5 @@
+# typed: true
+
 require('cli/ui')
 
 module CLI
@@ -16,57 +18,74 @@ 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')
 
-      def self.register(name, &cb)
-        MAP[name] = cb
-      end
+      class << self
+        extend T::Sig
 
-      autoload(:Status, 'cli/ui/widgets/status')
-      register('status') { Widgets::Status }
+        sig { params(name: String, cb: T.proc.returns(T.class_of(Widgets::Base))).void }
+        def register(name, &cb)
+          MAP[name] = cb
+        end
 
-      # Looks up a widget by handle
-      #
-      # ==== Raises
-      # Raises InvalidWidgetHandle if the widget is not available.
-      #
-      # ==== Returns
-      # A callable widget, to be invoked like `.call(argstring)`
-      #
-      def self.lookup(handle)
-        MAP.fetch(handle.to_s).call
-      rescue KeyError, NameError
-        raise(InvalidWidgetHandle, handle)
-      end
+        # Looks up a widget by handle
+        #
+        # ==== Raises
+        # Raises InvalidWidgetHandle if the widget is not available.
+        #
+        # ==== Returns
+        # A callable widget, to be invoked like `.call(argstring)`
+        #
+        sig { params(handle: String).returns(T.class_of(Widgets::Base)) }
+        def lookup(handle)
+          MAP.fetch(handle).call
+        rescue KeyError, NameError
+          raise(InvalidWidgetHandle, handle)
+        end
 
-      # All available widgets by name
-      #
-      def self.available
-        MAP.keys
+        # All available widgets by name
+        #
+        sig { returns(T::Array[String]) }
+        def available
+          MAP.keys
+        end
       end
 
+      register('status') { Widgets::Status }
+
       class InvalidWidgetHandle < ArgumentError
+        extend T::Sig
+
+        sig { params(handle: String).void }
         def initialize(handle)
           super
           @handle = handle
         end
 
+        sig { returns(String) }
         def message
-          keys = Widget.available.join(',')
+          keys = Widgets.available.join(',')
           "invalid widget handle: #{@handle} " \
             "-- must be one of CLI::UI::Widgets.available (#{keys})"
         end
       end
 
       class InvalidWidgetArguments < ArgumentError
+        extend T::Sig
+
+        sig { params(argstring: String, pattern: Regexp).void }
         def initialize(argstring, pattern)
           super
           @argstring = argstring
           @pattern   = pattern
         end
 
+        sig { returns(String) }
         def message
           "invalid widget arguments: #{@argstring} " \
             "-- must match pattern: #{@pattern.inspect}"

data/lib/cli/ui/wrap.rb

@@ -1,4 +1,7 @@
 # coding: utf-8
+
+# typed: true
+
 require 'cli/ui'
 require 'cli/ui/frame/frame_stack'
 require 'cli/ui/frame/frame_style'
@@ -6,13 +9,17 @@ require 'cli/ui/frame/frame_style'
 module CLI
   module UI
     class Wrap
+      extend T::Sig
+
+      sig { params(input: String).void }
       def initialize(input)
         @input = input
       end
 
+      sig { returns(String) }
       def wrap
         max_width = Terminal.width - Frame.prefix_width
-        width = 0
+        width = T.let(0, Integer)
         final = []
         # Create an alternation of format codes of parameter lengths 1-20, since + and {1,n} not allowed in lookbehind
         format_codes = (1..20).map { |n| /\x1b\[[\d;]{#{n}}m/ }.join('|')