ruvim 0.1.0

data/test/dispatcher_test.rb

@@ -0,0 +1,124 @@
+require_relative "test_helper"
+
+class DispatcherTest < Minitest::Test
+  def setup
+    @app = RuVim::App.new
+    @editor = @app.instance_variable_get(:@editor)
+    @dispatcher = RuVim::Dispatcher.new
+  end
+
+  def test_parse_ex_with_bang_and_args
+    parsed = @dispatcher.parse_ex("w! foo.txt")
+    assert_equal "w", parsed.name
+    assert parsed.bang
+    assert_equal ["foo.txt"], parsed.argv
+  end
+
+  def test_dispatch_ex_help_sets_message
+    @dispatcher.dispatch_ex(@editor, "help")
+    assert_equal "[Help] help", @editor.message
+    assert_equal :help, @editor.current_buffer.kind
+    assert @editor.current_buffer.readonly?
+    refute @editor.current_buffer.modifiable?
+    assert_includes @editor.current_buffer.lines.join("\n"), "help"
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_dispatch_ex_help_topic_for_command
+    @dispatcher.dispatch_ex(@editor, "help w")
+    assert_equal "[Help] w", @editor.message
+    body = @editor.current_buffer.lines.join("\n")
+    assert_includes body, ":w"
+    assert_includes body, "Write current buffer"
+  end
+
+  def test_dispatch_ex_command_and_ruby
+    @dispatcher.dispatch_ex(@editor, "command Hi help")
+    assert_equal "Defined :Hi", @editor.message
+
+    @dispatcher.dispatch_ex(@editor, "Hi")
+    assert_equal "[Help] help", @editor.message
+
+    @dispatcher.dispatch_ex(@editor, "ruby 1+2")
+    assert_equal "ruby: 3", @editor.message
+  end
+
+  def test_dispatch_ex_set_commands
+    @dispatcher.dispatch_ex(@editor, "set number")
+    assert_equal true, @editor.current_window.options["number"]
+
+    @dispatcher.dispatch_ex(@editor, "setlocal tabstop=4")
+    assert_equal 4, @editor.current_buffer.options["tabstop"]
+
+    @dispatcher.dispatch_ex(@editor, "setglobal tabstop=8")
+    assert_equal 8, @editor.global_options["tabstop"]
+    assert_equal 4, @editor.effective_option("tabstop")
+  end
+
+  def test_q_closes_current_window_when_multiple_windows_exist
+    @editor.split_current_window(layout: :horizontal)
+    assert_equal 2, @editor.window_count
+
+    @dispatcher.dispatch_ex(@editor, "q")
+
+    assert_equal 1, @editor.window_count
+    assert @editor.running?
+    assert_equal "closed window", @editor.message
+  end
+
+  def test_q_closes_current_tab_when_multiple_tabs_exist
+    @editor.tabnew
+    assert_equal 2, @editor.tabpage_count
+    assert_equal 1, @editor.window_count
+
+    @dispatcher.dispatch_ex(@editor, "q")
+
+    assert_equal 1, @editor.tabpage_count
+    assert @editor.running?
+    assert_equal "closed tab", @editor.message
+  end
+
+  def test_q_exits_app_when_last_window
+    assert_equal 1, @editor.window_count
+    assert_equal 1, @editor.tabpage_count
+
+    @dispatcher.dispatch_ex(@editor, "q")
+
+    refute @editor.running?
+  end
+
+  def test_dispatch_ex_error_marks_message_as_error
+    @dispatcher.dispatch_ex(@editor, "no_such_command")
+
+    assert_match(/Error:/, @editor.message)
+    assert_equal true, @editor.message_error?
+  end
+
+  def test_vimgrep_populates_quickfix_and_cnext_moves
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["foo", "bar foo", "baz"])
+    @dispatcher.dispatch_ex(@editor, "vimgrep /foo/")
+
+    assert_equal 2, @editor.quickfix_items.length
+    assert_equal 0, @editor.current_window.cursor_y
+
+    @dispatcher.dispatch_ex(@editor, "cnext")
+    assert_equal 1, @editor.current_window.cursor_y
+
+    @dispatcher.dispatch_ex(@editor, "copen")
+    qf_windows = @editor.find_window_ids_by_buffer_kind(:quickfix)
+    refute_empty qf_windows
+  end
+
+  def test_lvimgrep_populates_location_list_and_lnext_moves
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["aa", "bb aa", "cc aa"])
+    wid = @editor.current_window_id
+
+    @dispatcher.dispatch_ex(@editor, "lvimgrep /aa/")
+    assert_equal 3, @editor.location_items(wid).length
+
+    @dispatcher.dispatch_ex(@editor, "lnext")
+    assert_equal 1, @editor.current_window.cursor_y
+  end
+end

data/test/editor_mark_test.rb

@@ -0,0 +1,69 @@
+require_relative "test_helper"
+
+class EditorMarkTest < Minitest::Test
+  def test_local_and_global_marks
+    editor = fresh_editor
+    buffer = editor.current_buffer
+    window = editor.current_window
+
+    buffer.replace_all_lines!(["  abc", "def"])
+    window.cursor_y = 1
+    window.cursor_x = 2
+
+    assert editor.set_mark("a")
+    assert editor.set_mark("A")
+
+    assert_equal 1, editor.mark_location("a")[:row]
+    assert_equal 2, editor.mark_location("A")[:col]
+  end
+
+  def test_jump_to_mark_linewise_uses_first_nonblank
+    editor = fresh_editor
+    buffer = editor.current_buffer
+    window = editor.current_window
+    buffer.replace_all_lines!(["  abc"])
+    window.cursor_y = 0
+    window.cursor_x = 4
+    editor.set_mark("a")
+
+    window.cursor_x = 0
+    editor.jump_to_mark("a", linewise: true)
+
+    assert_equal 2, window.cursor_x
+  end
+
+  def test_jumplist_older_and_newer
+    editor = fresh_editor
+    buffer = editor.current_buffer
+    window = editor.current_window
+    buffer.replace_all_lines!(["a", "b", "c"])
+    window.cursor_y = 0
+    window.cursor_x = 0
+    editor.push_jump_location
+
+    window.cursor_y = 2
+    window.cursor_x = 0
+    editor.push_jump_location
+
+    editor.jump_older
+    assert_equal 0, window.cursor_y
+
+    editor.jump_newer
+    assert_equal 2, window.cursor_y
+  end
+
+  def test_macro_recording_and_append
+    editor = fresh_editor
+
+    assert editor.start_macro_recording("a")
+    editor.record_macro_key("i")
+    editor.record_macro_key("x")
+    editor.stop_macro_recording
+    assert_equal %w[i x], editor.macro_keys("a")
+
+    assert editor.start_macro_recording("A")
+    editor.record_macro_key("y")
+    editor.stop_macro_recording
+    assert_equal %w[i x y], editor.macro_keys("a")
+  end
+end

data/test/editor_register_test.rb

@@ -0,0 +1,64 @@
+require_relative "test_helper"
+
+class EditorRegisterTest < Minitest::Test
+  def test_named_register_and_append_register
+    editor = fresh_editor
+
+    editor.set_register("a", text: "foo", type: :charwise)
+    assert_equal({ text: "foo", type: :charwise }, editor.get_register("a"))
+    assert_equal({ text: "foo", type: :charwise }, editor.get_register("\""))
+
+    editor.set_register("A", text: "bar", type: :charwise)
+    assert_equal({ text: "foobar", type: :charwise }, editor.get_register("a"))
+    assert_equal({ text: "foobar", type: :charwise }, editor.get_register("\""))
+  end
+
+  def test_active_register_is_consumed_once
+    editor = fresh_editor
+    editor.set_active_register("b")
+
+    assert_equal "b", editor.consume_active_register
+    assert_equal "\"", editor.consume_active_register
+  end
+
+  def test_black_hole_register_discards_explicit_write
+    editor = fresh_editor
+    editor.set_register("\"", text: "keep", type: :charwise)
+
+    editor.set_register("_", text: "drop", type: :charwise)
+
+    assert_equal({ text: "keep", type: :charwise }, editor.get_register("\""))
+    assert_nil editor.get_register("_")
+  end
+
+  def test_operator_register_updates_yank_zero_and_delete_numbered
+    editor = fresh_editor
+
+    editor.store_operator_register("\"", text: "yank", type: :charwise, kind: :yank)
+    assert_equal({ text: "yank", type: :charwise }, editor.get_register("\""))
+    assert_equal({ text: "yank", type: :charwise }, editor.get_register("0"))
+
+    editor.store_operator_register("\"", text: "del1", type: :charwise, kind: :delete)
+    editor.store_operator_register("\"", text: "del2", type: :linewise, kind: :delete)
+    assert_equal({ text: "del2", type: :linewise }, editor.get_register("1"))
+    assert_equal({ text: "del1", type: :charwise }, editor.get_register("2"))
+    assert_equal({ text: "yank", type: :charwise }, editor.get_register("0"))
+  end
+
+  def test_black_hole_skips_auto_operator_registers
+    editor = fresh_editor
+    editor.store_operator_register("\"", text: "seed", type: :charwise, kind: :yank)
+
+    editor.store_operator_register("_", text: "drop", type: :charwise, kind: :delete)
+
+    assert_equal({ text: "seed", type: :charwise }, editor.get_register("\""))
+    assert_equal({ text: "seed", type: :charwise }, editor.get_register("0"))
+    assert_nil editor.get_register("1")
+  end
+
+  def test_detect_filetype_on_opened_buffer
+    editor = RuVim::Editor.new
+    buffer = editor.add_empty_buffer(path: "/tmp/example.rb")
+    assert_equal "ruby", buffer.options["filetype"]
+  end
+end

data/test/fixtures/render_basic_snapshot.txt

@@ -0,0 +1,8 @@
+1 # title               
+2                       
+3 foo                   
+4 bar 日本語 編集       
+5 baz                   
+  ~                     
+  ~                     
+-- NORMAL -- t1/1 w 1:1 

data/test/fixtures/render_basic_snapshot_nonumber.txt

@@ -0,0 +1,8 @@
+# title                 
+                        
+foo                     
+bar 日本語 編集         
+baz                     
+~                       
+~                       
+-- NORMAL -- t1/1 w 1:1 

data/test/fixtures/render_unicode_scrolled_snapshot.txt

@@ -0,0 +1,7 @@
+1 # title           
+2                   
+3 foo               
+4 bar 日本語 編集   
+5 baz               
+6 qux               
+-- NORMAL -- t1 4:5 

data/test/highlighter_test.rb

@@ -0,0 +1,16 @@
+require_relative "test_helper"
+
+class HighlighterTest < Minitest::Test
+  def test_ruby_highlighter_marks_keyword_and_string
+    cols = RuVim::Highlighter.color_columns("ruby", 'def x; "hi"; end')
+    refute_empty cols
+    assert_equal "\e[36m", cols[0] # "def"
+    assert_equal "\e[32m", cols[7] # opening quote
+  end
+
+  def test_json_highlighter_marks_key_and_number
+    cols = RuVim::Highlighter.color_columns("json", '{"a": 10}')
+    assert_equal "\e[36m", cols[1] # key chars
+    assert_equal "\e[33m", cols[6] # number start
+  end
+end

data/test/input_screen_integration_test.rb

@@ -0,0 +1,69 @@
+require_relative "test_helper"
+
+class InputScreenIntegrationTest < Minitest::Test
+  TerminalStub = Struct.new(:winsize) do
+    attr_reader :writes
+
+    def write(data)
+      @writes ||= []
+      @writes << data
+    end
+  end
+
+  class FakeTTY
+    def initialize(bytes)
+      @bytes = bytes.dup
+    end
+
+    def getch
+      @bytes.slice!(0)
+    end
+
+    def read_nonblock(_n)
+      raise IO::WaitReadable if @bytes.empty?
+
+      @bytes.slice!(0)
+    end
+
+    def ready?
+      !@bytes.empty?
+    end
+  end
+
+  def test_input_pagedown_to_app_and_screen_render
+    app = RuVim::App.new(clean: true)
+    editor = app.instance_variable_get(:@editor)
+    editor.materialize_intro_buffer!
+    editor.current_buffer.replace_all_lines!((1..30).map { |i| "line #{i}" })
+
+    term = TerminalStub.new([8, 40])
+    screen = RuVim::Screen.new(terminal: term)
+    app.instance_variable_set(:@screen, screen)
+
+    stdin = FakeTTY.new("\e[6~")
+    input = RuVim::Input.new(stdin: stdin)
+
+    io_sc = IO.singleton_class
+    verbose, $VERBOSE = $VERBOSE, nil
+    io_sc.alias_method(:__orig_select_for_input_screen_test, :select)
+    io_sc.define_method(:select) do |readers, *_rest|
+      ready = Array(readers).select { |io| io.respond_to?(:ready?) && io.ready? }
+      ready.empty? ? nil : [ready, [], []]
+    end
+
+    begin
+      key = input.read_key(timeout: 0.2)
+      assert_equal :pagedown, key
+
+      app.send(:handle_normal_key, key)
+      screen.render(editor)
+
+      assert_operator editor.current_window.cursor_y, :>, 0
+      assert_includes term.writes.last, "line "
+    ensure
+      io_sc.alias_method(:select, :__orig_select_for_input_screen_test)
+      io_sc.remove_method(:__orig_select_for_input_screen_test) rescue nil
+      $VERBOSE = verbose
+    end
+  end
+end

data/test/keymap_manager_test.rb

@@ -0,0 +1,48 @@
+require_relative "test_helper"
+
+class KeymapManagerTest < Minitest::Test
+  def setup
+    @km = RuVim::KeymapManager.new
+    @editor = fresh_editor
+  end
+
+  def test_mode_local_beats_global
+    @km.bind_global("x", "global.x")
+    @km.bind(:normal, "x", "normal.x")
+
+    match = @km.resolve_with_context(:normal, ["x"], editor: @editor)
+    assert_equal :match, match.status
+    assert_equal "normal.x", match.invocation.id
+  end
+
+  def test_buffer_local_beats_mode_local
+    @km.bind(:normal, "x", "normal.x")
+    @km.bind_buffer(@editor.current_buffer.id, "x", "buffer.x")
+
+    match = @km.resolve_with_context(:normal, ["x"], editor: @editor)
+    assert_equal "buffer.x", match.invocation.id
+  end
+
+  def test_prefix_pending_and_match
+    @km.bind(:normal, "dd", "delete.line")
+
+    pending = @km.resolve_with_context(:normal, ["d"], editor: @editor)
+    assert_equal :pending, pending.status
+
+    exact = @km.resolve_with_context(:normal, %w[d d], editor: @editor)
+    assert_equal :match, exact.status
+    assert_equal "delete.line", exact.invocation.id
+  end
+
+  def test_filetype_local_map_respects_mode
+    @editor.current_buffer.options["filetype"] = "ruby"
+    @km.bind(:normal, "x", "normal.x")
+    @km.bind_filetype("ruby", "x", "ruby.insert.x", mode: :insert)
+
+    normal = @km.resolve_with_context(:normal, ["x"], editor: @editor)
+    assert_equal "normal.x", normal.invocation.id
+
+    insert = @km.resolve_with_context(:insert, ["x"], editor: @editor)
+    assert_equal "ruby.insert.x", insert.invocation.id
+  end
+end

data/test/render_snapshot_test.rb

@@ -0,0 +1,70 @@
+require_relative "test_helper"
+
+class RenderSnapshotTest < Minitest::Test
+  TerminalStub = Struct.new(:winsize) do
+    def write(_data); end
+  end
+
+  FIXTURE = File.expand_path("fixtures/render_basic_snapshot.txt", __dir__)
+  FIXTURE_NONUM = File.expand_path("fixtures/render_basic_snapshot_nonumber.txt", __dir__)
+  FIXTURE_UNICODE_SCROLL = File.expand_path("fixtures/render_unicode_scrolled_snapshot.txt", __dir__)
+
+  def test_basic_render_frame_matches_snapshot
+    snapshot = build_snapshot(
+      lines: ["# title", "", "foo", "bar 日本語 編集", "baz"],
+      winsize: [8, 24],
+      number: true
+    )
+    expected = File.read(FIXTURE)
+    assert_equal expected, snapshot
+  end
+
+  def test_basic_render_frame_without_number_matches_snapshot
+    snapshot = build_snapshot(
+      lines: ["# title", "", "foo", "bar 日本語 編集", "baz"],
+      winsize: [8, 24],
+      number: false
+    )
+    expected = File.read(FIXTURE_NONUM)
+    assert_equal expected, snapshot
+  end
+
+  def test_unicode_scrolled_render_matches_snapshot
+    snapshot = build_snapshot(
+      lines: ["# title", "", "foo", "bar 日本語 編集", "baz", "qux", "quux"],
+      winsize: [7, 20],
+      number: true,
+      cursor_y: 3,
+      cursor_x: 4
+    )
+    expected = File.read(FIXTURE_UNICODE_SCROLL)
+    assert_equal expected, snapshot
+  end
+
+  private
+
+  def build_snapshot(lines:, winsize:, number:, cursor_y: 0, cursor_x: 0)
+    editor = RuVim::Editor.new
+    buf = editor.add_empty_buffer
+    win = editor.add_window(buffer_id: buf.id)
+    buf.replace_all_lines!(lines)
+    editor.set_option("number", number, scope: :window, window: win, buffer: buf)
+    win.cursor_y = cursor_y
+    win.cursor_x = cursor_x
+
+    term = TerminalStub.new(winsize)
+    screen = RuVim::Screen.new(terminal: term)
+
+    rows, cols = term.winsize
+    text_rows, text_cols = editor.text_viewport_size(rows:, cols:)
+    rects = screen.send(:window_rects, editor, text_rows:, text_cols:)
+    win.ensure_visible(buf, height: text_rows, width: text_cols, tabstop: 2)
+    frame = screen.send(:build_frame, editor, rows:, cols:, text_rows:, text_cols:, rects:)
+
+    (1..rows).map { |row| strip_ansi(frame[:lines][row].to_s) }.join("\n")
+  end
+
+  def strip_ansi(str)
+    str.gsub(/\e\[[0-9;?]*[A-Za-z]/, "")
+  end
+end

data/test/screen_test.rb

@@ -0,0 +1,123 @@
+require_relative "test_helper"
+
+class ScreenTest < Minitest::Test
+  TerminalStub = Struct.new(:winsize) do
+    attr_reader :writes
+
+    def write(data)
+      @writes ||= []
+      @writes << data
+    end
+  end
+
+  def test_horizontal_render_draws_all_visible_rows
+    editor = RuVim::Editor.new
+    buf = editor.add_empty_buffer
+    editor.add_window(buffer_id: buf.id)
+    buf.replace_all_lines!(["# title", "", "foo", "bar 日本語 編集", "baz"])
+
+    term = TerminalStub.new([8, 20])
+    screen = RuVim::Screen.new(terminal: term)
+
+    rows, cols = term.winsize
+    text_rows, text_cols = editor.text_viewport_size(rows:, cols:)
+    rects = screen.send(:window_rects, editor, text_rows:, text_cols:)
+    editor.window_order.each do |win_id|
+      w = editor.windows.fetch(win_id)
+      b = editor.buffers.fetch(w.buffer_id)
+      w.ensure_visible(b, height: text_rows, width: text_cols)
+    end
+    frame = screen.send(:build_frame, editor, rows:, cols:, text_rows:, text_cols:, rects:)
+
+    assert_includes frame[:lines][1], "#"
+    assert frame[:lines].key?(2), "row 2 should be rendered"
+    assert_includes frame[:lines][3], "foo"
+    assert_includes frame[:lines][4], "bar"
+    assert_includes frame[:lines][5], "baz"
+  end
+
+  def test_line_number_prefix_supports_relativenumber
+    editor = RuVim::Editor.new
+    buf = editor.add_empty_buffer
+    win = editor.add_window(buffer_id: buf.id)
+    buf.replace_all_lines!(["aa", "bb", "cc", "dd"])
+    win.cursor_y = 2
+    editor.set_option("relativenumber", true, scope: :window, window: win, buffer: buf)
+
+    term = TerminalStub.new([8, 20])
+    screen = RuVim::Screen.new(terminal: term)
+
+    assert_equal " 2 ", screen.send(:line_number_prefix, editor, win, buf, 0, 3)
+    assert_equal " 1 ", screen.send(:line_number_prefix, editor, win, buf, 1, 3)
+    assert_equal " 0 ", screen.send(:line_number_prefix, editor, win, buf, 2, 3)
+
+    editor.set_option("number", true, scope: :window, window: win, buffer: buf)
+    assert_equal " 3 ", screen.send(:line_number_prefix, editor, win, buf, 2, 3) # current line is absolute when both enabled
+  end
+
+  def test_render_shows_error_message_on_command_line_row_with_highlight
+    editor = RuVim::Editor.new
+    buf = editor.add_empty_buffer
+    editor.add_window(buffer_id: buf.id)
+    term = TerminalStub.new([6, 20])
+    screen = RuVim::Screen.new(terminal: term)
+
+    editor.echo_error("boom")
+    screen.render(editor)
+    out = term.writes.last
+    assert_includes out, "\e[97;41m"
+    assert_includes out, "boom"
+  end
+
+  def test_render_reuses_syntax_highlight_cache_for_same_line
+    editor = RuVim::Editor.new
+    buf = editor.add_empty_buffer
+    win = editor.add_window(buffer_id: buf.id)
+    buf.replace_all_lines!(['def x; "hi"; end'])
+    editor.set_option("filetype", "ruby", scope: :buffer, buffer: buf, window: win)
+
+    term = TerminalStub.new([6, 40])
+    screen = RuVim::Screen.new(terminal: term)
+
+    calls = 0
+    mod = RuVim::Highlighter.singleton_class
+    verbose, $VERBOSE = $VERBOSE, nil
+    mod.alias_method(:__orig_color_columns_for_screen_test, :color_columns)
+    mod.define_method(:color_columns) do |*args, **kwargs|
+      calls += 1
+      __orig_color_columns_for_screen_test(*args, **kwargs)
+    end
+
+    begin
+      screen.render(editor)
+      screen.render(editor)
+    ensure
+      mod.alias_method(:color_columns, :__orig_color_columns_for_screen_test)
+      mod.remove_method(:__orig_color_columns_for_screen_test) rescue nil
+      $VERBOSE = verbose
+    end
+
+    assert_equal 1, calls
+  end
+
+  def test_render_text_line_with_cursor_search_and_syntax_highlights_fits_width
+    editor = RuVim::Editor.new
+    buf = editor.add_empty_buffer
+    win = editor.add_window(buffer_id: buf.id)
+    buf.replace_all_lines!(['def x; "日本語"; end'])
+    editor.set_option("filetype", "ruby", scope: :buffer, buffer: buf, window: win)
+    editor.set_last_search(pattern: "日本", direction: :forward)
+    win.cursor_y = 0
+    win.cursor_x = 8 # around string body
+
+    term = TerminalStub.new([6, 18])
+    screen = RuVim::Screen.new(terminal: term)
+    line = buf.line_at(0)
+
+    out = screen.send(:render_text_line, line, editor, buffer_row: 0, window: win, buffer: buf, width: 10)
+    visible = out.gsub(/\e\[[0-9;?]*[A-Za-z]/, "")
+
+    assert_equal 10, RuVim::DisplayWidth.display_width(visible, tabstop: 2)
+    refute_includes out, "\n"
+  end
+end

data/test/search_option_test.rb

@@ -0,0 +1,39 @@
+require_relative "test_helper"
+
+class SearchOptionTest < Minitest::Test
+  TerminalStub = Struct.new(:winsize) do
+    def write(_data); end
+  end
+
+  def setup
+    @editor = RuVim::Editor.new
+    @buf = @editor.add_empty_buffer
+    @win = @editor.add_window(buffer_id: @buf.id)
+    @gc = RuVim::GlobalCommands.instance
+  end
+
+  def test_ignorecase_and_smartcase_affect_search_regex
+    regex = @gc.send(:compile_search_regex, "abc", editor: @editor, window: @win, buffer: @buf)
+    refute regex.match?("ABC")
+
+    @editor.set_option("ignorecase", true, scope: :global)
+    regex = @gc.send(:compile_search_regex, "abc", editor: @editor, window: @win, buffer: @buf)
+    assert regex.match?("ABC")
+
+    @editor.set_option("smartcase", true, scope: :global)
+    regex = @gc.send(:compile_search_regex, "Abc", editor: @editor, window: @win, buffer: @buf)
+    refute regex.match?("abc")
+  end
+
+  def test_hlsearch_option_controls_search_highlight
+    screen = RuVim::Screen.new(terminal: TerminalStub.new([10, 40]))
+    @editor.set_last_search(pattern: "foo", direction: :forward)
+
+    cols = screen.send(:search_highlight_source_cols, @editor, "foo bar", source_col_offset: 0)
+    assert_equal true, cols[0]
+
+    @editor.set_option("hlsearch", false, scope: :global)
+    cols = screen.send(:search_highlight_source_cols, @editor, "foo bar", source_col_offset: 0)
+    assert_equal({}, cols)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "minitest/autorun"
+require "ruvim"
+
+module RuVimTestHelpers
+  def fresh_editor
+    editor = RuVim::Editor.new
+    editor.ensure_bootstrap_buffer!
+    editor
+  end
+end
+
+class Minitest::Test
+  include RuVimTestHelpers
+end