rfix 2.0.4 → 3.0.0

data/vendor/cli-ui/lib/cli/ui/terminal.rb

@@ -0,0 +1,46 @@
+require 'cli/ui'
+require 'io/console'
+
+module CLI
+  module UI
+    module Terminal
+      DEFAULT_WIDTH = 80
+      DEFAULT_HEIGHT = 24
+
+      # Returns the width of the terminal, if possible
+      # Otherwise will return DEFAULT_WIDTH
+      #
+      def self.width
+        winsize[1]
+      end
+
+      # Returns the width of the terminal, if possible
+      # Otherwise, will return DEFAULT_HEIGHT
+      #
+      def self.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
+      end
+    end
+  end
+end

data/vendor/cli-ui/lib/cli/ui/truncater.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'cli/ui'
+
+module CLI
+  module UI
+    # Truncater truncates a string to a provided printable width.
+    module Truncater
+      PARSE_ROOT = :root
+      PARSE_ANSI = :ansi
+      PARSE_ESC  = :esc
+      PARSE_ZWJ  = :zwj
+
+      ESC                 = 0x1b
+      LEFT_SQUARE_BRACKET = 0x5b
+      ZWJ                 = 0x200d # emojipedia.org/emoji-zwj-sequences
+      SEMICOLON           = 0x3b
+
+      # EMOJI_RANGE in particular is super inaccurate. This is best-effort.
+      # If you need this to be more accurate, we'll almost certainly accept a
+      # PR improving it.
+      EMOJI_RANGE    = 0x1f300..0x1f5ff
+      NUMERIC_RANGE  = 0x30..0x39
+      LC_ALPHA_RANGE = 0x40..0x5a
+      UC_ALPHA_RANGE = 0x60..0x71
+
+      TRUNCATED = "\x1b[0m…"
+
+      class << self
+        def call(text, printing_width)
+          return text if text.size <= printing_width
+
+          width            = 0
+          mode             = PARSE_ROOT
+          truncation_index = nil
+
+          codepoints = text.codepoints
+          codepoints.each.with_index do |cp, index|
+            case mode
+            when PARSE_ROOT
+              case cp
+              when ESC # non-printable, followed by some more non-printables.
+                mode = PARSE_ESC
+              when ZWJ # non-printable, followed by another non-printable.
+                mode = PARSE_ZWJ
+              else
+                width += width(cp)
+                if width >= printing_width
+                  truncation_index ||= index
+                  # it looks like we could break here but we still want the
+                  # width calculation for the rest of the characters.
+                end
+              end
+            when PARSE_ESC
+              mode = case cp
+              when LEFT_SQUARE_BRACKET
+                PARSE_ANSI
+              else
+                PARSE_ROOT
+              end
+            when PARSE_ANSI
+              # ANSI escape codes preeeetty much have the format of:
+              # \x1b[0-9;]+[A-Za-z]
+              case cp
+              when NUMERIC_RANGE, SEMICOLON
+              when LC_ALPHA_RANGE, UC_ALPHA_RANGE
+                mode = PARSE_ROOT
+              else
+                # unexpected. let's just go back to the root state I guess?
+                mode = PARSE_ROOT
+              end
+            when PARSE_ZWJ
+              # consume any character and consider it as having no width
+              # width(x+ZWJ+y) = width(x).
+              mode = PARSE_ROOT
+            end
+          end
+
+          # Without the `width <= printing_width` check, we truncate
+          # "foo\x1b[0m" for a width of 3, but it should not be truncated.
+          # It's specifically for the case where we decided "Yes, this is the
+          # point at which we'd have to add a truncation!" but it's actually
+          # the end of the string.
+          return text if !truncation_index || width <= printing_width
+
+          codepoints[0...truncation_index].pack('U*') + TRUNCATED
+        end
+
+        private
+
+        def width(printable_codepoint)
+          case printable_codepoint
+          when EMOJI_RANGE
+            2
+          else
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/cli-ui/lib/cli/ui/version.rb

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

data/vendor/cli-ui/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/vendor/cli-ui/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/vendor/cli-ui/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

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

@@ -0,0 +1,56 @@
+# coding: utf-8
+require 'cli/ui'
+require 'cli/ui/frame/frame_stack'
+require 'cli/ui/frame/frame_style'
+
+module CLI
+  module UI
+    class Wrap
+      def initialize(input)
+        @input = input
+      end
+
+      def wrap
+        max_width = Terminal.width - Frame.prefix_width
+        width = 0
+        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

data/vendor/cli-ui/test/cli/ui/ansi_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+module CLI
+  module UI
+    class ANSITest < MiniTest::Test
+      def test_sgr
+        assert_equal("\x1b[1;34m", ANSI.sgr('1;34'))
+      end
+
+      def test_printing_width
+        assert_equal(4, ANSI.printing_width("\x1b[38;2;100;100;100mtest\x1b[0m"))
+        assert_equal(0, ANSI.printing_width(''))
+
+        assert_equal(3, ANSI.printing_width('>🔧<'))
+        assert_equal(1, ANSI.printing_width('👩‍💻'))
+      end
+
+      def test_line_skip_with_shift
+        next_line_expected = "\e[1B\e[1G"
+        previous_line_expected = "\e[1A\e[1G"
+
+        assert_equal(next_line_expected, ANSI.next_line)
+        assert_equal(previous_line_expected, ANSI.previous_line)
+
+        CLI::UI::OS.stubs(:current).returns(CLI::UI::OS::Windows)
+
+        assert_equal("#{next_line_expected}\e[1D", ANSI.next_line)
+        assert_equal("#{previous_line_expected}\e[1D", ANSI.previous_line)
+      end
+    end
+  end
+end

data/vendor/cli-ui/test/cli/ui/cli_ui_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+module CLI
+  class UITest < MiniTest::Test
+    def test_resolve_test
+      input = 'a{{blue:b {{*}}{{bold:c {{red:d}}}}{{bold: e}}}} f'
+      expected = "\e[0ma\e[0;94mb \e[0;33m⭑\e[0;94;1mc \e[0;94;1;31md\e[0;94;1m e\e[0m f"
+      actual = CLI::UI.resolve_text(input)
+      assert_equal(expected, actual)
+    end
+
+    def test_color
+      prev = CLI::UI.enable_color?
+
+      CLI::UI.enable_color = true
+      assert_equal("\e[0;31ma\e[0m", CLI::UI.fmt('{{red:a}}'))
+      CLI::UI.enable_color = false
+      assert_equal('a', CLI::UI.fmt('{{red:a}}'))
+    ensure
+      CLI::UI.enable_color = prev
+    end
+  end
+end

data/vendor/cli-ui/test/cli/ui/color_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module CLI
+  module UI
+    class ColorTest < MiniTest::Test
+      def test_colors
+        assert_equal("\x1b[31m", Color::RED.code)
+        assert_equal("\x1b[32m", Color::GREEN.code)
+        assert_equal("\x1b[33m", Color::YELLOW.code)
+        assert_equal("\x1b[94m", Color::BLUE.code)
+        assert_equal("\x1b[35m", Color::MAGENTA.code)
+        assert_equal("\x1b[36m", Color::CYAN.code)
+        assert_equal("\x1b[0m",  Color::RESET.code)
+        assert_equal("\x1b[1m",  Color::BOLD.code)
+        assert_equal("\x1b[97m", Color::WHITE.code)
+
+        assert_equal('36',  Color::CYAN.sgr)
+        assert_equal(:bold, Color::BOLD.name)
+
+        assert_equal(Color::BLUE, Color.lookup(:blue))
+        assert_equal(Color::RESET, Color.lookup(:reset))
+
+        assert_raises(Color::InvalidColorName) do
+          Color.lookup(:foobar)
+        end
+      end
+
+      def test_useful_exception
+        e = begin
+          Color.lookup(:foobar)
+        rescue => e
+          e
+        end
+        assert_match(/invalid color: :foobar/, e.message) # error
+        assert_match(/Color\.available/, e.message) # where to find colors
+        assert_match(/:green/, e.message) # list of valid colors
+      end
+    end
+  end
+end