cli-ui 1.5.1 → 2.2.3

data/lib/cli/ui/stdout_router.rb

@@ -1,24 +1,27 @@
+# typed: true
+
 require 'cli/ui'
 require 'stringio'
+require_relative '../../../vendor/reentrant_mutex'
 
 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: Object).returns(Integer) }
         def write(*args)
           args = args.map do |str|
             if auto_frame_inset?
               str = str.dup # unfreeze
-              str = str.force_encoding(Encoding::UTF_8)
+              str = str.to_s.force_encoding(Encoding::UTF_8)
               apply_line_prefix(str, CLI::UI::Frame.prefix)
             else
               @pending_newline = false
@@ -28,37 +31,50 @@ module CLI
 
           # hook return of false suppresses output.
           if (hook = Thread.current[:cliui_output_hook])
-            return if hook.call(args.map(&:to_s).join, @name) == false
+            return 0 if hook.call(args.map(&:to_s).join, @name) == false
           end
 
-          @stream.write_without_cli_ui(*prepend_id(@stream, args))
+          ret = T.unsafe(@stream).write_without_cli_ui(*prepend_id(@stream, args))
           if (dup = StdoutRouter.duplicate_output_to)
-            dup.write(*prepend_id(dup, args))
+            begin
+              T.unsafe(dup).write(*prepend_id(dup, args))
+            rescue IOError
+              # Ignore
+            end
           end
+          ret
         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,46 +90,132 @@ module CLI
       end
 
       class Capture
-        @m = Mutex.new
+        extend T::Sig
+
+        @capture_mutex = Mutex.new
+        @stdin_mutex = CLI::UI::ReentrantMutex.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 { returns(T.nilable(Capture)) }
+          def current_capture
+            Thread.current[:cliui_current_capture]
+          end
+
+          sig { returns(Capture) }
+          def current_capture!
+            T.must(current_capture)
+          end
+
+          sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+          def in_alternate_screen(&block)
+            stdin_synchronize do
+              previous_print_captured_output = current_capture&.print_captured_output
+              current_capture&.print_captured_output = true
+              Spinner::SpinGroup.pause_spinners do
+                if outermost_uncaptured?
+                  begin
+                    prev_hook = Thread.current[:cliui_output_hook]
+                    Thread.current[:cliui_output_hook] = nil
+                    replay = current_capture!.stdout.gsub(ANSI.match_alternate_screen, '')
+                    CLI::UI.raw do
+                      print("#{ANSI.enter_alternate_screen}#{replay}")
+                    end
+                  ensure
+                    Thread.current[:cliui_output_hook] = prev_hook
+                  end
+                end
+                block.call
+              ensure
+                print(ANSI.exit_alternate_screen) if outermost_uncaptured?
+              end
+            ensure
+              current_capture&.print_captured_output = !!previous_print_captured_output
             end
-            @active_captures += 1
           end
 
-          yield
-        ensure
-          @m.synchronize do
-            @active_captures -= 1
-            if @active_captures.zero?
-              $stdin = @saved_stdin
+          sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+          def stdin_synchronize(&block)
+            @stdin_mutex.synchronize do
+              case $stdin
+              when BlockingInput
+                $stdin.synchronize do
+                  block.call
+                end
+              else
+                block.call
+              end
             end
           end
+
+          sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+          def with_stdin_masked(&block)
+            @capture_mutex.synchronize do
+              if @active_captures.zero?
+                @stdin_mutex.synchronize do
+                  @saved_stdin = $stdin
+                  $stdin = BlockingInput.new(@saved_stdin)
+                end
+              end
+              @active_captures += 1
+            end
+
+            yield
+          ensure
+            @capture_mutex.synchronize do
+              @active_captures -= 1
+              if @active_captures.zero?
+                @stdin_mutex.synchronize do
+                  $stdin = @saved_stdin
+                end
+              end
+            end
+          end
+
+          private
+
+          sig { returns(T::Boolean) }
+          def outermost_uncaptured?
+            @stdin_mutex.count == 1 && $stdin.is_a?(BlockingInput)
+          end
         end
 
-        def initialize(*block_args, with_frame_inset: true, &block)
+        sig do
+          params(
+            with_frame_inset: T::Boolean,
+            merged_output: T::Boolean,
+            duplicate_output_to: IO,
+            block: T.proc.void,
+          ).void
+        end
+        def initialize(
+          with_frame_inset: true,
+          merged_output: false,
+          duplicate_output_to: File.open(File::NULL, 'w'),
+          &block
+        )
           @with_frame_inset = with_frame_inset
-          @block_args = block_args
+          @merged_output = merged_output
+          @duplicate_output_to = duplicate_output_to
           @block = block
+          @print_captured_output = false
+          @out = StringIO.new
+          @err = StringIO.new
         end
 
-        attr_reader :stdout, :stderr
+        sig { returns(T::Boolean) }
+        attr_accessor :print_captured_output
 
+        sig { returns(T.untyped) }
         def run
           require 'stringio'
 
           StdoutRouter.assert_enabled!
 
-          out = StringIO.new
-          err = StringIO.new
+          Thread.current[:cliui_current_capture] = self
 
           prev_frame_inset = Thread.current[:no_cliui_frame_inset]
           prev_hook = Thread.current[:cliui_output_hook]
@@ -125,61 +227,132 @@ module CLI
           self.class.with_stdin_masked do
             Thread.current[:no_cliui_frame_inset] = !@with_frame_inset
             Thread.current[:cliui_output_hook] = ->(data, stream) do
+              stream = :stdout if @merged_output
               case stream
-              when :stdout then out.write(data)
-              when :stderr then err.write(data)
+              when :stdout
+                @out.write(data)
+                @duplicate_output_to.write(data)
+              when :stderr
+                @err.write(data)
               else raise
               end
-              false # suppress writing to terminal
+              print_captured_output # suppress writing to terminal by default
             end
 
-            begin
-              @block.call(*@block_args)
-            ensure
-              @stdout = out.string
-              @stderr = err.string
-            end
+            @block.call
           end
         ensure
           Thread.current[:cliui_output_hook] = prev_hook
           Thread.current[:no_cliui_frame_inset] = prev_frame_inset
+          Thread.current[:cliui_current_capture] = nil
+        end
+
+        sig { returns(String) }
+        def stdout
+          @out.string
+        end
+
+        sig { returns(String) }
+        def stderr
+          @err.string
+        end
+
+        class BlockingInput
+          extend T::Sig
+
+          sig { params(stream: IO).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)) }
+          def synchronize(&block)
+            @m.synchronize do
+              previous_allowed_to_read = Thread.current[:cliui_allowed_to_read]
+              Thread.current[:cliui_allowed_to_read] = true
+              block.call
+            ensure
+              Thread.current[:cliui_allowed_to_read] = previous_allowed_to_read
+            end
+          end
+
+          READING_METHODS = [
+            :each,
+            :each_byte,
+            :each_char,
+            :each_codepoint,
+            :each_line,
+            :getbyte,
+            :getc,
+            :getch,
+            :gets,
+            :read,
+            :read_nonblock,
+            :readbyte,
+            :readchar,
+            :readline,
+            :readlines,
+            :readpartial,
+          ]
+
+          NON_READING_METHODS = IO.instance_methods(false) - READING_METHODS
+
+          READING_METHODS.each do |method|
+            define_method(method) do |*args, **kwargs, &block|
+              raise(IOError, 'closed stream') unless Thread.current[:cliui_allowed_to_read]
+
+              @stream.send(method, *args, **kwargs, &block)
+            end
+          end
+
+          NON_READING_METHODS.each do |method|
+            define_method(method) do |*args, **kwargs, &block|
+              @stream.send(method, *args, **kwargs, &block)
+            end
+          end
         end
       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 +360,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 +390,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.2.3'
   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