ruvim 0.4.0 → 0.6.0

data/test/git_blame_test.rb

@@ -9,17 +9,20 @@ class GitBlameTest < Minitest::Test
     @app = RuVim::App.new(clean: true)
     @editor = @app.instance_variable_get(:@editor)
     @dispatcher = @app.instance_variable_get(:@dispatcher)
+    @key_handler = @app.instance_variable_get(:@key_handler)
+    @stream_mixer = @app.instance_variable_get(:@stream_mixer)
     @editor.materialize_intro_buffer!
   end
 
   def feed(*keys)
-    keys.each { |k| @app.send(:handle_key, k) }
+    keys.each { |k| @key_handler.handle(k) }
   end
 
   def drain_git_stream!
-    threads = @app.instance_variable_get(:@git_stream_threads)
-    threads&.each_value(&:join)
-    @app.send(:drain_stream_events!)
+    @editor.buffers.each_value do |buf|
+      buf.stream&.thread&.join
+    end
+    @stream_mixer.drain_events!
   end
 
   # --- Parsing ---
@@ -81,12 +84,66 @@ class GitBlameTest < Minitest::Test
       { short_hash: "abc12345", author: "Alice", date: "2023-11-14", text: "hello", orig_line: 1, hash: "abc12345" * 5 },
       { short_hash: "def67890", author: "Bob",   date: "2023-11-15", text: "world", orig_line: 2, hash: "def67890" * 5 },
     ]
-    lines = RuVim::Git::Blame.format_lines(entries)
+    lines, labels = RuVim::Git::Blame.format_lines(entries)
     assert_equal 2, lines.length
-    assert_includes lines[0], "abc12345"
-    assert_includes lines[0], "Alice"
-    assert_includes lines[0], "hello"
-    assert_includes lines[1], "Bob"
+    assert_equal "hello", lines[0]
+    assert_equal "world", lines[1]
+    assert_equal 2, labels.length
+    assert_includes labels[0], "abc12345"
+    assert_includes labels[0], "Alice"
+    assert_includes labels[1], "Bob"
+  end
+
+  def test_blame_buffer_has_source_filetype
+    Dir.mktmpdir do |dir|
+      setup_git_repo(dir, "test_file.rb", "puts 'hello'\n")
+
+      file_path = File.join(dir, "test_file.rb")
+      buf = @editor.add_buffer_from_file(file_path)
+      @editor.switch_to_buffer(buf.id)
+      assert_equal "ruby", buf.options["filetype"]
+
+      @dispatcher.dispatch_ex(@editor, "git blame")
+
+      blame_buf = @editor.current_buffer
+      assert_equal :blame, blame_buf.kind
+      assert_equal "ruby", blame_buf.options["filetype"]
+    end
+  end
+
+  def test_blame_buffer_has_gutter_labels
+    Dir.mktmpdir do |dir|
+      setup_git_repo(dir, "test_file.txt", "line1\nline2\n")
+
+      file_path = File.join(dir, "test_file.txt")
+      buf = @editor.add_buffer_from_file(file_path)
+      @editor.switch_to_buffer(buf.id)
+
+      @dispatcher.dispatch_ex(@editor, "git blame")
+
+      blame_buf = @editor.current_buffer
+      labels = blame_buf.options["gutter_labels"]
+      assert_kind_of Array, labels
+      assert_equal 2, labels.length
+      # Labels should contain hash and author info
+      assert_match(/\A[0-9a-f]{8} /, labels[0])
+    end
+  end
+
+  def test_blame_buffer_lines_are_code_only
+    Dir.mktmpdir do |dir|
+      setup_git_repo(dir, "test_file.txt", "line1\nline2\n")
+
+      file_path = File.join(dir, "test_file.txt")
+      buf = @editor.add_buffer_from_file(file_path)
+      @editor.switch_to_buffer(buf.id)
+
+      @dispatcher.dispatch_ex(@editor, "git blame")
+
+      blame_buf = @editor.current_buffer
+      assert_equal "line1", blame_buf.line_at(0)
+      assert_equal "line2", blame_buf.line_at(1)
+    end
   end
 
   # --- Status filename parsing ---
@@ -221,9 +278,14 @@ class GitBlameTest < Minitest::Test
     end
   end
 
-  def test_git_unknown_subcommand_shows_error
-    @dispatcher.dispatch_ex(@editor, "git unknown")
-    assert_match(/Unknown Git subcommand/, @editor.message)
+  def test_git_unknown_subcommand_runs_shell
+    executed = nil
+    fake_status = Struct.new(:exitstatus).new(0)
+    @editor.shell_executor = ->(cmd) { executed = cmd; fake_status }
+
+    @dispatcher.dispatch_ex(@editor, "git stash")
+
+    assert_equal "git stash", executed
   end
 
   def test_git_no_subcommand_shows_list
@@ -485,10 +547,9 @@ class GitBlameTest < Minitest::Test
     assert_nil RuVim::Git::Branch.parse_branch_name("")
   end
 
-  def test_git_branch_enter_checks_out
+  def test_git_branch_enter_populates_checkout_command
     Dir.mktmpdir do |dir|
       setup_git_repo(dir, "test_file.txt", "line1\n")
-      # Create a second branch
       Dir.chdir(dir) do
         system("git branch test-branch", exception: true)
       end
@@ -507,9 +568,27 @@ class GitBlameTest < Minitest::Test
 
       feed(:enter)
 
-      # Branch buffer should be closed, and we should have switched
-      refute_equal :git_branch, @editor.current_buffer.kind
-      # Verify checkout happened
+      # Should enter command-line mode with checkout command pre-filled
+      assert_equal :command_line, @editor.mode
+      assert_equal "git checkout test-branch", @editor.command_line.text
+    end
+  end
+
+  def test_git_checkout_subcommand_executes
+    Dir.mktmpdir do |dir|
+      setup_git_repo(dir, "test_file.txt", "line1\n")
+      Dir.chdir(dir) do
+        system("git branch test-branch", exception: true)
+      end
+
+      file_path = File.join(dir, "test_file.txt")
+      buf = @editor.add_buffer_from_file(file_path)
+      @editor.switch_to_buffer(buf.id)
+
+      @dispatcher.dispatch_ex(@editor, "git checkout test-branch")
+
+      refute @editor.message_error?, "Unexpected error: #{@editor.message}"
+      assert_includes @editor.message.to_s, "Switched to branch"
       Dir.chdir(dir) do
         current = `git rev-parse --abbrev-ref HEAD`.strip
         assert_equal "test-branch", current

data/test/git_grep_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class GitGrepTest < Minitest::Test
+  def setup
+    @app = RuVim::App.new(clean: true)
+    @editor = @app.instance_variable_get(:@editor)
+    @dispatcher = @app.instance_variable_get(:@dispatcher)
+    @key_handler = @app.instance_variable_get(:@key_handler)
+    @editor.materialize_intro_buffer!
+  end
+
+  def feed(*keys)
+    keys.each { |k| @key_handler.handle(k) }
+  end
+
+  # --- Parsing ---
+
+  def test_parse_location_basic
+    line = "lib/ruvim/app.rb:42:    def run"
+    result = RuVim::Git::Grep.parse_location(line)
+    assert_equal ["lib/ruvim/app.rb", 42], result
+  end
+
+  def test_parse_location_no_line_number
+    line = "lib/ruvim/app.rb:    def run"
+    result = RuVim::Git::Grep.parse_location(line)
+    assert_nil result
+  end
+
+  def test_parse_location_empty
+    result = RuVim::Git::Grep.parse_location("")
+    assert_nil result
+  end
+
+  def test_parse_location_separator_line
+    result = RuVim::Git::Grep.parse_location("--")
+    assert_nil result
+  end
+
+  def test_parse_location_with_colon_in_content
+    line = "config.rb:10:  url = \"http://example.com\""
+    result = RuVim::Git::Grep.parse_location(line)
+    assert_equal ["config.rb", 10], result
+  end
+
+  def test_parse_location_windows_style_path
+    line = "src/main.rb:5:hello"
+    result = RuVim::Git::Grep.parse_location(line)
+    assert_equal ["src/main.rb", 5], result
+  end
+
+  # --- Command registration ---
+
+  def test_git_grep_subcommand_registered
+    assert RuVim::Git::Handler::GIT_SUBCOMMANDS.key?("grep")
+  end
+
+  def test_git_grep_open_file_command_registered
+    cmd = RuVim::CommandRegistry.instance
+    assert cmd.registered?("git.grep.open_file")
+  end
+end

data/test/highlighter_test.rb

@@ -178,4 +178,129 @@ class HighlighterTest < Minitest::Test
     refute_empty cols
     assert_equal "\e[33m", cols[0]
   end
+
+  # --- C ---
+
+  def test_c_keyword_if
+    cols = RuVim::Highlighter.color_columns("c", "if (x > 0) {")
+    assert_equal "\e[36m", cols[0]  # "if"
+    assert_equal "\e[36m", cols[1]
+  end
+
+  def test_c_keyword_return
+    cols = RuVim::Highlighter.color_columns("c", "  return 0;")
+    assert_equal "\e[36m", cols[2]  # "return"
+  end
+
+  def test_c_type_keyword
+    cols = RuVim::Highlighter.color_columns("c", "int main(void) {")
+    assert_equal "\e[36m", cols[0]  # "int"
+    assert_equal "\e[36m", cols[9]  # "void"
+  end
+
+  def test_c_string
+    cols = RuVim::Highlighter.color_columns("c", 'printf("hello");')
+    assert_equal "\e[32m", cols[7]  # opening quote
+    assert_equal "\e[32m", cols[13] # closing quote
+  end
+
+  def test_c_char_literal
+    cols = RuVim::Highlighter.color_columns("c", "char c = 'a';")
+    assert_equal "\e[32m", cols[9]  # opening quote
+    assert_equal "\e[32m", cols[11] # closing quote
+  end
+
+  def test_c_number_decimal
+    cols = RuVim::Highlighter.color_columns("c", "int x = 42;")
+    assert_equal "\e[33m", cols[8]  # "4"
+    assert_equal "\e[33m", cols[9]  # "2"
+  end
+
+  def test_c_number_hex
+    cols = RuVim::Highlighter.color_columns("c", "int x = 0xFF;")
+    assert_equal "\e[33m", cols[8]  # "0"
+    assert_equal "\e[33m", cols[11] # "F"
+  end
+
+  def test_c_line_comment
+    cols = RuVim::Highlighter.color_columns("c", "x = 1; // comment")
+    assert_equal "\e[90m", cols[7]  # "//"
+    assert_equal "\e[90m", cols[16] # end of comment
+  end
+
+  def test_c_block_comment_single_line
+    cols = RuVim::Highlighter.color_columns("c", "x = 1; /* comment */")
+    assert_equal "\e[90m", cols[7]  # "/*"
+    assert_equal "\e[90m", cols[19] # "*/"
+  end
+
+  def test_c_preprocessor
+    cols = RuVim::Highlighter.color_columns("c", "#include <stdio.h>")
+    assert_equal "\e[35m", cols[0]  # "#"
+    assert_equal "\e[35m", cols[7]  # "e" of include
+  end
+
+  def test_c_define_preprocessor
+    cols = RuVim::Highlighter.color_columns("c", "#define MAX 100")
+    assert_equal "\e[35m", cols[0]  # "#"
+  end
+
+  def test_c_constant_macro
+    cols = RuVim::Highlighter.color_columns("c", "if (ptr == NULL) {")
+    assert_equal "\e[96m", cols[11] # "N" of NULL
+  end
+
+  def test_c_all_caps_identifier
+    cols = RuVim::Highlighter.color_columns("c", "x = MAX_SIZE;")
+    assert_equal "\e[96m", cols[4]  # "M"
+  end
+
+  def test_c_empty_line
+    cols = RuVim::Highlighter.color_columns("c", "")
+    assert_empty cols
+  end
+
+  # --- C++ ---
+
+  def test_cpp_keyword_class
+    cols = RuVim::Highlighter.color_columns("cpp", "class Foo {")
+    assert_equal "\e[36m", cols[0]  # "class"
+    assert_equal "\e[36m", cols[4]
+  end
+
+  def test_cpp_keyword_namespace
+    cols = RuVim::Highlighter.color_columns("cpp", "namespace std {")
+    assert_equal "\e[36m", cols[0]  # "namespace"
+  end
+
+  def test_cpp_keyword_template
+    cols = RuVim::Highlighter.color_columns("cpp", "template <typename T>")
+    assert_equal "\e[36m", cols[0]  # "template"
+    assert_equal "\e[36m", cols[10] # "typename"
+  end
+
+  def test_cpp_keyword_nullptr
+    cols = RuVim::Highlighter.color_columns("cpp", "int* p = nullptr;")
+    assert_equal "\e[36m", cols[9]  # "nullptr"
+  end
+
+  def test_cpp_keyword_auto
+    cols = RuVim::Highlighter.color_columns("cpp", "auto x = 42;")
+    assert_equal "\e[36m", cols[0]  # "auto"
+  end
+
+  def test_cpp_inherits_c_string
+    cols = RuVim::Highlighter.color_columns("cpp", 'std::cout << "hello";')
+    assert_equal "\e[32m", cols[13] # opening quote
+  end
+
+  def test_cpp_inherits_c_comment
+    cols = RuVim::Highlighter.color_columns("cpp", "x = 1; // comment")
+    assert_equal "\e[90m", cols[7]  # "//"
+  end
+
+  def test_cpp_empty_line
+    cols = RuVim::Highlighter.color_columns("cpp", "")
+    assert_empty cols
+  end
 end

data/test/indent_test.rb

@@ -285,3 +285,140 @@ class RubyIndentTest < Minitest::Test
     assert_equal 0, calc(lines, 3)  # end
   end
 end
+
+class CIndentTest < Minitest::Test
+  def calc(lines, target_row, sw = 2)
+    RuVim::Lang::C.calculate_indent(lines, target_row, sw)
+  end
+
+  def test_first_line_is_zero
+    assert_equal 0, calc(["int main() {"], 0)
+  end
+
+  def test_after_open_brace
+    lines = ["int main() {", "  return 0;"]
+    assert_equal 2, calc(lines, 1)
+  end
+
+  def test_close_brace
+    lines = ["int main() {", "  return 0;", "}"]
+    assert_equal 0, calc(lines, 2)
+  end
+
+  def test_nested_braces
+    lines = [
+      "void foo() {",
+      "  if (x) {",
+      "    bar();",
+      "  }",
+      "}"
+    ]
+    assert_equal 2, calc(lines, 1)
+    assert_equal 4, calc(lines, 2)
+    assert_equal 2, calc(lines, 3)
+    assert_equal 0, calc(lines, 4)
+  end
+
+  def test_switch_case
+    lines = [
+      "switch (x) {",
+      "case 1:",
+      "  foo();",
+      "  break;",
+      "case 2:",
+      "  bar();",
+      "  break;",
+      "default:",
+      "  baz();",
+      "}"
+    ]
+    assert_equal 0, calc(lines, 1)  # case 1:
+    assert_equal 2, calc(lines, 2)  # foo()
+    assert_equal 2, calc(lines, 3)  # break
+    assert_equal 0, calc(lines, 4)  # case 2:
+    assert_equal 2, calc(lines, 5)  # bar()
+    assert_equal 0, calc(lines, 7)  # default:
+    assert_equal 2, calc(lines, 8)  # baz()
+    assert_equal 0, calc(lines, 9)  # }
+  end
+
+  def test_shiftwidth_4
+    lines = ["void foo() {", "    bar();", "}"]
+    assert_equal 4, calc(lines, 1, 4)
+    assert_equal 0, calc(lines, 2, 4)
+  end
+
+  def test_indent_trigger_open_brace
+    assert RuVim::Lang::C.indent_trigger?("int main() {")
+    assert RuVim::Lang::C.indent_trigger?("if (x) {")
+  end
+
+  def test_indent_trigger_no_trigger
+    refute RuVim::Lang::C.indent_trigger?("return 0;")
+    refute RuVim::Lang::C.indent_trigger?("}")
+  end
+
+  def test_dedent_trigger_close_brace
+    assert_kind_of Regexp, RuVim::Lang::C.dedent_trigger("}")
+  end
+
+  def test_dedent_trigger_no_trigger
+    assert_nil RuVim::Lang::C.dedent_trigger("a")
+  end
+end
+
+class CppIndentTest < Minitest::Test
+  def calc(lines, target_row, sw = 2)
+    RuVim::Lang::Cpp.calculate_indent(lines, target_row, sw)
+  end
+
+  def test_class_body
+    lines = [
+      "class Foo {",
+      "  int x;",
+      "};"
+    ]
+    assert_equal 2, calc(lines, 1)
+    assert_equal 0, calc(lines, 2)
+  end
+
+  def test_namespace_body
+    lines = [
+      "namespace ns {",
+      "  class Bar {",
+      "    void f();",
+      "  };",
+      "}"
+    ]
+    assert_equal 2, calc(lines, 1)
+    assert_equal 4, calc(lines, 2)
+    assert_equal 2, calc(lines, 3)
+    assert_equal 0, calc(lines, 4)
+  end
+
+  def test_access_specifier_dedent
+    lines = [
+      "class Foo {",
+      "public:",
+      "  int x;",
+      "private:",
+      "  int y;",
+      "};"
+    ]
+    assert_equal 0, calc(lines, 1)  # public:
+    assert_equal 2, calc(lines, 2)  # int x
+    assert_equal 0, calc(lines, 3)  # private:
+    assert_equal 2, calc(lines, 4)  # int y
+    assert_equal 0, calc(lines, 5)  # };
+  end
+
+  def test_indent_trigger
+    assert RuVim::Lang::Cpp.indent_trigger?("class Foo {")
+    assert RuVim::Lang::Cpp.indent_trigger?("namespace ns {")
+  end
+
+  def test_dedent_trigger
+    assert_kind_of Regexp, RuVim::Lang::Cpp.dedent_trigger("}")
+    assert_nil RuVim::Lang::Cpp.dedent_trigger("x")
+  end
+end

data/test/input_screen_integration_test.rb

@@ -62,7 +62,7 @@ class InputScreenIntegrationTest < Minitest::Test
       key = input.read_key(timeout: 0.2)
       assert_equal :pagedown, key
 
-      app.send(:handle_normal_key, key)
+      app.instance_variable_get(:@key_handler).send(:handle_normal_key, key)
       screen.render(editor)
 
       assert_operator editor.current_window.cursor_y, :>, 0

data/test/keyword_chars_test.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class KeywordCharsTest < Minitest::Test
+  def setup
+    # Clear caches between tests
+    RuVim::KeywordChars.instance_variable_set(:@char_class_cache, nil)
+    RuVim::KeywordChars.instance_variable_set(:@regex_cache, nil)
+  end
+
+  # --- char_class ---
+
+  def test_char_class_default_for_empty
+    assert_equal "[:alnum:]_", RuVim::KeywordChars.char_class("")
+  end
+
+  def test_char_class_default_for_nil
+    assert_equal "[:alnum:]_", RuVim::KeywordChars.char_class(nil)
+  end
+
+  def test_char_class_single_char
+    result = RuVim::KeywordChars.char_class("-")
+    assert_includes result, "[:alnum:]_"
+    assert_includes result, "\\-"
+  end
+
+  def test_char_class_range
+    result = RuVim::KeywordChars.char_class("65-90")
+    assert_includes result, "[:alnum:]_"
+    # Should include A-Z range
+    assert_includes result, "A-Z"
+  end
+
+  def test_char_class_reversed_range
+    # minmax should handle reversed ranges
+    result = RuVim::KeywordChars.char_class("90-65")
+    assert_includes result, "A-Z"
+  end
+
+  def test_char_class_skips_at_sign
+    result = RuVim::KeywordChars.char_class("@")
+    assert_equal "[:alnum:]_", result
+  end
+
+  def test_char_class_skips_out_of_range
+    result = RuVim::KeywordChars.char_class("256-300")
+    assert_equal "[:alnum:]_", result
+  end
+
+  def test_char_class_mixed_spec
+    result = RuVim::KeywordChars.char_class("-,65-90")
+    assert_includes result, "\\-"
+    assert_includes result, "A-Z"
+  end
+
+  def test_char_class_caches_result
+    result1 = RuVim::KeywordChars.char_class("-")
+    result2 = RuVim::KeywordChars.char_class("-")
+    assert_same result1, result2
+  end
+
+  # --- regex ---
+
+  def test_regex_default_for_empty
+    assert_equal RuVim::KeywordChars::DEFAULT_REGEX, RuVim::KeywordChars.regex("")
+  end
+
+  def test_regex_default_for_nil
+    assert_equal RuVim::KeywordChars::DEFAULT_REGEX, RuVim::KeywordChars.regex(nil)
+  end
+
+  def test_regex_matches_with_spec
+    re = RuVim::KeywordChars.regex("-")
+    assert_match re, "a"
+    assert_match re, "-"
+    refute_match re, " "
+  end
+
+  def test_regex_caches_result
+    result1 = RuVim::KeywordChars.regex("-")
+    result2 = RuVim::KeywordChars.regex("-")
+    assert_same result1, result2
+  end
+end