fluid_cli 0.1.2

data/vendor/deps/cli-kit/lib/cli/kit.rb

@@ -0,0 +1,139 @@
+# typed: true
+
+require 'cli/ui'
+require 'cli/kit/core_ext'
+
+module CLI
+  module Kit
+    autoload :Args,            'cli/kit/args'
+    autoload :BaseCommand,     'cli/kit/base_command'
+    autoload :CommandRegistry, 'cli/kit/command_registry'
+    autoload :CommandHelp,     'cli/kit/command_help'
+    autoload :Config,          'cli/kit/config'
+    autoload :ErrorHandler,    'cli/kit/error_handler'
+    autoload :Executor,        'cli/kit/executor'
+    autoload :Ini,             'cli/kit/ini'
+    autoload :Levenshtein,     'cli/kit/levenshtein'
+    autoload :Logger,          'cli/kit/logger'
+    autoload :Opts,            'cli/kit/opts'
+    autoload :ParseArgs,       'cli/kit/parse_args'
+    autoload :Resolver,        'cli/kit/resolver'
+    autoload :Support,         'cli/kit/support'
+    autoload :System,          'cli/kit/system'
+    autoload :Util,            'cli/kit/util'
+
+    EXIT_FAILURE_BUT_NOT_BUG = 30
+    EXIT_BUG                 = 1
+    EXIT_SUCCESS             = 0
+
+    UNTYPED_NIL = nil #: untyped
+    private_constant(:UNTYPED_NIL)
+
+    # Abort, Bug, AbortSilent, and BugSilent are four ways of immediately bailing
+    # on command-line execution when an unrecoverable error occurs.
+    #
+    # Note that these don't inherit from StandardError, and so are not caught by
+    # a bare `rescue => e`.
+    #
+    # * Abort prints its message in red and exits 1;
+    # * Bug additionally submits the exception to the exception_reporter passed to
+    #     `CLI::Kit::ErrorHandler.new`
+    # * AbortSilent and BugSilent do the same as above, but do not print
+    #     messages before exiting.
+    #
+    # Treat these like panic() in Go:
+    #   * Don't rescue them. Use a different Exception class if you plan to recover;
+    #   * Provide a useful message, since it will be presented in brief to the
+    #       user, and will be useful for debugging.
+    #   * Avoid using it if it does actually make sense to recover from an error.
+    #
+    # Additionally:
+    #   * Do not subclass these.
+    #   * Only use AbortSilent or BugSilent if you prefer to print a more
+    #       contextualized error than Abort or Bug would present to the user.
+    #   * In general, don't attach a message to AbortSilent or BugSilent.
+    #   * Never raise GenericAbort directly.
+    #   * Think carefully about whether Abort or Bug is more appropriate. Is this
+    #       a bug in the tool? Or is it just user error, transient network
+    #       failure, etc.?
+    #   * One case where it's ok to rescue (cli-kit internals or tests aside):
+    #       1. rescue Abort or Bug
+    #       2. Print a contextualized error message
+    #       3. Re-raise AbortSilent or BugSilent respectively.
+    #
+    # These aren't the only exceptions that can carry this 'bug' and 'silent'
+    # metadata, however:
+    #
+    # If you raise an exception with `CLI::Kit.raise(..., bug: x, silent: y)`,
+    # those last two (optional) keyword arguments will attach the metadata to
+    # whatever exception you raise. This is interpreted later in the
+    # ErrorHandler to decide how to print output and whether to submit the
+    # exception to bugsnag.
+    GenericAbort = Class.new(Exception) # rubocop:disable Lint/InheritException
+
+    class Abort < GenericAbort # bug:false; silent: false
+      #: -> bool
+      def bug?
+        false
+      end
+    end
+
+    class Bug < GenericAbort # bug:true; silent:false
+    end
+
+    class BugSilent < GenericAbort # bug:true; silent:true
+      #: -> bool
+      def silent?
+        true
+      end
+    end
+
+    class AbortSilent < GenericAbort # bug:false; silent:true
+      #: -> bool
+      def bug?
+        false
+      end
+
+      #: -> bool
+      def silent?
+        true
+      end
+    end
+
+    class << self
+      # Mirrors the API of Kernel#raise, but with the addition of a few new
+      # optional keyword arguments. `bug` and `silent` attach metadata to the
+      # exception being raised, which is interpreted later in the ErrorHandler to
+      # decide what to print and whether to submit to bugsnag.
+      #
+      # `depth` is used to trim leading elements of the backtrace. If you wrap
+      # this method in your own wrapper, you'll want to pass `depth: 2`, for
+      # example.
+      #: (?(Class | String | Exception) exception, ?untyped string, ?Array[String]? array, ?cause: Exception?, ?bug: bool?, ?silent: bool?, ?depth: Integer) -> bot
+      def raise(
+        # default arguments
+        exception = UNTYPED_NIL,
+        string = UNTYPED_NIL,
+        array = UNTYPED_NIL,
+        cause: $ERROR_INFO,
+        # new arguments
+        bug: nil, silent: nil, depth: 1
+      )
+        k = Kernel #: as untyped
+        if array
+          k.raise(exception, string, array, cause: cause)
+        elsif string
+          k.raise(exception, string, Kernel.caller(depth), cause: cause)
+        elsif exception.is_a?(String)
+          k.raise(RuntimeError, exception, Kernel.caller(depth), cause: cause)
+        else
+          k.raise(exception, exception.message, Kernel.caller(depth), cause: cause)
+        end
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        e.bug!(bug) unless bug.nil?
+        e.silent!(silent) unless silent.nil?
+        Kernel.raise(e, cause: cause)
+      end
+    end
+  end
+end

data/vendor/deps/cli-ui/REVISION

@@ -0,0 +1 @@
+53b30b0786fd3db544ae80ae641e88f126006b88

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

@@ -0,0 +1,218 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'cli/ui'
+
+module CLI
+  module UI
+    module ANSI
+      ESC = "\x1b"
+
+      class << self
+        # ANSI escape sequences (like \x1b[31m) have zero width.
+        # when calculating the padding width, we must exclude them.
+        # This also implements a basic version of utf8 character width calculation like
+        # we could get for real from something like utf8proc.
+        #
+        #: (String str) -> Integer
+        def printing_width(str)
+          zwj = false #: bool
+          strip_codes(str).codepoints.reduce(0) do |acc, cp|
+            if zwj
+              zwj = false
+              next acc
+            end
+            case cp
+            when 0x200d # zero-width joiner
+              zwj = true
+              acc
+            when "\n"
+              acc
+            else
+              acc + 1
+            end
+          end
+        end
+
+        # Strips ANSI codes from a str
+        #
+        # ==== Attributes
+        #
+        # - +str+ - The string from which to strip codes
+        #
+        #: (String str) -> String
+        def strip_codes(str)
+          str.gsub(/\x1b\[[\d;]+[A-Za-z]|\x1b\][\d;]+.*?\x1b\\|\r/, '')
+        end
+
+        # Returns an ANSI control sequence
+        #
+        # ==== Attributes
+        #
+        # - +args+ - Argument to pass to the ANSI control sequence
+        # - +cmd+ - ANSI control sequence Command
+        #
+        #: (String args, String cmd) -> String
+        def control(args, cmd)
+          ESC + '[' + args + cmd
+        end
+
+        # https://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+        #: (String params) -> String
+        def sgr(params)
+          control(params, 'm')
+        end
+
+        # Cursor Movement
+
+        # Move the cursor up n lines
+        #
+        # ==== Attributes
+        #
+        # * +n+ - number of lines by which to move the cursor up
+        #
+        #: (?Integer n) -> String
+        def cursor_up(n = 1)
+          return '' if n.zero?
+
+          control(n.to_s, 'A')
+        end
+
+        # Move the cursor down n lines
+        #
+        # ==== Attributes
+        #
+        # * +n+ - number of lines by which to move the cursor down
+        #
+        #: (?Integer n) -> String
+        def cursor_down(n = 1)
+          return '' if n.zero?
+
+          control(n.to_s, 'B')
+        end
+
+        # Move the cursor forward n columns
+        #
+        # ==== Attributes
+        #
+        # * +n+ - number of columns by which to move the cursor forward
+        #
+        #: (?Integer n) -> String
+        def cursor_forward(n = 1)
+          return '' if n.zero?
+
+          control(n.to_s, 'C')
+        end
+
+        # Move the cursor back n columns
+        #
+        # ==== Attributes
+        #
+        # * +n+ - number of columns by which to move the cursor back
+        #
+        #: (?Integer n) -> String
+        def cursor_back(n = 1)
+          return '' if n.zero?
+
+          control(n.to_s, 'D')
+        end
+
+        # Move the cursor to a specific column
+        #
+        # ==== Attributes
+        #
+        # * +n+ - The column to move to
+        #
+        #: (?Integer n) -> String
+        def cursor_horizontal_absolute(n = 1)
+          cmd = control(n.to_s, 'G')
+          cmd += cursor_back if CLI::UI::OS.current.shift_cursor_back_on_horizontal_absolute?
+          cmd
+        end
+
+        #: -> String
+        def enter_alternate_screen
+          control('?1049', 'h')
+        end
+
+        #: -> String
+        def exit_alternate_screen
+          control('?1049', 'l')
+        end
+
+        #: -> Regexp
+        def match_alternate_screen
+          /#{Regexp.escape(control("?1049", ""))}[hl]/
+        end
+
+        # Show the cursor
+        #
+        #: -> String
+        def show_cursor
+          control('', '?25h')
+        end
+
+        # Hide the cursor
+        #
+        #: -> String
+        def hide_cursor
+          control('', '?25l')
+        end
+
+        # Save the cursor position
+        #
+        #: -> String
+        def cursor_save
+          control('', 's')
+        end
+
+        # Restore the saved cursor position
+        #
+        #: -> String
+        def cursor_restore
+          control('', 'u')
+        end
+
+        # Move to the next line
+        #
+        #: -> String
+        def next_line
+          cursor_down + cursor_horizontal_absolute
+        end
+
+        # Move to the previous line
+        #
+        #: -> String
+        def previous_line
+          previous_lines(1)
+        end
+
+        # Move to the previous n lines
+        #
+        # ==== Attributes
+        #
+        # * +n+ - number of lines by which to move the cursor up
+        #
+        #: (?Integer n) -> String
+        def previous_lines(n = 1)
+          cursor_up(n) + cursor_horizontal_absolute
+        end
+
+        #: -> String
+        def clear_to_end_of_line
+          control('', 'K')
+        end
+
+        #: -> String
+        def insert_line
+          insert_lines(1)
+        end
+
+        #: (?Integer n) -> String
+        def insert_lines(n = 1)
+          control(n.to_s, 'L')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'cli/ui'
+
+module CLI
+  module UI
+    class Color
+      #: String
+      attr_reader :sgr, :code
+
+      #: Symbol
+      attr_reader :name
+
+      # Creates a new color mapping
+      # Signatures can be found here:
+      # https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+      #
+      # ==== Attributes
+      #
+      # * +sgr+ - The color signature
+      # * +name+ - The name of the color
+      #
+      #: (String sgr, Symbol name) -> void
+      def initialize(sgr, name)
+        @sgr  = sgr
+        @code = CLI::UI::ANSI.sgr(sgr)
+        @name = name
+      end
+
+      RED     = new('31', :red)
+      GREEN   = new('32', :green)
+      YELLOW  = new('33', :yellow)
+      # default blue is low-contrast against black in some default terminal color scheme
+      BLUE    = new('94', :blue) # 9x = high-intensity fg color x
+      MAGENTA = new('35', :magenta)
+      CYAN    = new('36', :cyan)
+      RESET   = new('0',  :reset)
+      BOLD    = new('1',  :bold)
+      WHITE   = new('97', :white)
+
+      # 240 is very dark gray; 255 is very light gray. 244 is somewhat dark.
+      GRAY = new('38;5;244', :gray)
+      # Using color 214 from the 256-color palette for a more distinct orange
+      ORANGE = new('38;5;214', :orange)
+
+      MAP = {
+        red: RED,
+        green: GREEN,
+        yellow: YELLOW,
+        blue: BLUE,
+        magenta: MAGENTA,
+        cyan: CYAN,
+        reset: RESET,
+        bold: BOLD,
+        gray: GRAY,
+        orange: ORANGE,
+      }.freeze
+
+      class InvalidColorName < ArgumentError
+        #: (Symbol name) -> void
+        def initialize(name)
+          super
+          @name = name
+        end
+
+        #: -> String
+        def message
+          keys = Color.available.map(&:inspect).join(',')
+          "invalid color: #{@name.inspect} " \
+            "-- must be one of CLI::UI::Color.available (#{keys})"
+        end
+      end
+
+      class << self
+        # Looks up a color code by name
+        #
+        # ==== Raises
+        # Raises a InvalidColorName if the color is not available
+        # You likely need to add it to the +MAP+ or you made a typo
+        #
+        # ==== Returns
+        # Returns a color code
+        #
+        #: ((Symbol | String) name) -> Color
+        def lookup(name)
+          MAP.fetch(name.to_sym)
+        rescue KeyError
+          raise InvalidColorName, name.to_sym
+        end
+
+        # All available colors by name
+        #
+        #: -> Array[Symbol]
+        def available
+          MAP.keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,219 @@
+# typed: true
+# frozen_string_literal: true
+
+require('cli/ui')
+require('strscan')
+
+module CLI
+  module UI
+    class Formatter
+      # Available mappings of formattings
+      # To use any of them, you can use {{<key>:<string>}}
+      # There are presentational (colours and formatters)
+      # and semantic (error, info, command) formatters available
+      #
+      SGR_MAP = {
+        # presentational
+        'red' => '31',
+        'green' => '32',
+        'yellow' => '33',
+        # default blue is low-contrast against black in some default terminal color scheme
+        'blue' => '94', # 9x = high-intensity fg color x
+        'magenta' => '35',
+        'cyan' => '36',
+        'gray' => '38;5;244',
+        'orange' => '38;5;214',
+        'white' => '97',
+        'bold' => '1',
+        'italic' => '3',
+        'underline' => '4',
+        'strikethrough' => '9',
+        'reset' => '0',
+
+        # semantic
+        'error' => '31', # red
+        'success' => '32', # success
+        'warning' => '33', # yellow
+        'info' => '94', # bright blue
+        'command' => '36', # cyan
+      }.freeze
+
+      BEGIN_EXPR = '{{'
+      END_EXPR   = '}}'
+
+      SCAN_WIDGET   = %r[@widget/(?<handle>\w+):(?<args>.*?)}}]
+      SCAN_FUNCNAME = /\w+:/
+      SCAN_GLYPH    = /.}}/
+      SCAN_BODY     = %r{
+        .*?
+        (
+          #{BEGIN_EXPR} |
+          #{END_EXPR}   |
+          \z
+        )
+      }mx
+
+      DISCARD_BRACES = 0..-3
+
+      LITERAL_BRACES = Class.new
+
+      #: type stack = Array[String | LITERAL_BRACES]
+
+      class FormatError < StandardError
+        #: String
+        attr_accessor :input
+
+        #: Integer
+        attr_accessor :index
+
+        #: (String message, String input, Integer index) -> void
+        def initialize(message, input, index)
+          super(message)
+          @input = input
+          @index = index
+        end
+      end
+
+      # Initialize a formatter with text.
+      #
+      # ===== Attributes
+      #
+      # * +text+ - the text to format
+      #
+      #: (String text) -> void
+      def initialize(text)
+        @text = text
+        @nodes = [] #: Array[[String, stack]]
+      end
+
+      # Format the text using a map.
+      #
+      # ===== Attributes
+      #
+      # * +sgr_map+ - the mapping of the formattings. Defaults to +SGR_MAP+
+      #
+      # ===== Options
+      #
+      # * +:enable_color+ - enable color output? Default is true unless output is redirected
+      #
+      #: (?Hash[String, String] sgr_map, ?enable_color: bool) -> String
+      def format(sgr_map = SGR_MAP, enable_color: CLI::UI.enable_color?)
+        @nodes.replace([])
+        stack = parse_body(StringScanner.new(@text))
+        prev_fmt = nil #: stack?
+        content = @nodes.each_with_object(+'') do |(text, fmt), str|
+          if prev_fmt != fmt && enable_color
+            text = apply_format(text, fmt, sgr_map)
+          end
+          str << text
+          prev_fmt = fmt
+        end
+
+        stack.reject! { |e| e.is_a?(LITERAL_BRACES) }
+
+        return content unless enable_color
+        return content if stack == prev_fmt
+
+        last_node = @nodes.last #: as !nil
+        unless stack.empty? && (@nodes.empty? || last_node[1].empty?)
+          content << apply_format('', stack, sgr_map)
+        end
+        content
+      end
+
+      private
+
+      #: (String text, stack fmt, Hash[String, String] sgr_map) -> String
+      def apply_format(text, fmt, sgr_map)
+        sgr = fmt.each_with_object(+'0') do |name, str|
+          next if name.is_a?(LITERAL_BRACES)
+
+          begin
+            str << ';' << sgr_map.fetch(name)
+          rescue KeyError
+            raise FormatError.new(
+              "invalid format specifier: #{name}",
+              @text,
+              -1,
+            )
+          end
+        end
+        CLI::UI::ANSI.sgr(sgr) + text
+      end
+
+      #: (StringScanner sc, stack stack) -> stack
+      def parse_expr(sc, stack)
+        if (match = sc.scan(SCAN_GLYPH))
+          glyph_handle = match[0] #: as !nil
+          begin
+            glyph = Glyph.lookup(glyph_handle)
+            emit(glyph.char, [glyph.color.name.to_s])
+          rescue Glyph::InvalidGlyphHandle
+            index = sc.pos - 2 # rewind past '}}'
+            raise FormatError.new(
+              "invalid glyph handle at index #{index}: '#{glyph_handle}'",
+              @text,
+              index,
+            )
+          end
+        elsif (match = sc.scan(SCAN_WIDGET))
+          match_data = SCAN_WIDGET.match(match) #: as !nil # Regexp.last_match doesn't work here
+          widget_handle = match_data['handle'] #: as !nil
+          begin
+            widget = Widgets.lookup(widget_handle)
+            args = match_data['args'] #: as !nil
+            emit(widget.call(args), stack)
+          rescue Widgets::InvalidWidgetHandle
+            index = sc.pos - 2 # rewind past '}}'
+            raise(FormatError.new(
+              "invalid widget handle at index #{index}: '#{widget_handle}'",
+              @text,
+              index,
+            ))
+          end
+        elsif (match = sc.scan(SCAN_FUNCNAME))
+          funcname = match.chop
+          stack.push(funcname)
+        else
+          # We read a {{ but it's not apparently Formatter syntax.
+          # We could error, but it's nicer to just pass through as text.
+          # We do kind of assume that the text will probably have balanced
+          # pairs of {{ }} at least.
+          emit('{{', stack)
+          stack.push(LITERAL_BRACES.new)
+        end
+        parse_body(sc, stack)
+        stack
+      end
+
+      #: (StringScanner sc, ?stack stack) -> stack
+      def parse_body(sc, stack = [])
+        match = sc.scan(SCAN_BODY)
+        if match&.end_with?(BEGIN_EXPR)
+          text = match[DISCARD_BRACES] #: as !nil
+          emit(text, stack)
+          parse_expr(sc, stack)
+        elsif match&.end_with?(END_EXPR)
+          text = match[DISCARD_BRACES] #: as !nil
+          emit(text, stack)
+          if stack.pop.is_a?(LITERAL_BRACES)
+            emit('}}', stack)
+          end
+          parse_body(sc, stack)
+        elsif match
+          emit(match, stack)
+        else
+          emit(sc.rest, stack)
+        end
+        stack
+      end
+
+      #: (String text, stack stack) -> void
+      def emit(text, stack)
+        return if text.empty?
+
+        @nodes << [text, stack.reject { |n| n.is_a?(LITERAL_BRACES) }]
+      end
+    end
+  end
+end