cli-ui 1.2.2 → 1.5.1

data/lib/cli/ui/prompt/options_handler.rb

@@ -15,8 +15,13 @@ module CLI
           @options[option] = handler
         end
 
-        def call(option)
-          @options[option].call(option)
+        def call(options)
+          case options
+          when Array
+            options.map { |option| @options[option].call(options) }
+          else
+            @options[options].call(options)
+          end
         end
       end
     end

data/lib/cli/ui/spinner.rb

@@ -1,3 +1,4 @@
+# frozen-string-literal: true
 require 'cli/ui'
 
 module CLI
@@ -9,11 +10,28 @@ module CLI
       PERIOD = 0.1 # seconds
       TASK_FAILED = :task_failed
 
-      begin
-        runes = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
-        colors = [CLI::UI::Color::CYAN.code] * 5 + [CLI::UI::Color::MAGENTA.code] * 5
-        raise unless runes.size == colors.size
-        GLYPHS = colors.zip(runes).map(&:join)
+      RUNES = CLI::UI::OS.current.supports_emoji? ? %w(⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏).freeze : %w(\\ | / - \\ | / -).freeze
+
+      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
+        attr_accessor(:index)
+
+        # We use this from CLI::UI::Widgets::Status to render an additional
+        # spinner next to the "working" element. While this global state looks
+        # a bit repulsive at first, it's worth realizing that:
+        #
+        # * It's managed by the SpinGroup#wait method, not individual tasks; and
+        # * It would be complete insanity to run two separate but concurrent SpinGroups.
+        #
+        # 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.
+        def current_rune
+          RUNES[index || 0]
+        end
       end
 
       # Adds a single spinner

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

@@ -25,6 +25,7 @@ module CLI
           @consumed_lines = 0
           @tasks = []
           @auto_debrief = auto_debrief
+          @start = Time.new
         end
 
         class Task
@@ -40,6 +41,7 @@ module CLI
           #
           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)
               begin
@@ -50,8 +52,9 @@ module CLI
               end
             end
 
+            @m = Mutex.new
             @force_full_render = false
-            @done      = false
+            @done = false
             @exception = nil
             @success   = false
           end
@@ -75,7 +78,17 @@ module CLI
             @done
           end
 
-          # Re-renders the task if required
+          # Re-renders the task if required:
+          #
+          # We try to be as lazy as possible in re-rendering the full line. The
+          # spinner rune will change on each render for the most part, but the
+          # body text will rarely have changed. If the body text *has* changed,
+          # we set @force_full_render.
+          #
+          # Further, if the title string includes any CLI::UI::Widgets, we
+          # assume that it may change from render to render, since those
+          # evaluate more dynamically than the rest of our format codes, which
+          # are just text formatters. This is controlled by @always_full_render.
           #
           # ==== Attributes
           #
@@ -84,10 +97,15 @@ module CLI
           # * +width+ - current terminal width to format for
           #
           def render(index, force = true, width: CLI::UI::Terminal.width)
-            return full_render(index, width) if force || @force_full_render
-            partial_render(index)
-          ensure
-            @force_full_render = false
+            @m.synchronize do
+              if force || @always_full_render || @force_full_render
+                full_render(index, width)
+              else
+                partial_render(index)
+              end
+            ensure
+              @force_full_render = false
+            end
           end
 
           # Update the spinner title
@@ -97,8 +115,11 @@ module CLI
           # * +title+ - title to change the spinner to
           #
           def update_title(new_title)
-            @title = new_title
-            @force_full_render = true
+            @m.synchronize do
+              @always_full_render = new_title =~ Formatter::SCAN_WIDGET
+              @title = new_title
+              @force_full_render = true
+            end
           end
 
           private
@@ -182,7 +203,7 @@ module CLI
                     @consumed_lines += 1
                   else
                     offset = @consumed_lines - int_index
-                    move_to   = CLI::UI::ANSI.cursor_up(offset) + "\r"
+                    move_to = CLI::UI::ANSI.cursor_up(offset) + "\r"
                     move_from = "\r" + CLI::UI::ANSI.cursor_down(offset)
 
                     print(move_to + task.render(idx, idx.zero?, width: width) + move_from)
@@ -194,6 +215,7 @@ module CLI
             break if all_done
 
             idx = (idx + 1) % GLYPHS.size
+            Spinner.index = idx
             sleep(PERIOD)
           end
 
@@ -217,18 +239,18 @@ module CLI
               out = task.stdout
               err = task.stderr
 
-              CLI::UI::Frame.open('Task Failed: ' + task.title, color: :red) do
+              CLI::UI::Frame.open('Task Failed: ' + task.title, color: :red, timing: Time.new - @start) do
                 if e
                   puts "#{e.class}: #{e.message}"
                   puts "\tfrom #{e.backtrace.join("\n\tfrom ")}"
                 end
 
                 CLI::UI::Frame.divider('STDOUT')
-                out = "(empty)" if out.nil? || out.strip.empty?
+                out = '(empty)' if out.nil? || out.strip.empty?
                 puts out
 
                 CLI::UI::Frame.divider('STDERR')
-                err = "(empty)" if err.nil? || err.strip.empty?
+                err = '(empty)' if err.nil? || err.strip.empty?
                 puts err
               end
             end

data/lib/cli/ui/stdout_router.rb

@@ -26,13 +26,14 @@ module CLI
             end
           end
 
-          hook = Thread.current[:cliui_output_hook]
           # hook return of false suppresses output.
-          if !hook || hook.call(args.first, @name) != false
-            @stream.write_without_cli_ui(*prepend_id(@stream, args))
-            if dup = StdoutRouter.duplicate_output_to
-              dup.write(*prepend_id(dup, args))
-            end
+          if (hook = Thread.current[:cliui_output_hook])
+            return if hook.call(args.map(&:to_s).join, @name) == false
+          end
+
+          @stream.write_without_cli_ui(*prepend_id(@stream, args))
+          if (dup = StdoutRouter.duplicate_output_to)
+            dup.write(*prepend_id(dup, args))
           end
         end
 
@@ -117,6 +118,10 @@ module CLI
           prev_frame_inset = Thread.current[:no_cliui_frame_inset]
           prev_hook = Thread.current[:cliui_output_hook]
 
+          if Thread.current.respond_to?(:report_on_exception)
+            Thread.current.report_on_exception = false
+          end
+
           self.class.with_stdin_masked do
             Thread.current[:no_cliui_frame_inset] = !@with_frame_inset
             Thread.current[:cliui_output_hook] = ->(data, stream) do
@@ -156,10 +161,10 @@ module CLI
           end
 
           require 'securerandom'
-          id = format("%05d", rand(10**5))
+          id = format('%05d', rand(10**5))
           Thread.current[:cliui_output_id] = {
             id: id,
-            streams: on_streams
+            streams: on_streams,
           }
           yield(id)
         ensure

data/lib/cli/ui/terminal.rb

@@ -8,28 +8,38 @@ module CLI
       DEFAULT_HEIGHT = 24
 
       # Returns the width of the terminal, if possible
-      # Otherwise will return 80
+      # Otherwise will return DEFAULT_WIDTH
       #
       def self.width
-        if console = IO.respond_to?(:console) && IO.console
-          width = console.winsize[1]
-          width.zero? ? DEFAULT_WIDTH : width
-        else
-          DEFAULT_WIDTH
-        end
-      rescue Errno::EIO
-        DEFAULT_WIDTH
+        winsize[1]
       end
 
+      # Returns the width of the terminal, if possible
+      # Otherwise, will return DEFAULT_HEIGHT
+      #
       def self.height
-        if console = IO.respond_to?(:console) && IO.console
-          height = console.winsize[0]
-          height.zero? ? DEFAULT_HEIGHT : height
-        else
-          DEFAULT_HEIGHT
+        winsize[0]
+      end
+
+      def self.winsize
+        @winsize ||= begin
+          winsize = IO.console.winsize
+          setup_winsize_trap
+
+          if winsize.any?(&:zero?)
+            [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
         end
-      rescue Errno::EIO
-        DEFAULT_HEIGHT
       end
     end
   end

data/lib/cli/ui/truncater.rb

@@ -52,11 +52,11 @@ module CLI
                 end
               end
             when PARSE_ESC
-              case cp
+              mode = case cp
               when LEFT_SQUARE_BRACKET
-                mode = PARSE_ANSI
+                PARSE_ANSI
               else
-                mode = PARSE_ROOT
+                PARSE_ROOT
               end
             when PARSE_ANSI
               # ANSI escape codes preeeetty much have the format of:
@@ -83,7 +83,7 @@ module CLI
           # the end of the string.
           return text if !truncation_index || width <= printing_width
 
-          codepoints[0...truncation_index].pack("U*") + TRUNCATED
+          codepoints[0...truncation_index].pack('U*') + TRUNCATED
         end
 
         private

data/lib/cli/ui/version.rb

@@ -1,5 +1,5 @@
 module CLI
   module UI
-    VERSION = "1.2.2"
+    VERSION = '1.5.1'
   end
 end

data/lib/cli/ui/widgets.rb

@@ -0,0 +1,77 @@
+require('cli/ui')
+
+module CLI
+  module UI
+    # Widgets are formatter objects with more custom implementations than the
+    # other features, which all center around formatting text with colours,
+    # etc.
+    #
+    # If you want to extend CLI::UI with your own widgets, you may want to do
+    # something like this:
+    #
+    #   require('cli/ui')
+    #   class MyWidget < CLI::UI::Widgets::Base
+    #     # ...
+    #   end
+    #   CLI::UI::Widgets.register('my-widget') { MyWidget }
+    #   puts(CLI::UI.fmt("{{@widget/my-widget:args}}"))
+    module Widgets
+      MAP = {}
+
+      autoload(:Base, 'cli/ui/widgets/base')
+
+      def self.register(name, &cb)
+        MAP[name] = cb
+      end
+
+      autoload(:Status, 'cli/ui/widgets/status')
+      register('status') { Widgets::Status }
+
+      # 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
+
+      # All available widgets by name
+      #
+      def self.available
+        MAP.keys
+      end
+
+      class InvalidWidgetHandle < ArgumentError
+        def initialize(handle)
+          super
+          @handle = handle
+        end
+
+        def message
+          keys = Widget.available.join(',')
+          "invalid widget handle: #{@handle} " \
+            "-- must be one of CLI::UI::Widgets.available (#{keys})"
+        end
+      end
+
+      class InvalidWidgetArguments < ArgumentError
+        def initialize(argstring, pattern)
+          super
+          @argstring = argstring
+          @pattern   = pattern
+        end
+
+        def message
+          "invalid widget arguments: #{@argstring} " \
+            "-- must match pattern: #{@pattern.inspect}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require('cli/ui')
+
+module CLI
+  module UI
+    module Widgets
+      class Base
+        def self.call(argstring)
+          new(argstring).render
+        end
+
+        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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen-string-literal: true
+require('cli/ui')
+
+module CLI
+  module UI
+    module Widgets
+      class Status < Widgets::Base
+        ARGPARSE_PATTERN = %r{
+          \A (?<succeeded> \d+)
+          :  (?<failed>    \d+)
+          :  (?<working>   \d+)
+          :  (?<pending>   \d+) \z
+        }x # e.g. "1:23:3:404"
+        OPEN  = Color::RESET.code + Color::BOLD.code + '[' + Color::RESET.code
+        CLOSE = Color::RESET.code + Color::BOLD.code + ']' + Color::RESET.code
+        ARROW = Color::RESET.code + Color::GRAY.code + '◂' + Color::RESET.code
+        COMMA = Color::RESET.code + Color::GRAY.code + ',' + Color::RESET.code
+
+        SPINNER_STOPPED = '⠿'
+        EMPTY_SET = '∅'
+
+        def render
+          if zero?(@succeeded) && zero?(@failed) && zero?(@working) && zero?(@pending)
+            Color::RESET.code + Color::BOLD.code + EMPTY_SET + Color::RESET.code
+          else
+            #   [          0✓            ,         2✗          ◂         3⠼           ◂         4⌛︎           ]
+            "#{OPEN}#{succeeded_part}#{COMMA}#{failed_part}#{ARROW}#{working_part}#{ARROW}#{pending_part}#{CLOSE}"
+          end
+        end
+
+        private
+
+        def zero?(num_str)
+          num_str == '0'
+        end
+
+        def colorize_if_nonzero(num_str, rune, color)
+          color = Color::GRAY if zero?(num_str)
+          color.code + num_str + rune
+        end
+
+        def succeeded_part
+          colorize_if_nonzero(@succeeded, Glyph::CHECK.char, Color::GREEN)
+        end
+
+        def failed_part
+          colorize_if_nonzero(@failed, Glyph::X.char, Color::RED)
+        end
+
+        def working_part
+          rune = zero?(@working) ? SPINNER_STOPPED : Spinner.current_rune
+          colorize_if_nonzero(@working, rune, Color::BLUE)
+        end
+
+        def pending_part
+          colorize_if_nonzero(@pending, Glyph::HOURGLASS.char, Color::WHITE)
+        end
+      end
+    end
+  end
+end