rfix 2.0.4 → 3.0.0

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

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+module CLI
+  module UI
+    class FormatterTest < MiniTest::Test
+      def test_format
+        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::Formatter.new(input).format
+        assert_equal(expected, actual)
+      end
+
+      def test_format_widget
+        input = 'a{{@widget/status:0:0:0:0}}b'
+        expected = "a\e[0m\e[1m∅\e[0mb"
+        actual = CLI::UI::Formatter.new(input).format(enable_color: false)
+        assert_equal(expected, actual)
+      end
+
+      def test_format_no_color
+        input = 'a{{blue:b {{*}}{{bold:c {{red:d}}}}{{bold: e}}}} f {{bold:'
+        expected = 'ab ⭑c d e f '
+        actual = CLI::UI::Formatter.new(input).format(enable_color: false)
+        assert_equal(expected, actual)
+      end
+
+      def test_format_trailing
+        input = 'a{{bold:a {{blue:'
+        expected = "\e[0ma\e[0;1ma \e[0;1;94m"
+        actual = CLI::UI::Formatter.new(input).format
+        assert_equal(expected, actual)
+      end
+
+      def test_invalid_funcname
+        input = '{{nope:text}}'
+        ex = assert_raises(CLI::UI::Formatter::FormatError) do
+          CLI::UI::Formatter.new(input).format
+        end
+        expected = 'invalid format specifier: nope'
+        assert_equal(input, ex.input)
+        assert_equal(-1, ex.index)
+        assert_equal(expected, ex.message)
+      end
+
+      def test_invalid_glyph
+        input = '{{&}}'
+        ex = assert_raises(CLI::UI::Formatter::FormatError) do
+          CLI::UI::Formatter.new(input).format
+        end
+        expected = "invalid glyph handle at index 3: '&'"
+        assert_equal(input, ex.input)
+        assert_equal(3, ex.index)
+        assert_equal(expected, ex.message)
+      end
+
+      def test_mixed_non_syntax
+        input = '{{bold:{{foo {{green:bar}} }}}}'
+        expected = "\e[0;1m{{foo \e[0;1;32mbar\e[0;1m }}\e[0m"
+        actual = CLI::UI::Formatter.new(input).format
+        assert_equal(expected, actual)
+      end
+
+      def test_incomplete_non_syntax
+        input = '{{foo'
+        expected = "\e[0m{{foo"
+        actual = CLI::UI::Formatter.new(input).format
+        assert_equal(expected, actual)
+      end
+
+      def test_reset_after_glyph
+        input = '{{*}} foobar'
+        expected = "\e[0;33m⭑\e[0m foobar"
+
+        actual = CLI::UI::Formatter.new(input).format
+        assert_equal(expected, actual)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+module CLI
+  module UI
+    class GlyphTest < MiniTest::Test
+      def test_glyphs
+        assert_equal("\x1b[33m⭑\x1b[0m", Glyph::STAR.to_s)
+        assert_equal("\x1b[94m𝒾\x1b[0m", Glyph::INFO.to_s)
+        assert_equal("\x1b[94m?\x1b[0m", Glyph::QUESTION.to_s)
+        assert_equal("\x1b[32m✓\x1b[0m", Glyph::CHECK.to_s)
+        assert_equal("\x1b[31m✗\x1b[0m", Glyph::X.to_s)
+        assert_equal("\x1b[97m🐛\x1b[0m", Glyph::BUG.to_s)
+        assert_equal("\x1b[33m»\x1b[0m", Glyph::CHEVRON.to_s)
+
+        assert_equal(Glyph::STAR,     Glyph.lookup('*'))
+        assert_equal(Glyph::INFO,     Glyph.lookup('i'))
+        assert_equal(Glyph::QUESTION, Glyph.lookup('?'))
+        assert_equal(Glyph::CHECK,    Glyph.lookup('v'))
+        assert_equal(Glyph::X,        Glyph.lookup('x'))
+        assert_equal(Glyph::BUG,      Glyph.lookup('b'))
+        assert_equal(Glyph::CHEVRON,  Glyph.lookup('>'))
+
+        assert_raises(Glyph::InvalidGlyphHandle) do
+          Glyph.lookup('$')
+        end
+      end
+
+      def test_plain_glyphs
+        with_os_mock_and_reload(
+          CLI::UI::OS::Windows,
+          :Glyph,
+          File.join(File.dirname(__FILE__), '../../../lib/cli/ui/glyph.rb')
+        ) do
+          assert_equal("\x1b[33m*\x1b[0m", Glyph::STAR.to_s)
+          assert_equal("\x1b[94mi\x1b[0m", Glyph::INFO.to_s)
+          assert_equal("\x1b[94m?\x1b[0m", Glyph::QUESTION.to_s)
+          assert_equal("\x1b[32m√\x1b[0m", Glyph::CHECK.to_s)
+          assert_equal("\x1b[31mX\x1b[0m", Glyph::X.to_s)
+          assert_equal("\x1b[97m!\x1b[0m", Glyph::BUG.to_s)
+          assert_equal("\x1b[33m»\x1b[0m", Glyph::CHEVRON.to_s)
+
+          assert_equal(Glyph::STAR,     Glyph.lookup('*'))
+          assert_equal(Glyph::INFO,     Glyph.lookup('i'))
+          assert_equal(Glyph::QUESTION, Glyph.lookup('?'))
+          assert_equal(Glyph::CHECK,    Glyph.lookup('v'))
+          assert_equal(Glyph::X,        Glyph.lookup('x'))
+          assert_equal(Glyph::BUG,      Glyph.lookup('b'))
+          assert_equal(Glyph::CHEVRON,  Glyph.lookup('>'))
+
+          assert_raises(Glyph::InvalidGlyphHandle) do
+            Glyph.lookup('$')
+          end
+        end
+      end
+
+      def test_useful_exception
+        e = begin
+          Glyph.lookup('$')
+        rescue => e
+          e
+        end
+        assert_match(/invalid glyph handle: \$/, e.message) # error
+        assert_match(/Glyph\.available/, e.message) # where to find colors
+        assert_match(/\*/, e.message) # list of valid colors
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+require 'test_helper'
+
+module CLI
+  module UI
+    class PrinterTest < MiniTest::Test
+      def test_puts_color
+        out, _ = capture_io do
+          CLI::UI::StdoutRouter.ensure_activated
+          assert(Printer.puts('foo', frame_color: :red))
+        end
+
+        assert_equal("\e[0mfoo\n", out)
+      end
+
+      # NOTE: The spacing in the assertion of this test is important for
+      #       downstream projects and should be maintained.
+      def test_puts_color_frame
+        Frame.open('test') do
+          out, _ = capture_io do
+            CLI::UI::StdoutRouter.ensure_activated
+            assert(Printer.puts('foo', frame_color: :red))
+          end
+
+          assert_equal("\e[31m┃ \e[0m\e[0mfoo\n", out)
+        end
+      end
+
+      def test_frame_with_long_texts
+        overlong_preamble = 'This is a long preamble! '
+        overlong_preamble *= (CLI::UI::Terminal.width / overlong_preamble.length).floor + 1
+
+        overlong_suffix = 'This overlaps the suffix! '
+        overlong_suffix *= (CLI::UI::Terminal.width / overlong_suffix.length).floor + 1
+
+        Frame.open(overlong_preamble, success_text: overlong_suffix) do
+          out, _ = capture_io do
+            CLI::UI::StdoutRouter.ensure_activated
+            assert(Printer.puts('foo', frame_color: :red))
+          end
+
+          assert_equal("\e[31m┃ \e[0m\e[0mfoo\n", out)
+        end
+      end
+
+      def test_puts_stream
+        _, err = capture_io do
+          assert(Printer.puts('foo', to: $stderr, format: false))
+        end
+
+        assert_equal("foo\n", err)
+      end
+
+      def test_puts_format
+        out, _ = capture_io do
+          assert(Printer.puts('{{x}} foo'))
+        end
+
+        assert_equal("\e[0;31m✗\e[0m foo\n", out)
+      end
+
+      def test_puts_pipe
+        IO.pipe do |r, w|
+          assert(Printer.puts('foo', to: w, format: false))
+          assert_equal("foo\n", r.gets)
+        end
+      end
+
+      def test_puts_pipe_closed
+        IO.pipe do |_r, w|
+          w.close
+          assert_raises(IOError) do
+            Printer.puts('foo', to: w, graceful: false)
+          end
+        end
+      end
+
+      def test_puts_graceful
+        IO.pipe do |r, w|
+          w.close
+          refute(Printer.puts('foo', to: w, graceful: true))
+          assert_nil(r.gets)
+        end
+      end
+
+      def test_encoding
+        msg = 'é'.force_encoding(Encoding::ISO_8859_1)
+        out, _ = capture_io do
+          assert(Printer.puts(msg, encoding: nil, format: false))
+        end
+        refute_equal(msg + "\n", out) # It doesn't work
+        assert_equal(msg.encode(Encoding::UTF_8) + "\n", out)
+      end
+
+      def test_encoding_ut8
+        msg = 'é'.force_encoding(Encoding::ISO_8859_1)
+        out, _ = capture_io do
+          assert(Printer.puts(msg, format: false))
+        end
+        assert_equal(msg + "\n", out)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+module CLI
+  module UI
+    class ProgressTest < MiniTest::Test
+      def test_tick_with_percent
+        assert_bar(set_percent: 0.1, expected_filled: 1, expected_unfilled: 9, suffix: ' 10% ')
+      end
+
+      def test_tick_with_set_percent
+        assert_bar(set_percent: 0.9, expected_filled: 9, expected_unfilled: 1, suffix: ' 90% ')
+      end
+
+      def test_tick_with_set_percent_above_100_percent_is_set_to_100_percent
+        assert_bar(set_percent: 2.0, expected_filled: 10, suffix: ' 100%')
+      end
+
+      def test_tick_with_percent_change_to_above_100_percent_is_set_to_100_percent
+        assert_bar(percent: 2.0, expected_filled: 10, suffix: ' 100%')
+      end
+
+      def test_tick_with_set_percent_and_percent_raises
+        assert_raises(ArgumentError) do
+          bar = Progress.new(width: 10)
+          bar.tick(percent: 0.5, set_percent: 0.9)
+        end
+      end
+
+      def assert_bar(percent: nil, set_percent: nil, expected_filled: 0, expected_unfilled: 0, suffix: '')
+        expected_bar = "\e[0m\e[46m#{" " * expected_filled}\e[1;47m#{" " * expected_unfilled}\e[0m#{suffix}"
+
+        params = {}
+        params[:percent] = percent if percent
+        params[:set_percent] = set_percent if set_percent
+
+        out, = capture_io do
+          bar = Progress.new(width: 10 + suffix.size) # each 10% is one box with this width
+          bar.tick(**params)
+          assert_equal(expected_bar, bar.to_s)
+        end
+
+        assert_equal(expected_bar + "\e[1A\e[1G\n", out)
+      end
+    end
+  end
+end

data/vendor/cli-ui/test/cli/ui/prompt/options_handler_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+require 'cli/ui/prompt/options_handler'
+
+module CLI
+  module UI
+    module Prompt
+      class OptionsHandlerTest < MiniTest::Test
+        def test_initialize
+          handler = OptionsHandler.new
+
+          assert_empty(handler.options)
+        end
+
+        def test_option
+          handler = OptionsHandler.new
+
+          handler.option('a') {}
+          handler.option('b') {}
+          handler.option('c') {}
+
+          assert_equal(['a', 'b', 'c'], handler.options)
+        end
+
+        def test_call
+          handler = OptionsHandler.new
+          procedure_called = false
+          procedure = proc do |selection|
+            procedure_called = true
+            selection
+          end
+
+          handler.option('a', &procedure)
+          assert_equal('a', handler.call('a'))
+          assert(procedure_called)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,348 @@
+# coding: utf-8
+require 'test_helper'
+require 'readline'
+require 'timeout'
+require 'open3'
+
+module CLI
+  module UI
+    class PromptTest < MiniTest::Test
+      # ^C is not handled; raises Interrupt, which may be handled by caller.
+      def test_confirm_sigint
+        jruby_skip('SIGINT shuts down the JVM instead of raising Interrupt')
+
+        run_in_process(<<~RUBY)
+          begin
+            CLI::UI::Prompt.confirm('question')
+          rescue Interrupt
+            puts 'sentinel'
+          end
+        RUBY
+
+        wait_for_output_to_include('question')
+        kill_process
+
+        assert_output_includes('sentinel')
+      end
+
+      # ^C is not handled; raises Interrupt, which may be handled by caller.
+      def test_ask_free_form_sigint
+        jruby_skip('SIGINT shuts down the JVM instead of raising Interrupt')
+
+        run_in_process(<<~RUBY)
+          begin
+            CLI::UI::Prompt.ask('question')
+          rescue Interrupt
+            puts 'sentinel'
+          end
+        RUBY
+
+        wait_for_output_to_include('question')
+        kill_process
+
+        assert_output_includes('sentinel')
+      end
+
+      # ^C is not handled; raises Interrupt, which may be handled by caller.
+      def test_ask_interactive_sigint
+        jruby_skip('SIGINT shuts down the JVM instead of raising Interrupt')
+
+        run_in_process(<<~RUBY)
+          begin
+            CLI::UI::Prompt.ask('question', options: %w(a b))
+          rescue Interrupt
+            puts 'sentinel'
+          end
+        RUBY
+
+        wait_for_output_to_include('question')
+        kill_process
+
+        assert_output_includes('sentinel')
+      end
+
+      def test_confirm_happy_path
+        run_in_process('puts CLI::UI::Prompt.confirm("q")')
+        write('y')
+        assert_output_includes('true')
+      end
+
+      def test_confirm_default_no
+        run_in_process('puts CLI::UI::Prompt.confirm("q", default: false)')
+        write("\n")
+        assert_output_includes('false')
+      end
+
+      def test_confirm_invalid
+        run_in_process('puts CLI::UI::Prompt.confirm("q")')
+        write('ryn')
+        assert_output_includes('true')
+      end
+
+      def test_confirm_no_match_internal
+        run_in_process('puts CLI::UI::Prompt.confirm("q", default: false)')
+        write('xn')
+        assert_output_includes('false')
+      end
+
+      def test_output_includes_instructions
+        run_in_process('CLI::UI::Prompt.confirm("q")')
+        write('y')
+        assert_output_includes('(Choose with ↑ ↓ ⏎)')
+      end
+
+      def test_windows_instructions
+        # Windows doesn't detect presses on the arrow keys when picking an option, so we don't show the instruction text
+        # for them.
+        run_in_process(<<~RUBY)
+          CLI::UI::OS # Force the file to load before redefining ::current
+          module CLI
+            module UI
+              module OS
+                def self.current
+                  CLI::UI::OS::Windows
+                end
+              end
+            end
+          end
+          CLI::UI::Prompt.confirm("q")
+        RUBY
+        write('y')
+        assert_output_includes("(Navigate up with 'k' and down with 'j', press Enter to select)")
+      end
+
+      def test_ask_free_form_happy_path
+        run_in_process('puts "--#{CLI::UI::Prompt.ask("q")}--"')
+        write("asdf\n")
+        assert_output_includes('--asdf--')
+      end
+
+      def test_ask_free_form_empty_answer_allowed
+        run_in_process('puts "--#{CLI::UI::Prompt.ask("q")}--"')
+        write("\n")
+        assert_output_includes('----')
+      end
+
+      def test_ask_free_form_empty_answer_rejected
+        run_in_process('puts "--#{CLI::UI::Prompt.ask("q", allow_empty: false)}--"')
+        write("\nasdf\n")
+        assert_output_includes('--asdf--')
+      end
+
+      def test_ask_free_form_no_filename_completion
+        run_in_process('puts "--#{CLI::UI::Prompt.ask("q")}--"')
+        write("/dev/nul\t\n")
+        assert_output_includes('--/dev/nul--')
+      end
+
+      def test_ask_free_form_filename_completion
+        run_in_process('puts "--#{CLI::UI::Prompt.ask("q", is_file: true)}--"')
+        write("/dev/nul\t\n")
+        assert_output_includes('--/dev/null--')
+      end
+
+      def test_ask_free_form_default
+        run_in_process('puts "--#{CLI::UI::Prompt.ask("q", default: "asdf")}--"')
+        write("\n")
+        assert_output_includes('--asdf--')
+      end
+
+      def test_ask_free_form_default_nondefault
+        run_in_process('puts "--#{CLI::UI::Prompt.ask("q", default: "asdf")}--"')
+        write("zxcv\n")
+        assert_output_includes('--zxcv--')
+      end
+
+      def test_ask_invalid_kwargs
+        kwargsets = [
+          { options: ['a'], default: 'a' },
+          { options: ['a'], is_file: true },
+        ]
+
+        kwargsets.each do |kwargs|
+          error = assert_raises(ArgumentError) { Prompt.ask('q', **kwargs) }
+          assert_equal('conflicting arguments: options provided with default or is_file', error.message)
+        end
+
+        error = assert_raises(ArgumentError) do
+          Prompt.ask('q', default: 'a', allow_empty: false)
+        end
+        assert_equal('conflicting arguments: default enabled but allow_empty is false', error.message)
+
+        error = assert_raises(ArgumentError) do
+          Prompt.ask('q', default: 'b') {}
+        end
+        assert_equal('conflicting arguments: options provided with default or is_file', error.message)
+      end
+
+      def test_ask_interactive_conflicting_arguments
+        error = assert_raises(ArgumentError) do
+          Prompt.ask('q', options: %w(a b)) { |h| h.option('a') }
+        end
+        assert_equal('conflicting arguments: options and block given', error.message)
+
+        error = assert_raises(ArgumentError) do
+          Prompt.ask('q', options: %w(a b), multiple: true, default: %w(b c)) { |h| h.option('a') }
+        end
+        assert_equal('conflicting arguments: default should only include elements present in options', error.message)
+      end
+
+      def test_ask_interactive_insufficient_options
+        exception = assert_raises(ArgumentError) do
+          Prompt.ask('q', options: %w())
+        end
+        assert_equal('insufficient options', exception.message)
+
+        exception = assert_raises(ArgumentError) do
+          Prompt.ask('q') { |_h| {} }
+        end
+        assert_equal('insufficient options', exception.message)
+      end
+
+      def test_ask_interactive_with_block
+        run_in_process(<<~RUBY)
+          puts(CLI::UI::Prompt.ask('q') do |h|
+            h.option('a') { |_a| 'a was selected' }
+            h.option('b') { |_a| 'b was selected' }
+          end)
+        RUBY
+        write('1')
+
+        assert_output_includes('a was selected')
+      end
+
+      def test_ask_interactive_with_vim_bound_arrows
+        run_in_process('puts "--#{CLI::UI::Prompt.ask("q", options: %w(a b))}--"')
+        write('j ')
+        assert_output_includes('--b--')
+      end
+
+      def test_ask_interactive_escape
+        run_in_process(<<~RUBY)
+          begin
+            CLI::UI::Prompt.ask("q", options: %w(a b))
+          rescue Interrupt # jruby can rescue this one since we raise it rather than receiving it as a signal
+            puts 'sentinel'
+          end
+        RUBY
+
+        write("\e;")
+        assert_output_includes('sentinel')
+      end
+
+      def test_ask_interactive_invalid_input
+        run_in_process('puts "--#{CLI::UI::Prompt.ask("q", options: %w(a b))}--"')
+        write('3nan2')
+        assert_output_includes('--b--')
+      end
+
+      def test_ask_interactive_with_blank_option
+        run_in_process(<<~RUBY)
+          puts(CLI::UI::Prompt.ask('q') do |h|
+            h.option('a') { |_a| 'a was selected' }
+            h.option('') { |_a| 'b was selected' }
+          end)
+        RUBY
+        write('jj ')
+        assert_output_includes('a was selected')
+      end
+
+      def test_ask_interactive_filter_options
+        run_in_process('puts "--#{CLI::UI::Prompt.ask("q", options: %w(abcd xyz))}--"')
+        write("fz\n")
+        assert_output_includes('--xyz--')
+      end
+
+      def test_ask_interactive_line_selection
+        run_in_process('puts "--#{CLI::UI::Prompt.ask("q", options: (1..15).map(&:to_s))}--"')
+        write("e10\n")
+        assert_output_includes('--10--')
+      end
+
+      def test_ask_multiple
+        run_in_process('puts CLI::UI::Prompt.ask("q", options: (1..15).map(&:to_s), multiple: true).inspect')
+        write('1350')
+        assert_output_includes(['1', '3', '5'].inspect)
+      end
+
+      def test_ask_multiple_with_handler
+        run_in_process(<<~RUBY)
+          puts(CLI::UI::Prompt.ask('q', multiple: true) do |handler|
+            ('1'..'10').each do |i|
+              handler.option(i) { i }
+            end
+          end.inspect)
+        RUBY
+        write('1350')
+        assert_output_includes(['1', '3', '5'].inspect)
+      end
+
+      def test_ask_multiple_with_default_values
+        run_in_process(
+          'puts CLI::UI::Prompt.ask("q", options: (1..15).map(&:to_s), multiple: true, default: %w(2 3)).inspect'
+        )
+        write('120')
+        assert_output_includes(['1', '3'].inspect)
+      end
+
+      private
+
+      def run_in_process(code)
+        @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(
+          'ruby',
+          '-r',
+          'bundler/setup',
+          '-r',
+          'cli/ui',
+          '-e',
+          "$stdout.sync = true; $stderr.sync = true; #{code}"
+        )
+      end
+
+      def wait_for_output_to_include(text)
+        @output = ''
+        until @output.include?(text)
+          begin
+            @output += @stdout.read_nonblock(100)
+          rescue IO::WaitReadable
+            IO.select([@stdout])
+            retry
+          end
+        end
+      end
+
+      def write(text)
+        @stdin.write(text)
+      end
+
+      def kill_process
+        Process.kill('INT', @wait_thr[:pid])
+      end
+
+      def clean_up
+        @wait_thr.value
+        yield if block_given?
+      ensure
+        @stdin.close
+        @stderr.close
+        @stdout.close
+      end
+
+      def assert_output_includes(text)
+        clean_up do
+          assert_includes(@stdout.read, text)
+        end
+      end
+
+      def assert_error_includes(text)
+        clean_up do
+          assert_includes(@stderr.read, text)
+        end
+      end
+
+      def jruby_skip(message)
+        skip(message) if RUBY_ENGINE.include?('jruby')
+      end
+    end
+  end
+end