fluid_cli 0.1.2

data/vendor/deps/cli-ui/lib/cli/ui/widgets/status.rb

@@ -0,0 +1,79 @@
+# typed: true
+# 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 = '∅'
+
+        class << self
+          # @override
+          #: -> Regexp
+          def argparse_pattern
+            ARGPARSE_PATTERN
+          end
+        end
+
+        # @override
+        #: -> String
+        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
+
+        #: (String num_str) -> bool
+        def zero?(num_str)
+          num_str == '0'
+        end
+
+        #: (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
+
+        #: -> String
+        def succeeded_part
+          colorize_if_nonzero(@succeeded, Glyph::CHECK.char, Color::GREEN)
+        end
+
+        #: -> String
+        def failed_part
+          colorize_if_nonzero(@failed, Glyph::X.char, Color::RED)
+        end
+
+        #: -> String
+        def working_part
+          rune = zero?(@working) ? SPINNER_STOPPED : Spinner.current_rune
+          colorize_if_nonzero(@working, rune, Color::BLUE)
+        end
+
+        #: -> String
+        def pending_part
+          colorize_if_nonzero(@pending, Glyph::HOURGLASS.char, Color::WHITE)
+        end
+      end
+    end
+  end
+end

data/vendor/deps/cli-ui/lib/cli/ui/widgets.rb

@@ -0,0 +1,89 @@
+# typed: true
+# frozen_string_literal: true
+
+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')
+      autoload(:Status, 'cli/ui/widgets/status')
+
+      class << self
+        #: (String name) { -> singleton(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)`
+        #
+        #: (String handle) -> singleton(Widgets::Base)
+        def lookup(handle)
+          MAP.fetch(handle).call
+        rescue KeyError, NameError
+          raise(InvalidWidgetHandle, handle)
+        end
+
+        # All available widgets by name
+        #
+        #: -> Array[String]
+        def available
+          MAP.keys
+        end
+      end
+
+      register('status') { Widgets::Status }
+
+      class InvalidWidgetHandle < ArgumentError
+        #: (String handle) -> void
+        def initialize(handle)
+          super
+          @handle = handle
+        end
+
+        #: -> String
+        def message
+          keys = Widgets.available.join(',')
+          "invalid widget handle: #{@handle} " \
+            "-- must be one of CLI::UI::Widgets.available (#{keys})"
+        end
+      end
+
+      class InvalidWidgetArguments < ArgumentError
+        #: (String argstring, Regexp pattern) -> void
+        def initialize(argstring, pattern)
+          super(nil)
+          @argstring = argstring
+          @pattern   = pattern
+        end
+
+        #: -> String
+        def message
+          "invalid widget arguments: #{@argstring} " \
+            "-- must match pattern: #{@pattern.inspect}"
+        end
+      end
+    end
+  end
+end

data/vendor/deps/cli-ui/lib/cli/ui/work_queue.rb

@@ -0,0 +1,142 @@
+# typed: strict
+# frozen_string_literal: true
+
+module CLI
+  module UI
+    class WorkQueue
+      class Future
+        #: -> void
+        def initialize
+          @mutex = Mutex.new #: Mutex
+          @condition = ConditionVariable.new #: ConditionVariable
+          @completed = false #: bool
+          @started = false #: bool
+          @result = nil #: untyped
+          @error = nil #: Exception?
+        end
+
+        #: (untyped result) -> void
+        def complete(result)
+          @mutex.synchronize do
+            @completed = true
+            @result = result
+            @condition.broadcast
+          end
+        end
+
+        #: (Exception error) -> void
+        def fail(error)
+          @mutex.synchronize do
+            return if @completed
+
+            @completed = true
+            @error = error
+            @condition.broadcast
+          end
+        end
+
+        #: -> untyped
+        def value
+          @mutex.synchronize do
+            @condition.wait(@mutex) until @completed
+            raise @error if @error
+
+            @result
+          end
+        end
+
+        #: -> bool
+        def completed?
+          @mutex.synchronize { @completed }
+        end
+
+        #: -> bool
+        def started?
+          @mutex.synchronize { @started }
+        end
+
+        #: -> void
+        def start
+          @mutex.synchronize do
+            @started = true
+            @condition.broadcast
+          end
+        end
+      end
+
+      #: (Integer max_concurrent) -> void
+      def initialize(max_concurrent)
+        @max_concurrent = max_concurrent
+        @queue = Queue.new #: Queue
+        @mutex = Mutex.new #: Mutex
+        @condition = ConditionVariable.new #: ConditionVariable
+        @workers = [] #: Array[Thread]
+      end
+
+      #: { -> untyped } -> Future
+      def enqueue(&block)
+        future = Future.new
+        @mutex.synchronize do
+          start_worker if @workers.size < @max_concurrent
+        end
+        @queue.push([future, block])
+        future
+      end
+
+      #: -> void
+      def close
+        @queue.close
+      end
+
+      #: -> void
+      def wait
+        @queue.close
+        @workers.each(&:join)
+      end
+
+      #: -> void
+      def interrupt
+        @mutex.synchronize do
+          @queue.close
+          # Fail any remaining tasks in the queue
+          until @queue.empty?
+            future, _block = @queue.pop(true)
+            future&.fail(Interrupt.new)
+          end
+          # Interrupt all worker threads
+          @workers.each { |worker| worker.raise(Interrupt) if worker.alive? }
+          @workers.each(&:join)
+          @workers.clear
+        end
+      end
+
+      private
+
+      #: -> void
+      def start_worker
+        @workers << Thread.new do
+          loop do
+            work = @queue.pop
+            break if work.nil?
+
+            future, block = work
+
+            begin
+              future.start
+              result = block.call
+              future.complete(result)
+            rescue Interrupt => e
+              future.fail(e)
+              raise # Always re-raise interrupts to terminate the worker
+            rescue StandardError => e
+              future.fail(e)
+              # Don't re-raise standard errors - allow worker to continue
+            end
+          end
+        rescue Interrupt
+          # Clean exit on interrupt
+        end
+      end
+    end
+  end
+end

data/vendor/deps/cli-ui/lib/cli/ui/wrap.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+# typed: true
+# frozen_string_literal: true
+
+require 'cli/ui'
+require 'cli/ui/frame/frame_stack'
+require 'cli/ui/frame/frame_style'
+
+module CLI
+  module UI
+    class Wrap
+      #: (String input) -> void
+      def initialize(input)
+        @input = input
+      end
+
+      #: (?Integer total_width) -> String
+      def wrap(total_width = Terminal.width)
+        max_width = total_width - Frame.prefix_width
+        width = 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('|')
+        codes = ''
+        @input.split(/(?=\s|\x1b\[[\d;]+m|\r)|(?<=\s|#{format_codes})/).each do |token|
+          case token
+          when '\x1B[0?m'
+            codes = ''
+            final << token
+          when /\x1b\[[\d;]+m/
+            codes += token # Track in use format codes so that they are resent after frame coloring
+            final << token
+          when "\n"
+            final << "\n#{codes}"
+            width = 0
+          when /\s/
+            token_width = ANSI.printing_width(token)
+            if width + token_width <= max_width
+              final << token
+              width += token_width
+            else
+              final << "\n#{codes}"
+              width = 0
+            end
+          else
+            token_width = ANSI.printing_width(token)
+            if width + token_width <= max_width
+              final << token
+              width += token_width
+            else
+              final << "\n#{codes}"
+              final << token
+              width = token_width
+            end
+          end
+        end
+        final.join
+      end
+    end
+  end
+end