fluid_cli 0.1.2

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

@@ -0,0 +1,286 @@
+# 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
+    module Frame
+      class UnnestedFrameException < StandardError; end
+      DEFAULT_FRAME_COLOR = CLI::UI.resolve_color(:cyan)
+
+      class << self
+        #: -> FrameStyle
+        def frame_style
+          @frame_style ||= FrameStyle::Box
+        end
+
+        # Set the default frame style.
+        #
+        # Raises ArgumentError if +frame_style+ is not valid
+        #
+        # ==== Attributes
+        #
+        # * +symbol+ or +FrameStyle+ - the default frame style to use for frames
+        #
+        #: (frame_stylable frame_style) -> void
+        def frame_style=(frame_style)
+          @frame_style = CLI::UI.resolve_style(frame_style)
+        end
+
+        # Opens a new frame. Can be nested
+        # Can be invoked in two ways: block and blockless
+        # * In block form, the frame is closed automatically when the block returns
+        # * In blockless form, caller MUST call +Frame.close+ when the frame is logically done
+        # * Blockless form is strongly discouraged in cases where block form can be made to work
+        #
+        # https://user-images.githubusercontent.com/3074765/33799861-cb5dcb5c-dd01-11e7-977e-6fad38cee08c.png
+        #
+        # The return value of the block determines if the block is a "success" or a "failure"
+        #
+        # ==== Attributes
+        #
+        # * +text+ - (required) the text/title to output in the frame
+        #
+        # ==== Options
+        #
+        # * +:color+ - The color of the frame. Defaults to +DEFAULT_FRAME_COLOR+
+        # * +:failure_text+ - If the block failed, what do we output? Defaults to nil
+        # * +:success_text+ - If the block succeeds, what do we output? Defaults to nil
+        # * +:timing+ - How long did the frame content take? Invalid for blockless. Defaults to true for the block form
+        # * +frame_style+ - The frame style to use for this frame
+        # * +:to+ - Target stream, like $stdout or $stderr. Can be anything with print and puts methods,
+        #   or under Sorbet, IO or StringIO. Defaults to $stdout.
+        #
+        # ==== Example
+        #
+        # ===== Block Form (Assumes +CLI::UI::StdoutRouter.enable+ has been called)
+        #
+        #   CLI::UI::Frame.open('Open') { puts 'hi' }
+        #
+        # Default Output:
+        #   ┏━━ Open ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        #   ┃ hi
+        #   ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ (0.0s) ━━
+        #
+        # ===== Blockless Form
+        #
+        #   CLI::UI::Frame.open('Open')
+        #
+        # Default Output:
+        #   ┏━━ Open ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        #
+        #
+        #: [T] (String text, ?color: colorable, ?failure_text: String?, ?success_text: String?, ?timing: (Numeric | bool), ?frame_style: frame_stylable, ?to: io_like) ?{ -> T } -> T?
+        def open(
+          text,
+          color: DEFAULT_FRAME_COLOR,
+          failure_text: nil,
+          success_text: nil,
+          timing: block_given?,
+          frame_style: self.frame_style,
+          to: $stdout,
+          &block
+        )
+          frame_style = CLI::UI.resolve_style(frame_style)
+          color = CLI::UI.resolve_color(color)
+
+          unless block_given?
+            if failure_text
+              raise ArgumentError, 'failure_text is not compatible with blockless invocation'
+            elsif success_text
+              raise ArgumentError, 'success_text is not compatible with blockless invocation'
+            elsif timing
+              raise ArgumentError, 'timing is not compatible with blockless invocation'
+            end
+          end
+
+          t_start = Time.now
+          CLI::UI.raw do
+            to.print(prefix.chop)
+            to.puts(frame_style.start(text, color: color))
+          end
+          FrameStack.push(color: color, style: frame_style)
+
+          return unless block_given?
+
+          closed = false
+          begin
+            success = false #: untyped
+            success = yield
+          rescue
+            closed = true
+            t_diff = elapsed(t_start, timing)
+            close(failure_text, color: :red, elapsed: t_diff, to: to)
+            raise
+          else
+            success
+          ensure
+            unless closed
+              t_diff = elapsed(t_start, timing)
+              success_bool = success #: as untyped
+              if success_bool != false
+                close(success_text, color: color, elapsed: t_diff, to: to)
+              else
+                close(failure_text, color: :red, elapsed: t_diff, to: to)
+              end
+            end
+          end
+        end
+
+        # Adds a divider in a frame
+        # Used to separate information within a single frame
+        #
+        # ==== Attributes
+        #
+        # * +text+ - (required) the text/title to output in the frame
+        #
+        # ==== Options
+        #
+        # * +:color+ - The color of the frame. Defaults to +DEFAULT_FRAME_COLOR+
+        # * +frame_style+ - The frame style to use for this frame
+        # * +:to+ - Target stream, like $stdout or $stderr. Can be anything with print and puts methods,
+        #   or under Sorbet, IO or StringIO. Defaults to $stdout.
+        #
+        # ==== Example
+        #
+        #   CLI::UI::Frame.open('Open') { CLI::UI::Frame.divider('Divider') }
+        #
+        # Default Output:
+        #   ┏━━ Open ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        #   ┣━━ Divider ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        #   ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        #
+        # ==== Raises
+        #
+        # MUST be inside an open frame or it raises a +UnnestedFrameException+
+        #
+        #: (String? text, ?color: colorable?, ?frame_style: frame_stylable?, ?to: io_like) -> void
+        def divider(text, color: nil, frame_style: nil, to: $stdout)
+          fs_item = FrameStack.pop
+          raise UnnestedFrameException, 'No frame nesting to unnest' unless fs_item
+
+          divider_color = CLI::UI.resolve_color(color || fs_item.color)
+          frame_style = CLI::UI.resolve_style(frame_style || fs_item.frame_style)
+
+          CLI::UI.raw do
+            to.print(prefix.chop)
+            to.puts(frame_style.divider(text.to_s, color: divider_color))
+          end
+
+          FrameStack.push(fs_item)
+        end
+
+        # Closes a frame
+        # Automatically called for a block-form +open+
+        #
+        # ==== Attributes
+        #
+        # * +text+ - (required) the text/title to output in the frame
+        #
+        # ==== Options
+        #
+        # * +:color+ - The color of the frame. Defaults to nil
+        # * +:elapsed+ - How long did the frame take? Defaults to nil
+        # * +frame_style+ - The frame style to use for this frame.  Defaults to nil
+        # * +:to+ - Target stream, like $stdout or $stderr. Can be anything with print and puts methods,
+        #   or under Sorbet, IO or StringIO. Defaults to $stdout.
+        #
+        # ==== Example
+        #
+        #   CLI::UI::Frame.close('Close')
+        #
+        # Default Output:
+        #   ┗━━ Close ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        #
+        # ==== Raises
+        #
+        # MUST be inside an open frame or it raises a +UnnestedFrameException+
+        #
+        #: (String? text, ?color: colorable?, ?elapsed: Numeric?, ?frame_style: frame_stylable?, ?to: io_like) -> void
+        def close(text, color: nil, elapsed: nil, frame_style: nil, to: $stdout)
+          fs_item = FrameStack.pop
+          raise UnnestedFrameException, 'No frame nesting to unnest' unless fs_item
+
+          close_color = CLI::UI.resolve_color(color || fs_item.color)
+          frame_style = CLI::UI.resolve_style(frame_style || fs_item.frame_style)
+          elapsed_string = elapsed ? "(#{elapsed.round(2)}s)" : nil
+
+          CLI::UI.raw do
+            to.print(prefix.chop)
+            to.puts(frame_style.close(text.to_s, color: close_color, right_text: elapsed_string))
+          end
+        end
+
+        # Determines the prefix of a frame entry taking multi-nested frames into account
+        #
+        # ==== Options
+        #
+        # * +:color+ - The color of the prefix. Defaults to +Thread.current[:cliui_frame_color_override]+
+        #
+        #: (?color: colorable?) -> String
+        def prefix(color: Thread.current[:cliui_frame_color_override])
+          (+'').tap do |output|
+            items = FrameStack.items
+
+            items[0..-2].to_a.each do |item|
+              output << item.color.code if CLI::UI.enable_color?
+              output << item.frame_style.prefix
+              output << CLI::UI::Color::RESET.code if CLI::UI.enable_color?
+            end
+
+            if (item = items.last)
+              final_color = color || item.color
+              output << CLI::UI.resolve_color(final_color).code if CLI::UI.enable_color?
+              output << item.frame_style.prefix
+              output << CLI::UI::Color::RESET.code if CLI::UI.enable_color?
+              output << ' '
+            end
+          end
+        end
+
+        # The width of a prefix given the number of Frames in the stack
+        #: -> Integer
+        def prefix_width
+          w = FrameStack.items.reduce(0) do |width, item|
+            width + item.frame_style.prefix_width
+          end
+
+          w.zero? ? w : w + 1
+        end
+
+        # Override a color for a given thread.
+        #
+        # ==== Attributes
+        #
+        # * +color+ - The color to override to
+        #
+        #: [T] (colorable color) { -> T } -> T
+        def with_frame_color_override(color, &block)
+          prev = Thread.current[:cliui_frame_color_override]
+          Thread.current[:cliui_frame_color_override] = color
+          yield
+        ensure
+          Thread.current[:cliui_frame_color_override] = prev
+        end
+
+        private
+
+        # If timing is:
+        #   Numeric: return it
+        #   false: return nil
+        #   true: defaults to Time.new
+        #: (Time start, (Numeric | bool) timing) -> Numeric?
+        def elapsed(start, timing)
+          return timing if timing.is_a?(Numeric)
+          return if timing.is_a?(FalseClass)
+
+          timing = Time.new
+          timing - start
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'cli/ui'
+
+module CLI
+  module UI
+    class Glyph
+      class InvalidGlyphHandle < ArgumentError
+        #: (String handle) -> void
+        def initialize(handle)
+          super
+          @handle = handle
+        end
+
+        #: -> String
+        def message
+          keys = Glyph.available.join(',')
+          "invalid glyph handle: #{@handle} " \
+            "-- must be one of CLI::UI::Glyph.available (#{keys})"
+        end
+      end
+
+      #: String
+      attr_reader :handle, :to_s, :fmt, :char
+
+      #: (Integer | Array[Integer])
+      attr_reader :codepoint
+
+      #: Color
+      attr_reader :color
+
+      # Creates a new glyph
+      #
+      # ==== Attributes
+      #
+      # * +handle+ - The handle in the +MAP+ constant
+      # * +codepoint+ - The codepoint used to create the glyph (e.g. +0x2717+ for a ballot X)
+      # * +plain+ - A fallback plain string to be used in case glyphs are disabled
+      # * +color+ - What color to output the glyph. Check +CLI::UI::Color+ for options.
+      #
+      #: (String handle, (Integer | Array[Integer]) codepoint, String plain, Color color) -> void
+      def initialize(handle, codepoint, plain, color)
+        @handle    = handle
+        @codepoint = codepoint
+        @color     = color
+        @char      = CLI::UI::OS.current.use_emoji? ? Array(codepoint).pack('U*') : plain
+        @to_s      = color.code + @char + Color::RESET.code
+        @fmt       = "{{#{color.name}:#{@char}}}"
+
+        MAP[handle] = self
+      end
+
+      # Mapping of glyphs to terminal output
+      MAP = {}
+      STAR      = new('*', 0x2b51,           '*', Color::YELLOW) # YELLOW SMALL STAR (⭑)
+      INFO      = new('i', 0x1d4be,          'i', Color::BLUE)   # BLUE MATHEMATICAL SCRIPT SMALL i (𝒾)
+      QUESTION  = new('?', 0x003f,           '?', Color::BLUE)   # BLUE QUESTION MARK (?)
+      CHECK     = new('v', 0x2713,           '√', Color::GREEN)  # GREEN CHECK MARK (✓)
+      X         = new('x', 0x2717,           'X', Color::RED)    # RED BALLOT X (✗)
+      BUG       = new('b', 0x1f41b,          '!', Color::WHITE)  # Bug emoji (🐛)
+      CHEVRON   = new('>', 0xbb,             '»', Color::YELLOW) # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK (»)
+      HOURGLASS = new('H', 0x29d6,           'H', Color::ORANGE) # HOURGLASS (⧖)
+      WARNING   = new('!', [0x26a0, 0xfe0f], '!', Color::YELLOW) # WARNING SIGN + VARIATION SELECTOR 16 (⚠️ )
+
+      class << self
+        # Looks up a glyph by name
+        #
+        # ==== Raises
+        # Raises a InvalidGlyphHandle if the glyph is not available
+        # You likely need to create it with +.new+ or you made a typo
+        #
+        # ==== Returns
+        # Returns a terminal output-capable string
+        #
+        #: (String name) -> Glyph
+        def lookup(name)
+          MAP.fetch(name.to_s)
+        rescue KeyError
+          raise InvalidGlyphHandle, name
+        end
+
+        # All available glyphs by name
+        #
+        #: -> Array[String]
+        def available
+          MAP.keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+module CLI
+  module UI
+    class OS
+      #: (?emoji: bool, ?color_prompt: bool, ?arrow_keys: bool, ?shift_cursor: bool) -> void
+      def initialize(emoji: true, color_prompt: true, arrow_keys: true, shift_cursor: false)
+        @emoji = emoji
+        @color_prompt = color_prompt
+        @arrow_keys = arrow_keys
+        @shift_cursor = shift_cursor
+      end
+
+      #: -> bool
+      def use_emoji?
+        @emoji
+      end
+
+      #: -> bool
+      def use_color_prompt?
+        @color_prompt
+      end
+
+      #: -> bool
+      def suggest_arrow_keys?
+        @arrow_keys
+      end
+
+      #: -> bool
+      def shift_cursor_back_on_horizontal_absolute?
+        @shift_cursor
+      end
+
+      class << self
+        #: -> OS
+        def current
+          @current_os ||= case RbConfig::CONFIG['host_os']
+          when /darwin/
+            MAC
+          when /linux/
+            LINUX
+          when /freebsd/
+            FREEBSD
+          else
+            if RUBY_PLATFORM !~ /cygwin/ && ENV['OS'] == 'Windows_NT'
+              WINDOWS
+            else
+              raise "Could not determine OS from host_os #{RbConfig::CONFIG["host_os"]}"
+            end
+          end
+        end
+      end
+
+      MAC = OS.new
+      LINUX = OS.new
+      FREEBSD = OS.new
+      WINDOWS = OS.new(emoji: false, color_prompt: false, arrow_keys: false, shift_cursor: true)
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'cli/ui'
+
+module CLI
+  module UI
+    class Printer
+      class << self
+        # Print a message to a stream with common utilities.
+        # Allows overriding the color, encoding, and target stream.
+        # By default, it formats the string using CLI:UI and rescues common stream errors.
+        #
+        # ==== Attributes
+        #
+        # * +msg+ - (required) the string to output. Can be frozen.
+        #
+        # ==== Options
+        #
+        # * +:frame_color+ - Override the frame color. Defaults to nil.
+        # * +:to+ - Target stream, like $stdout or $stderr. Can be anything with a puts method. Defaults to $stdout.
+        # * +:encoding+ - Force the output to be in a certain encoding. Defaults to UTF-8.
+        # * +:format+ - Whether to format the string using CLI::UI.fmt. Defaults to true.
+        # * +:graceful+ - Whether to gracefully ignore common I/O errors. Defaults to true.
+        # * +:wrap+ - Whether to wrap text at word boundaries to terminal width. Defaults to true.
+        #
+        # ==== Returns
+        # Returns whether the message was successfully printed,
+        # which can be useful if +:graceful+ is set to true.
+        #
+        # ==== Example
+        #
+        #   CLI::UI::Printer.puts('{{x}} Ouch', to: $stderr)
+        #
+        #: (String msg, ?frame_color: colorable?, ?to: io_like, ?encoding: Encoding?, ?format: bool, ?graceful: bool, ?wrap: bool) -> bool
+        def puts(
+          msg,
+          frame_color: nil,
+          to: $stdout,
+          encoding: Encoding::UTF_8,
+          format: true,
+          graceful: true,
+          wrap: true
+        )
+          msg = (+msg).force_encoding(encoding) if encoding
+          msg = CLI::UI.fmt(msg) if format
+          msg = CLI::UI.wrap(msg) if wrap
+
+          if frame_color
+            CLI::UI::Frame.with_frame_color_override(frame_color) { to.puts(msg) }
+          else
+            to.puts(msg)
+          end
+
+          true
+        rescue Errno::EIO, Errno::EPIPE, IOError => e
+          raise(e) unless graceful
+
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'cli/ui'
+
+module CLI
+  module UI
+    class Progress
+      # A Cyan filled block
+      FILLED_BAR = "\e[46m"
+      # A bright white block
+      UNFILLED_BAR = "\e[1;47m"
+
+      class << self
+        # Add a progress bar to the terminal output
+        #
+        # https://user-images.githubusercontent.com/3074765/33799794-cc4c940e-dd00-11e7-9bdc-90f77ec9167c.gif
+        #
+        # ==== Example Usage:
+        #
+        # Set the percent to X
+        #   CLI::UI::Progress.progress do |bar|
+        #     bar.tick(set_percent: percent)
+        #   end
+        #
+        # Increase the percent by 1 percent
+        #   CLI::UI::Progress.progress do |bar|
+        #     bar.tick
+        #   end
+        #
+        # Increase the percent by X
+        #   CLI::UI::Progress.progress do |bar|
+        #     bar.tick(percent: 0.05)
+        #   end
+        #
+        # Update the title
+        #   CLI::UI::Progress.progress('Title') do |bar|
+        #     bar.tick(percent: 0.05)
+        #     bar.update_title('New title')
+        #   end
+        #: [T] (?String? title, ?width: Integer) { (Progress bar) -> T } -> T
+        def progress(title = nil, width: Terminal.width, &block)
+          bar = nil #: Progress?
+          CLI::UI::ProgressReporter.with_progress(mode: :progress) do |reporter|
+            bar = Progress.new(title, width: width, reporter: reporter)
+            print(CLI::UI::ANSI.hide_cursor)
+            yield(bar)
+          end
+        ensure
+          puts(bar) if bar
+
+          CLI::UI.raw do
+            print(ANSI.show_cursor)
+          end
+        end
+      end
+
+      # Initialize a progress bar. Typically used in a +Progress.progress+ block
+      #
+      # ==== Options
+      #
+      # * +:title+ - The title of the progress bar
+      # * +:width+ - The width of the terminal
+      # * +:reporter+ - The progress reporter instance
+      #
+      #: (?String? title, ?width: Integer, ?reporter: ProgressReporter::Reporter?) -> void
+      def initialize(title = nil, width: Terminal.width, reporter: nil)
+        @percent_done = 0 #: Numeric
+        @title = title
+        @max_width = width
+        @reporter = reporter
+      end
+
+      # Set the progress of the bar. Typically used in a +Progress.progress+ block
+      #
+      # ==== Options
+      # One of the follow can be used, but not both together
+      #
+      # * +:percent+ - Increment progress by a specific percent amount
+      # * +:set_percent+ - Set progress to a specific percent
+      #
+      # *Note:* The +:percent+ and +:set_percent must be between 0.00 and 1.0
+      #
+      #: (?percent: Numeric?, ?set_percent: Numeric?) -> void
+      def tick(percent: nil, set_percent: nil)
+        raise ArgumentError, 'percent and set_percent cannot both be specified' if percent && set_percent
+
+        @percent_done += percent || 0.01
+        @percent_done = set_percent if set_percent
+        @percent_done = [@percent_done, 1.0].min # Make sure we can't go above 1.0
+
+        # Update terminal progress reporter with current percentage
+        @reporter&.set_progress((@percent_done * 100).floor)
+
+        print(self)
+
+        printed_lines = @title ? 2 : 1
+        print(CLI::UI::ANSI.previous_lines(printed_lines) + "\n")
+      end
+
+      # Update the progress bar title
+      #
+      # ==== Attributes
+      #
+      # * +new_title+ - title to change the progress bar to
+      #
+      #: (String new_title) -> void
+      def update_title(new_title)
+        @title = new_title
+      end
+
+      # Format the progress bar to be printed to terminal
+      #
+      #: -> String
+      def to_s
+        suffix = " #{(@percent_done * 100).floor}%".ljust(5)
+        workable_width = @max_width - Frame.prefix_width - suffix.size
+        filled = [(@percent_done * workable_width.to_f).ceil, 0].max
+        unfilled = [workable_width - filled, 0].max
+
+        title = CLI::UI.resolve_text(@title, truncate_to: @max_width - Frame.prefix_width) if @title
+        bar = CLI::UI.resolve_text([
+          FILLED_BAR + ' ' * filled,
+          UNFILLED_BAR + ' ' * unfilled,
+          CLI::UI::Color::RESET.code + suffix,
+        ].join)
+
+        [title, bar].compact.join("\n")
+      end
+    end
+  end
+end