ruvim 0.1.0 → 0.3.0

data/test/dispatcher_test.rb

@@ -1,4 +1,5 @@
 require_relative "test_helper"
+require "tmpdir"
 
 class DispatcherTest < Minitest::Test
   def setup
@@ -32,6 +33,53 @@ class DispatcherTest < Minitest::Test
     assert_includes body, "Write current buffer"
   end
 
+  def test_dispatch_ex_bindings_lists_buffer_filetype_and_app_layers
+    keymaps = @app.instance_variable_get(:@keymaps)
+    @editor.current_buffer.options["filetype"] = "ruby"
+    keymaps.bind_buffer(@editor.current_buffer.id, "Q", "ui.clear_message")
+    keymaps.bind_filetype("ruby", "K", "cursor.up", mode: :normal)
+
+    @dispatcher.dispatch_ex(@editor, "bindings")
+
+    assert_equal "[Bindings]", @editor.message
+    assert_equal :help, @editor.current_buffer.kind
+    body = @editor.current_buffer.lines.join("\n")
+    assert_includes body, "Layer: buffer"
+    assert_includes body, "Layer: filetype"
+    assert_includes body, "Layer: app"
+    assert_operator body.index("Layer: buffer"), :<, body.index("Layer: filetype")
+    assert_operator body.index("Layer: filetype"), :<, body.index("Layer: app")
+    assert_includes body, "Q"
+    assert_includes body, "K"
+    assert_includes body, "gg"
+    assert_includes body, "f"
+    assert_includes body, "normal.find_char_forward_start"
+    assert_includes body, "Move to start of buffer"
+    assert_includes body, "Start char find forward"
+    assert_includes body, "Clear message"
+  end
+
+  def test_dispatch_ex_bindings_sort_command_sorts_within_group_by_command_id
+    keymaps = @app.instance_variable_get(:@keymaps)
+    keymaps.bind_buffer(@editor.current_buffer.id, "K", "ui.clear_message")
+    keymaps.bind_buffer(@editor.current_buffer.id, "Q", "cursor.up")
+
+    @dispatcher.dispatch_ex(@editor, "bindings sort=command")
+
+    body = @editor.current_buffer.lines.join("\n")
+    assert_includes body, "Sort: command"
+
+    buffer_section = body.split("Layer: buffer", 2).last
+    refute_nil buffer_section
+    buffer_section = buffer_section.split("Layer: app", 2).first.to_s
+
+    up_idx = buffer_section.index("cursor.up")
+    clear_idx = buffer_section.index("ui.clear_message")
+    refute_nil up_idx
+    refute_nil clear_idx
+    assert_operator up_idx, :<, clear_idx
+  end
+
   def test_dispatch_ex_command_and_ruby
     @dispatcher.dispatch_ex(@editor, "command Hi help")
     assert_equal "Defined :Hi", @editor.message
@@ -43,6 +91,49 @@ class DispatcherTest < Minitest::Test
     assert_equal "ruby: 3", @editor.message
   end
 
+  def test_dispatch_ex_commands_shows_description_and_bound_keys
+    keymaps = @app.instance_variable_get(:@keymaps)
+    keymaps.bind(:normal, "K", "editor.buffer_next")
+
+    @dispatcher.dispatch_ex(@editor, "commands")
+
+    assert_equal "[Commands]", @editor.message
+    assert_equal :help, @editor.current_buffer.kind
+    body = @editor.current_buffer.lines.join("\n")
+    assert_includes body, "bnext"
+    assert_includes body, "Next buffer"
+    assert_includes body, "keys: K"
+  end
+
+  def test_dispatch_ex_ruby_captures_stdout_and_stderr_into_virtual_buffer
+    @dispatcher.dispatch_ex(@editor, "ruby STDOUT.puts(%q[out]); STDERR.puts(%q[err]); 42")
+
+    assert_equal "[Ruby Output]", @editor.message
+    assert_equal :help, @editor.current_buffer.kind
+    body = @editor.current_buffer.lines.join("\n")
+    assert_includes body, "[stdout]"
+    assert_includes body, "out"
+    assert_includes body, "[stderr]"
+    assert_includes body, "err"
+    assert_includes body, "[result]"
+    assert_includes body, "42"
+  end
+
+  def test_dispatch_ex_shell_captures_stdout_and_stderr_into_virtual_buffer
+    @dispatcher.dispatch_ex(@editor, "!echo out; echo err 1>&2")
+
+    assert_equal "[Shell Output]", @editor.message
+    assert_equal :help, @editor.current_buffer.kind
+    body = @editor.current_buffer.lines.join("\n")
+    assert_includes body, "[command]"
+    assert_includes body, "echo out; echo err 1>&2"
+    assert_includes body, "[stdout]"
+    assert_includes body, "out"
+    assert_includes body, "[stderr]"
+    assert_includes body, "err"
+    assert_includes body, "[status]"
+  end
+
   def test_dispatch_ex_set_commands
     @dispatcher.dispatch_ex(@editor, "set number")
     assert_equal true, @editor.current_window.options["number"]
@@ -121,4 +212,351 @@ class DispatcherTest < Minitest::Test
     @dispatcher.dispatch_ex(@editor, "lnext")
     assert_equal 1, @editor.current_window.cursor_y
   end
+
+  def test_hidden_option_allows_buffer_switch_without_bang
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["x"])
+    @editor.current_buffer.modified = true
+    other = @editor.add_empty_buffer(path: "other.txt")
+    @editor.set_option("hidden", true, scope: :global)
+
+    @dispatcher.dispatch_ex(@editor, "buffer #{other.id}")
+
+    assert_equal other.id, @editor.current_buffer.id
+    refute @editor.message_error?
+  end
+
+  def test_autowrite_saves_current_buffer_before_buffer_switch
+    Dir.mktmpdir("ruvim-autowrite") do |dir|
+      path = File.join(dir, "a.txt")
+      File.write(path, "old\n")
+      @editor.materialize_intro_buffer!
+      @editor.current_buffer.path = path
+      @editor.current_buffer.replace_all_lines!(["new"])
+      @editor.current_buffer.modified = true
+      other = @editor.add_empty_buffer(path: "other.txt")
+      @editor.set_option("autowrite", true, scope: :global)
+
+      @dispatcher.dispatch_ex(@editor, "buffer #{other.id}")
+
+      assert_equal other.id, @editor.current_buffer.id
+      assert_equal "new", File.read(path).strip
+    end
+  end
+
+  def test_bdelete_deletes_current_buffer_and_switches_to_another
+    @editor.materialize_intro_buffer!
+    first = @editor.current_buffer
+    other = @editor.add_empty_buffer(path: "other.txt")
+    @dispatcher.dispatch_ex(@editor, "buffer #{other.id}")
+    assert_equal other.id, @editor.current_buffer.id
+
+    @dispatcher.dispatch_ex(@editor, "bd")
+
+    assert_equal first.id, @editor.current_buffer.id
+    refute @editor.buffers.key?(other.id)
+    assert_equal "buffer #{other.id} deleted", @editor.message
+  end
+
+  def test_bdelete_rejects_modified_buffer_without_bang
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["x"])
+    @editor.current_buffer.modified = true
+
+    @dispatcher.dispatch_ex(@editor, "bd")
+
+    assert_equal true, @editor.message_error?
+    assert_match(/No write since last change/, @editor.message)
+    assert @editor.buffers.key?(@editor.current_buffer.id)
+  end
+
+  def test_bdelete_bang_deletes_modified_buffer
+    @editor.materialize_intro_buffer!
+    first = @editor.current_buffer
+    other = @editor.add_empty_buffer(path: "other.txt")
+    @dispatcher.dispatch_ex(@editor, "buffer #{other.id}")
+    @editor.current_buffer.replace_all_lines!(["dirty"])
+    @editor.current_buffer.modified = true
+
+    @dispatcher.dispatch_ex(@editor, "bd!")
+
+    assert_equal first.id, @editor.current_buffer.id
+    refute @editor.buffers.key?(other.id)
+    refute @editor.message_error?
+  end
+
+  def test_tabs_lists_all_tabpages
+    @editor.tabnew(path: nil)
+    @editor.tabnew(path: nil)
+    assert_equal 3, @editor.tabpage_count
+
+    @dispatcher.dispatch_ex(@editor, "tabs")
+
+    lines = @editor.hit_enter_lines
+    refute_nil lines, "tabs should produce multiline output"
+    joined = lines.join("\n")
+    assert_includes joined, "Tab page 1"
+    assert_includes joined, "Tab page 2"
+    assert_includes joined, "Tab page 3"
+  end
+
+  def test_splitbelow_and_splitright_change_insertion_side
+    @editor.set_option("splitbelow", false, scope: :global)
+    first = @editor.current_window_id
+    @dispatcher.dispatch_ex(@editor, "split")
+    assert_equal @editor.window_order[0], @editor.current_window_id
+    assert_equal first, @editor.window_order[1]
+
+    @editor.set_option("splitright", false, scope: :global)
+    @editor.current_window_id = first
+    @dispatcher.dispatch_ex(@editor, "vsplit")
+    idx = @editor.window_order.index(@editor.current_window_id)
+    assert_equal 1, idx
+  end
+
+  # --- Range parser tests ---
+
+  def test_parse_range_percent
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["a", "b", "c", "d", "e"])
+    result = @dispatcher.parse_range("%", @editor)
+    assert_equal 0, result[:range_start]
+    assert_equal 4, result[:range_end]
+    assert_equal "", result[:rest]
+  end
+
+  def test_parse_range_numeric_pair
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["a", "b", "c", "d", "e"])
+    result = @dispatcher.parse_range("1,5", @editor)
+    assert_equal 0, result[:range_start]
+    assert_equal 4, result[:range_end]
+    assert_equal "", result[:rest]
+  end
+
+  def test_parse_range_dot_and_dollar
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["a", "b", "c", "d", "e"])
+    @editor.current_window.cursor_y = 2
+
+    result = @dispatcher.parse_range(".,$", @editor)
+    assert_equal 2, result[:range_start]
+    assert_equal 4, result[:range_end]
+    assert_equal "", result[:rest]
+  end
+
+  def test_parse_range_with_offset
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["a", "b", "c", "d", "e"])
+    @editor.current_window.cursor_y = 1
+
+    result = @dispatcher.parse_range(".+2,$-1", @editor)
+    assert_equal 3, result[:range_start]
+    assert_equal 3, result[:range_end]
+    assert_equal "", result[:rest]
+  end
+
+  def test_parse_range_single_address
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["a", "b", "c"])
+    result = @dispatcher.parse_range("2", @editor)
+    assert_equal 1, result[:range_start]
+    assert_equal 1, result[:range_end]
+    assert_equal "", result[:rest]
+  end
+
+  def test_parse_range_returns_nil_for_no_range
+    @editor.materialize_intro_buffer!
+    result = @dispatcher.parse_range("help", @editor)
+    assert_nil result
+  end
+
+  def test_parse_range_with_rest
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["a", "b", "c", "d", "e"])
+    result = @dispatcher.parse_range("%s/a/b/g", @editor)
+    assert_equal 0, result[:range_start]
+    assert_equal 4, result[:range_end]
+    assert_equal "s/a/b/g", result[:rest]
+  end
+
+  def test_parse_range_mark_address
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["a", "b", "c", "d", "e"])
+    @editor.current_window.cursor_y = 1
+    @editor.set_mark("a")
+    @editor.current_window.cursor_y = 3
+    @editor.set_mark("b")
+
+    result = @dispatcher.parse_range("'a,'b", @editor)
+    assert_equal 1, result[:range_start]
+    assert_equal 3, result[:range_end]
+    assert_equal "", result[:rest]
+  end
+
+  # --- Substitute parser tests ---
+
+  def test_parse_substitute_basic
+    result = @dispatcher.parse_substitute("s/foo/bar/")
+    assert_equal "foo", result[:pattern]
+    assert_equal "bar", result[:replacement]
+    assert_equal "", result[:flags_str]
+  end
+
+  def test_parse_substitute_with_flags
+    result = @dispatcher.parse_substitute("s/foo/bar/gi")
+    assert_equal "foo", result[:pattern]
+    assert_equal "bar", result[:replacement]
+    assert_equal "gi", result[:flags_str]
+  end
+
+  def test_parse_substitute_returns_nil_for_non_substitute
+    assert_nil @dispatcher.parse_substitute("help")
+    assert_nil @dispatcher.parse_substitute("set number")
+  end
+
+  # --- Substitute with range integration ---
+
+  def test_substitute_with_range
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["foo", "foo", "foo", "foo", "foo"])
+
+    @dispatcher.dispatch_ex(@editor, "1,3s/foo/bar/")
+
+    assert_equal "bar", @editor.current_buffer.line_at(0)
+    assert_equal "bar", @editor.current_buffer.line_at(1)
+    assert_equal "bar", @editor.current_buffer.line_at(2)
+    assert_equal "foo", @editor.current_buffer.line_at(3)
+    assert_equal "foo", @editor.current_buffer.line_at(4)
+  end
+
+  def test_substitute_percent_range
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["foo", "bar", "foo"])
+
+    @dispatcher.dispatch_ex(@editor, "%s/foo/baz/")
+
+    assert_equal "baz", @editor.current_buffer.line_at(0)
+    assert_equal "bar", @editor.current_buffer.line_at(1)
+    assert_equal "baz", @editor.current_buffer.line_at(2)
+  end
+
+  def test_substitute_ignore_case_flag
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["FOO", "foo", "Foo"])
+
+    @dispatcher.dispatch_ex(@editor, "%s/foo/bar/gi")
+
+    assert_equal "bar", @editor.current_buffer.line_at(0)
+    assert_equal "bar", @editor.current_buffer.line_at(1)
+    assert_equal "bar", @editor.current_buffer.line_at(2)
+  end
+
+  def test_substitute_count_only_flag
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["foo", "bar", "foo baz foo"])
+
+    @dispatcher.dispatch_ex(@editor, "%s/foo/x/gn")
+
+    # n flag: count only, no changes
+    assert_equal "foo", @editor.current_buffer.line_at(0)
+    assert_equal "foo baz foo", @editor.current_buffer.line_at(2)
+    assert_match(/3 match/, @editor.message)
+  end
+
+  def test_substitute_no_range_defaults_to_whole_buffer
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["aaa", "bbb", "aaa"])
+
+    @dispatcher.dispatch_ex(@editor, "s/aaa/zzz/")
+
+    assert_equal "zzz", @editor.current_buffer.line_at(0)
+    assert_equal "bbb", @editor.current_buffer.line_at(1)
+    assert_equal "zzz", @editor.current_buffer.line_at(2)
+  end
+
+  # --- :d (delete lines) tests ---
+
+  def test_delete_lines_with_range
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["a", "b", "c", "d", "e"])
+
+    @dispatcher.dispatch_ex(@editor, "2,4d")
+
+    assert_equal 2, @editor.current_buffer.line_count
+    assert_equal "a", @editor.current_buffer.line_at(0)
+    assert_equal "e", @editor.current_buffer.line_at(1)
+    assert_match(/3 line/, @editor.message)
+  end
+
+  def test_delete_lines_without_range_deletes_current
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["a", "b", "c"])
+    @editor.current_window.cursor_y = 1
+
+    @dispatcher.dispatch_ex(@editor, "d")
+
+    assert_equal 2, @editor.current_buffer.line_count
+    assert_equal "a", @editor.current_buffer.line_at(0)
+    assert_equal "c", @editor.current_buffer.line_at(1)
+  end
+
+  # --- :y (yank lines) tests ---
+
+  def test_yank_lines_with_range
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["a", "b", "c", "d", "e"])
+
+    @dispatcher.dispatch_ex(@editor, "1,3y")
+
+    assert_match(/3 line/, @editor.message)
+    # Buffer unchanged
+    assert_equal 5, @editor.current_buffer.line_count
+  end
+
+  def test_yank_lines_without_range_yanks_current
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(["a", "b", "c"])
+    @editor.current_window.cursor_y = 1
+
+    @dispatcher.dispatch_ex(@editor, "y")
+
+    assert_match(/1 line/, @editor.message)
+    assert_equal 3, @editor.current_buffer.line_count
+  end
+
+  # --- :grep tests ---
+
+  def test_grep_populates_quickfix
+    Dir.mktmpdir("ruvim-grep") do |dir|
+      File.write(File.join(dir, "a.txt"), "hello world\ngoodbye\n")
+      File.write(File.join(dir, "b.txt"), "hello again\n")
+
+      @editor.materialize_intro_buffer!
+      @dispatcher.dispatch_ex(@editor, "grep hello #{File.join(dir, '*.txt')}")
+
+      assert_operator @editor.quickfix_items.length, :>=, 2
+      refute @editor.message_error?
+    end
+  end
+
+  def test_grep_no_matches_shows_error
+    @editor.materialize_intro_buffer!
+    @dispatcher.dispatch_ex(@editor, "grep ZZZZUNMATCHABLE /dev/null")
+
+    assert @editor.message_error?
+  end
+
+  def test_lgrep_populates_location_list
+    Dir.mktmpdir("ruvim-lgrep") do |dir|
+      File.write(File.join(dir, "c.txt"), "alpha\nbeta\nalpha\n")
+
+      @editor.materialize_intro_buffer!
+      wid = @editor.current_window_id
+      @dispatcher.dispatch_ex(@editor, "lgrep alpha #{File.join(dir, 'c.txt')}")
+
+      assert_operator @editor.location_items(wid).length, :>=, 2
+      refute @editor.message_error?
+    end
+  end
 end

data/test/display_width_test.rb

@@ -0,0 +1,18 @@
+require_relative "test_helper"
+
+class DisplayWidthTest < Minitest::Test
+  def test_ambiguous_width_cache_tracks_env_changes
+    prev = ENV["RUVIM_AMBIGUOUS_WIDTH"]
+    ENV["RUVIM_AMBIGUOUS_WIDTH"] = nil
+    assert_equal 1, RuVim::DisplayWidth.cell_width("Ω")
+
+    ENV["RUVIM_AMBIGUOUS_WIDTH"] = "2"
+    assert_equal 2, RuVim::DisplayWidth.cell_width("Ω")
+  ensure
+    if prev.nil?
+      ENV.delete("RUVIM_AMBIGUOUS_WIDTH")
+    else
+      ENV["RUVIM_AMBIGUOUS_WIDTH"] = prev
+    end
+  end
+end

data/test/editor_register_test.rb

@@ -1,4 +1,5 @@
 require_relative "test_helper"
+require "tmpdir"
 
 class EditorRegisterTest < Minitest::Test
   def test_named_register_and_append_register
@@ -61,4 +62,26 @@ class EditorRegisterTest < Minitest::Test
     buffer = editor.add_empty_buffer(path: "/tmp/example.rb")
     assert_equal "ruby", buffer.options["filetype"]
   end
+
+  def test_detect_filetype_from_shebang_when_extension_is_missing
+    editor = RuVim::Editor.new
+    Dir.mktmpdir("ruvim-shebang-ft") do |dir|
+      path = File.join(dir, "script")
+      File.binwrite(path, "#!/usr/bin/env ruby\nputs :ok\n")
+
+      buffer = editor.add_buffer_from_file(path)
+      assert_equal "ruby", buffer.options["filetype"]
+    end
+  end
+
+  def test_detect_filetype_from_env_shebang_with_dash_s
+    editor = RuVim::Editor.new
+    Dir.mktmpdir("ruvim-shebang-envs") do |dir|
+      path = File.join(dir, "tool")
+      File.binwrite(path, "#!/usr/bin/env -S python3 -u\nprint('ok')\n")
+
+      buffer = editor.add_buffer_from_file(path)
+      assert_equal "python", buffer.options["filetype"]
+    end
+  end
 end

data/test/fixtures/render_basic_snapshot.txt

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

data/test/fixtures/render_basic_snapshot_nonumber.txt

@@ -4,5 +4,4 @@ foo
 bar 日本語 編集         
 baz                     
 ~                       
-~                       
--- NORMAL -- t1/1 w 1:1 
+-- NORMAL -- [No Na 1:1 

data/test/fixtures/render_unicode_scrolled_snapshot.txt

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

data/test/highlighter_test.rb

@@ -13,4 +13,125 @@ class HighlighterTest < Minitest::Test
     assert_equal "\e[36m", cols[1] # key chars
     assert_equal "\e[33m", cols[6] # number start
   end
+
+  def test_ruby_highlighter_marks_instance_variables_and_constants
+    cols = RuVim::Highlighter.color_columns("ruby", "@x = Foo")
+    assert_equal "\e[93m", cols[0] # @x
+    assert_equal "\e[96m", cols[5] # F
+  end
+
+  # --- Markdown ---
+
+  def test_markdown_heading_h1
+    cols = RuVim::Highlighter.color_columns("markdown", "# Hello")
+    refute_empty cols
+    assert_equal "\e[1;33m", cols[0]  # bold yellow for H1
+    assert_equal "\e[1;33m", cols[6]  # entire line colored
+  end
+
+  def test_markdown_heading_h2
+    cols = RuVim::Highlighter.color_columns("markdown", "## Section")
+    assert_equal "\e[1;36m", cols[0]  # bold cyan for H2
+  end
+
+  def test_markdown_heading_h3_to_h6
+    colors = {
+      3 => "\e[1;32m",
+      4 => "\e[1;35m",
+      5 => "\e[1;34m",
+      6 => "\e[1;90m"
+    }
+    colors.each do |level, expected_color|
+      line = "#{"#" * level} Title"
+      cols = RuVim::Highlighter.color_columns("markdown", line)
+      assert_equal expected_color, cols[0], "H#{level} should use correct color"
+    end
+  end
+
+  def test_markdown_fence_line
+    cols = RuVim::Highlighter.color_columns("markdown", "```ruby")
+    refute_empty cols
+    assert_equal "\e[90m", cols[0]  # dim
+  end
+
+  def test_markdown_hr
+    cols = RuVim::Highlighter.color_columns("markdown", "---")
+    refute_empty cols
+    assert_equal "\e[90m", cols[0]  # dim
+  end
+
+  def test_markdown_block_quote_marker
+    cols = RuVim::Highlighter.color_columns("markdown", "> quoted text")
+    assert_equal "\e[36m", cols[0]  # cyan for >
+  end
+
+  def test_markdown_inline_bold
+    cols = RuVim::Highlighter.color_columns("markdown", "hello **bold** world")
+    # ** markers and content should be bold
+    assert_equal "\e[1m", cols[6]   # first *
+    assert_equal "\e[1m", cols[13]  # last *
+  end
+
+  def test_markdown_inline_code
+    cols = RuVim::Highlighter.color_columns("markdown", "use `foo()` here")
+    assert_equal "\e[33m", cols[4]  # backtick
+  end
+
+  def test_markdown_empty_line
+    cols = RuVim::Highlighter.color_columns("markdown", "")
+    assert_empty cols
+  end
+
+  def test_markdown_plain_text
+    cols = RuVim::Highlighter.color_columns("markdown", "plain text")
+    assert_empty cols
+  end
+
+  # --- Scheme ---
+
+  def test_scheme_keyword_define
+    cols = RuVim::Highlighter.color_columns("scheme", "(define x 42)")
+    assert_equal "\e[36m", cols[1]  # "define" keyword
+    assert_equal "\e[36m", cols[6]  # end of "define"
+  end
+
+  def test_scheme_keyword_lambda
+    cols = RuVim::Highlighter.color_columns("scheme", "(lambda (x) x)")
+    assert_equal "\e[36m", cols[1]  # "lambda"
+  end
+
+  def test_scheme_string
+    cols = RuVim::Highlighter.color_columns("scheme", '(display "hello")')
+    assert_equal "\e[32m", cols[9]  # opening quote
+    assert_equal "\e[32m", cols[15] # closing quote
+  end
+
+  def test_scheme_number
+    cols = RuVim::Highlighter.color_columns("scheme", "(+ 1 2.5)")
+    assert_equal "\e[33m", cols[3]  # "1"
+    assert_equal "\e[33m", cols[5]  # "2"
+  end
+
+  def test_scheme_boolean
+    cols = RuVim::Highlighter.color_columns("scheme", "(if #t #f)")
+    assert_equal "\e[35m", cols[4]  # "#t"
+    assert_equal "\e[35m", cols[7]  # "#f"
+  end
+
+  def test_scheme_comment
+    cols = RuVim::Highlighter.color_columns("scheme", "; this is a comment")
+    assert_equal "\e[90m", cols[0]  # ";"
+    assert_equal "\e[90m", cols[18] # end of comment
+  end
+
+  def test_scheme_char_literal
+    cols = RuVim::Highlighter.color_columns("scheme", '#\a #\space')
+    assert_equal "\e[32m", cols[0]  # "#\a"
+    assert_equal "\e[32m", cols[4]  # "#\space"
+  end
+
+  def test_scheme_empty_line
+    cols = RuVim::Highlighter.color_columns("scheme", "")
+    assert_empty cols
+  end
 end