cli-ui 1.5.1 → 2.1.0

data/lib/cli/ui/sorbet_runtime_stub.rb

@@ -0,0 +1,157 @@
+# 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
+      # rubocop:disable Naming/InclusiveLanguage
+      def sealed_violation_whitelist; end
+      def sealed_violation_whitelist=(sealed_violation_whitelist); end
+      # rubocop:enable Naming/InclusiveLanguage
+      def sig_builder_error_handler(error, location); 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

data/lib/cli/ui/spinner/async.rb

@@ -1,11 +1,20 @@
+# typed: true
+
 module CLI
   module UI
     module Spinner
       class Async
-        # Convenience method for +initialize+
-        #
-        def self.start(title)
-          new(title)
+        extend T::Sig
+
+        class << self
+          extend T::Sig
+
+          # Convenience method for +initialize+
+          #
+          sig { params(title: String).returns(Async) }
+          def start(title)
+            new(title)
+          end
         end
 
         # Initializes a new asynchronous spinner with no specific end.
@@ -19,6 +28,7 @@ module CLI
         #
         #   CLI::UI::Spinner::Async.new('Title')
         #
+        sig { params(title: String).void }
         def initialize(title)
           require 'thread'
           sg = CLI::UI::Spinner::SpinGroup.new
@@ -30,6 +40,7 @@ module CLI
 
         # Stops an asynchronous spinner
         #
+        sig { returns(T::Boolean) }
         def stop
           @m.synchronize { @cv.signal }
           @t.value

data/lib/cli/ui/spinner/spin_group.rb

@@ -1,35 +1,53 @@
+# typed: true
+
 module CLI
   module UI
     module Spinner
       class SpinGroup
+        extend T::Sig
+
         # Initializes a new spin group
         # This lets you add +Task+ objects to the group to multi-thread work
         #
         # ==== Options
         #
-        # * +:auto_debrief+ - Automatically debrief exceptions? Default to true
+        # * +:auto_debrief+ - Automatically debrief exceptions or through success_debrief? Default to true
         #
         # ==== Example Usage
         #
-        #  spin_group = CLI::UI::SpinGroup.new
-        #  spin_group.add('Title')   { |spinner| sleep 3.0 }
-        #  spin_group.add('Title 2') { |spinner| sleep 3.0; spinner.update_title('New Title'); sleep 3.0 }
-        #  spin_group.wait
+        #  CLI::UI::SpinGroup.new do |spin_group|
+        #    spin_group.add('Title')   { |spinner| sleep 3.0 }
+        #    spin_group.add('Title 2') { |spinner| sleep 3.0; spinner.update_title('New Title'); sleep 3.0 }
+        #  end
         #
         # Output:
         #
         # https://user-images.githubusercontent.com/3074765/33798558-c452fa26-dce8-11e7-9e90-b4b34df21a46.gif
         #
+        sig { params(auto_debrief: T::Boolean).void }
         def initialize(auto_debrief: true)
           @m = Mutex.new
           @consumed_lines = 0
           @tasks = []
           @auto_debrief = auto_debrief
           @start = Time.new
+          if block_given?
+            yield self
+            wait
+          end
         end
 
         class Task
-          attr_reader :title, :exception, :success, :stdout, :stderr
+          extend T::Sig
+
+          sig { returns(String) }
+          attr_reader :title, :stdout, :stderr
+
+          sig { returns(T::Boolean) }
+          attr_reader :success
+
+          sig { returns(T.nilable(Exception)) }
+          attr_reader :exception
 
           # Initializes a new Task
           # This is managed entirely internally by +SpinGroup+
@@ -39,11 +57,12 @@ module CLI
           # * +title+ - Title of the task
           # * +block+ - Block for the task, will be provided with an instance of the spinner
           #
+          sig { params(title: String, block: T.proc.params(task: Task).returns(T.untyped)).void }
           def initialize(title, &block)
             @title = title
             @always_full_render = title =~ Formatter::SCAN_WIDGET
             @thread = Thread.new do
-              cap = CLI::UI::StdoutRouter::Capture.new(self, with_frame_inset: false, &block)
+              cap = CLI::UI::StdoutRouter::Capture.new(with_frame_inset: false) { block.call(self) }
               begin
                 cap.run
               ensure
@@ -61,6 +80,7 @@ module CLI
 
           # Checks if a task is finished
           #
+          sig { returns(T::Boolean) }
           def check
             return true if @done
             return false if @thread.alive?
@@ -96,6 +116,7 @@ module CLI
           # * +force+ - force rerender of the task
           # * +width+ - current terminal width to format for
           #
+          sig { params(index: Integer, force: T::Boolean, width: Integer).returns(String) }
           def render(index, force = true, width: CLI::UI::Terminal.width)
             @m.synchronize do
               if force || @always_full_render || @force_full_render
@@ -114,6 +135,7 @@ module CLI
           #
           # * +title+ - title to change the spinner to
           #
+          sig { params(new_title: String).void }
           def update_title(new_title)
             @m.synchronize do
               @always_full_render = new_title =~ Formatter::SCAN_WIDGET
@@ -122,8 +144,14 @@ module CLI
             end
           end
 
+          sig { void }
+          def interrupt
+            @thread.raise(Interrupt)
+          end
+
           private
 
+          sig { params(index: Integer, terminal_width: Integer).returns(String) }
           def full_render(index, terminal_width)
             prefix = inset +
               glyph(index) +
@@ -137,10 +165,12 @@ module CLI
               "\e[K"
           end
 
+          sig { params(index: Integer).returns(String) }
           def partial_render(index)
             CLI::UI::ANSI.cursor_forward(inset_width) + glyph(index) + CLI::UI::Color::RESET.code
           end
 
+          sig { params(index: Integer).returns(String) }
           def glyph(index)
             if @done
               @success ? CLI::UI::Glyph::CHECK.to_s : CLI::UI::Glyph::X.to_s
@@ -149,10 +179,12 @@ module CLI
             end
           end
 
+          sig { returns(String) }
           def inset
             @inset ||= CLI::UI::Frame.prefix
           end
 
+          sig { returns(Integer) }
           def inset_width
             @inset_width ||= CLI::UI::ANSI.printing_width(inset)
           end
@@ -170,6 +202,7 @@ module CLI
         #   spin_group.add('Title') { |spinner| sleep 1.0 }
         #   spin_group.wait
         #
+        sig { params(title: String, block: T.proc.params(task: Task).void).void }
         def add(title, &block)
           @m.synchronize do
             @tasks << Task.new(title, &block)
@@ -183,11 +216,12 @@ module CLI
         #   spin_group.add('Title') { |spinner| sleep 1.0 }
         #   spin_group.wait
         #
+        sig { returns(T::Boolean) }
         def wait
           idx = 0
 
           loop do
-            all_done = true
+            all_done = T.let(true, T::Boolean)
 
             width = CLI::UI::Terminal.width
 
@@ -222,24 +256,58 @@ module CLI
           if @auto_debrief
             debrief
           else
-            @m.synchronize do
-              @tasks.all?(&:success)
-            end
+            all_succeeded?
+          end
+        rescue Interrupt
+          @tasks.each(&:interrupt)
+          raise
+        end
+
+        # Provide an alternative debriefing for failed tasks
+        sig do
+          params(
+            block: T.proc.params(title: String, exception: T.nilable(Exception), out: String, err: String).void,
+          ).void
+        end
+        def failure_debrief(&block)
+          @failure_debrief = block
+        end
+
+        # Provide a debriefing for successful tasks
+        sig do
+          params(
+            block: T.proc.params(title: String, out: String, err: String).void,
+          ).void
+        end
+        def success_debrief(&block)
+          @success_debrief = block
+        end
+
+        sig { returns(T::Boolean) }
+        def all_succeeded?
+          @m.synchronize do
+            @tasks.all?(&:success)
           end
         end
 
         # Debriefs failed tasks is +auto_debrief+ is true
         #
+        sig { returns(T::Boolean) }
         def debrief
           @m.synchronize do
             @tasks.each do |task|
-              next if task.success
-
-              e = task.exception
+              title = task.title
               out = task.stdout
               err = task.stderr
 
-              CLI::UI::Frame.open('Task Failed: ' + task.title, color: :red, timing: Time.new - @start) do
+              if task.success
+                next @success_debrief&.call(title, out, err)
+              end
+
+              e = task.exception
+              next @failure_debrief.call(title, e, out, err) if @failure_debrief
+
+              CLI::UI::Frame.open('Task Failed: ' + title, color: :red, timing: Time.new - @start) do
                 if e
                   puts "#{e.class}: #{e.message}"
                   puts "\tfrom #{e.backtrace.join("\n\tfrom ")}"

data/lib/cli/ui/spinner.rb

@@ -1,22 +1,33 @@
-# frozen-string-literal: true
+# typed: true
+# frozen_string_literal: true
+
 require 'cli/ui'
 
 module CLI
   module UI
     module Spinner
+      extend T::Sig
+
       autoload :Async,      'cli/ui/spinner/async'
       autoload :SpinGroup,  'cli/ui/spinner/spin_group'
 
       PERIOD = 0.1 # seconds
       TASK_FAILED = :task_failed
 
-      RUNES = CLI::UI::OS.current.supports_emoji? ? %w(⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏).freeze : %w(\\ | / - \\ | / -).freeze
+      RUNES = if CLI::UI::OS.current.use_emoji?
+        ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'].freeze
+      else
+        ['\\', '|', '/', '-', '\\', '|', '/', '-'].freeze
+      end
 
       colors = [CLI::UI::Color::CYAN.code] * (RUNES.size / 2).ceil +
         [CLI::UI::Color::MAGENTA.code] * (RUNES.size / 2).to_i
       GLYPHS = colors.zip(RUNES).map(&:join)
 
       class << self
+        extend T::Sig
+
+        sig { returns(T.nilable(Integer)) }
         attr_accessor(:index)
 
         # We use this from CLI::UI::Widgets::Status to render an additional
@@ -29,37 +40,46 @@ module CLI
         # While it would be possible to stitch through some connection between
         # the SpinGroup and the Widgets included in its title, this is simpler
         # in practice and seems unlikely to cause issues in practice.
+        sig { returns(String) }
         def current_rune
           RUNES[index || 0]
         end
       end
 
-      # Adds a single spinner
-      # Uses an interactive session to allow the user to pick an answer
-      # Can use arrows, y/n, numbers (1/2), and vim bindings to control
-      #
-      # https://user-images.githubusercontent.com/3074765/33798295-d94fd822-dce3-11e7-819b-43e5502d490e.gif
-      #
-      # ==== Attributes
-      #
-      # * +title+ - Title of the spinner to use
-      #
-      # ==== Options
-      #
-      # * +:auto_debrief+ - Automatically debrief exceptions? Default to true
-      #
-      # ==== Block
-      #
-      # * *spinner+ - Instance of the spinner. Can call +update_title+ to update the user of changes
-      #
-      # ==== Example Usage:
-      #
-      #   CLI::UI::Spinner.spin('Title') { sleep 1.0 }
-      #
-      def self.spin(title, auto_debrief: true, &block)
-        sg = SpinGroup.new(auto_debrief: auto_debrief)
-        sg.add(title, &block)
-        sg.wait
+      class << self
+        extend T::Sig
+
+        # Adds a single spinner
+        # Uses an interactive session to allow the user to pick an answer
+        # Can use arrows, y/n, numbers (1/2), and vim bindings to control
+        #
+        # https://user-images.githubusercontent.com/3074765/33798295-d94fd822-dce3-11e7-819b-43e5502d490e.gif
+        #
+        # ==== Attributes
+        #
+        # * +title+ - Title of the spinner to use
+        #
+        # ==== Options
+        #
+        # * +:auto_debrief+ - Automatically debrief exceptions or through success_debrief? Default to true
+        #
+        # ==== Block
+        #
+        # * *spinner+ - Instance of the spinner. Can call +update_title+ to update the user of changes
+        #
+        # ==== Example Usage:
+        #
+        #   CLI::UI::Spinner.spin('Title') { sleep 1.0 }
+        #
+        sig do
+          params(title: String, auto_debrief: T::Boolean, block: T.proc.params(task: SpinGroup::Task).void)
+            .returns(T::Boolean)
+        end
+        def spin(title, auto_debrief: true, &block)
+          sg = SpinGroup.new(auto_debrief: auto_debrief)
+          sg.add(title, &block)
+          sg.wait
+        end
       end
     end
   end