ruvim 0.3.0 → 0.6.0

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

@@ -14,6 +14,12 @@ class HighlighterTest < Minitest::Test
     assert_equal "\e[33m", cols[6] # number start
   end
 
+  def test_jsonl_highlighter_reuses_json_colors
+    cols = RuVim::Highlighter.color_columns("jsonl", '{"a": 10}')
+    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
@@ -134,4 +140,167 @@ class HighlighterTest < Minitest::Test
     cols = RuVim::Highlighter.color_columns("scheme", "")
     assert_empty cols
   end
+
+  # --- Diff ---
+
+  def test_diff_add_line_green
+    cols = RuVim::Highlighter.color_columns("diff", "+added line")
+    refute_empty cols
+    assert_equal "\e[32m", cols[0]
+    assert_equal "\e[32m", cols[5]
+  end
+
+  def test_diff_delete_line_red
+    cols = RuVim::Highlighter.color_columns("diff", "-removed line")
+    refute_empty cols
+    assert_equal "\e[31m", cols[0]
+  end
+
+  def test_diff_hunk_header_cyan
+    cols = RuVim::Highlighter.color_columns("diff", "@@ -1,3 +1,4 @@ def foo")
+    refute_empty cols
+    assert_equal "\e[36m", cols[0]
+  end
+
+  def test_diff_header_bold
+    cols = RuVim::Highlighter.color_columns("diff", "diff --git a/foo.rb b/foo.rb")
+    refute_empty cols
+    assert_equal "\e[1m", cols[0]
+  end
+
+  def test_diff_context_line_no_color
+    cols = RuVim::Highlighter.color_columns("diff", " context line")
+    assert_empty cols
+  end
+
+  def test_diff_meta_line_yellow
+    cols = RuVim::Highlighter.color_columns("diff", "index abc..def 100644")
+    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

@@ -1,5 +1,91 @@
 require_relative "test_helper"
 
+class JsonIndentTest < Minitest::Test
+  def calc(lines, target_row, sw = 2)
+    RuVim::Lang::Json.calculate_indent(lines, target_row, sw)
+  end
+
+  def test_first_line_is_zero
+    assert_equal 0, calc(["{"], 0)
+  end
+
+  def test_after_open_brace
+    lines = ["{", '  "key": "value"']
+    assert_equal 2, calc(lines, 1)
+  end
+
+  def test_close_brace
+    lines = ["{", '  "key": "value"', "}"]
+    assert_equal 0, calc(lines, 2)
+  end
+
+  def test_after_open_bracket
+    lines = ["[", "  1"]
+    assert_equal 2, calc(lines, 1)
+  end
+
+  def test_close_bracket
+    lines = ["[", "  1,", "  2", "]"]
+    assert_equal 0, calc(lines, 3)
+  end
+
+  def test_nested_objects
+    lines = [
+      "{",
+      '  "a": {',
+      '    "b": 1',
+      "  }",
+      "}"
+    ]
+    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_array_in_object
+    lines = [
+      "{",
+      '  "items": [',
+      "    1,",
+      "    2",
+      "  ]",
+      "}"
+    ]
+    assert_equal 2, calc(lines, 1)
+    assert_equal 4, calc(lines, 2)
+    assert_equal 4, calc(lines, 3)
+    assert_equal 2, calc(lines, 4)
+    assert_equal 0, calc(lines, 5)
+  end
+
+  def test_shiftwidth_4
+    lines = ["{", '    "key": 1', "}"]
+    assert_equal 4, calc(lines, 1, 4)
+    assert_equal 0, calc(lines, 2, 4)
+  end
+
+  def test_indent_trigger_open_brace
+    assert RuVim::Lang::Json.indent_trigger?("{")
+    assert RuVim::Lang::Json.indent_trigger?('  "key": {')
+    assert RuVim::Lang::Json.indent_trigger?('  "key": [')
+  end
+
+  def test_indent_trigger_no_trigger
+    refute RuVim::Lang::Json.indent_trigger?('  "key": "value"')
+    refute RuVim::Lang::Json.indent_trigger?("}")
+  end
+
+  def test_dedent_trigger_close_brace
+    assert_kind_of Regexp, RuVim::Lang::Json.dedent_trigger("}")
+    assert_kind_of Regexp, RuVim::Lang::Json.dedent_trigger("]")
+  end
+
+  def test_dedent_trigger_no_trigger
+    assert_nil RuVim::Lang::Json.dedent_trigger("a")
+  end
+end
+
 class RubyIndentTest < Minitest::Test
   def calc(lines, target_row, sw = 2)
     RuVim::Lang::Ruby.calculate_indent(lines, target_row, sw)
@@ -199,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