ruvim 0.2.0 → 0.4.0

data/test/highlighter_test.rb

@@ -13,4 +13,169 @@ class HighlighterTest < Minitest::Test
     assert_equal "\e[36m", cols[1] # key chars
     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
+    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
+
+  # --- 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
 end

data/test/indent_test.rb

@@ -0,0 +1,287 @@
+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)
+  end
+
+  def test_first_line_is_zero
+    assert_equal 0, calc(["hello"], 0)
+  end
+
+  def test_after_def
+    lines = ["def foo", "  bar"]
+    assert_equal 2, calc(lines, 1)
+  end
+
+  def test_end_returns_to_zero
+    lines = ["def foo", "  bar", "end"]
+    assert_equal 0, calc(lines, 2)
+  end
+
+  def test_class_def_end_nesting
+    lines = [
+      "class Foo",
+      "  def bar",
+      "    baz",
+      "  end",
+      "end"
+    ]
+    assert_equal 2, calc(lines, 1)  # def bar
+    assert_equal 4, calc(lines, 2)  # baz
+    assert_equal 2, calc(lines, 3)  # end (inner)
+    assert_equal 0, calc(lines, 4)  # end (outer)
+  end
+
+  def test_if_else_end
+    lines = [
+      "if cond",
+      "  a",
+      "else",
+      "  b",
+      "end"
+    ]
+    assert_equal 2, calc(lines, 1)  # a
+    assert_equal 0, calc(lines, 2)  # else
+    assert_equal 2, calc(lines, 3)  # b
+    assert_equal 0, calc(lines, 4)  # end
+  end
+
+  def test_if_elsif_else_end
+    lines = [
+      "if a",
+      "  x",
+      "elsif b",
+      "  y",
+      "else",
+      "  z",
+      "end"
+    ]
+    assert_equal 2, calc(lines, 1)  # x
+    assert_equal 0, calc(lines, 2)  # elsif
+    assert_equal 2, calc(lines, 3)  # y
+    assert_equal 0, calc(lines, 4)  # else
+    assert_equal 2, calc(lines, 5)  # z
+    assert_equal 0, calc(lines, 6)  # end
+  end
+
+  def test_modifier_if_does_not_increase_indent
+    lines = [
+      "def foo",
+      "  return if true",
+      "  bar",
+      "end"
+    ]
+    assert_equal 2, calc(lines, 1)  # return if true
+    assert_equal 2, calc(lines, 2)  # bar
+    assert_equal 0, calc(lines, 3)  # end
+  end
+
+  def test_do_end_block
+    lines = [
+      "items.each do |x|",
+      "  puts x",
+      "end"
+    ]
+    assert_equal 2, calc(lines, 1)  # puts x
+    assert_equal 0, calc(lines, 2)  # end
+  end
+
+  def test_brace_block
+    lines = [
+      "items.map {",
+      "  |x| x + 1",
+      "}"
+    ]
+    assert_equal 2, calc(lines, 1)
+    assert_equal 0, calc(lines, 2)
+  end
+
+  def test_case_when
+    lines = [
+      "case x",
+      "when 1",
+      "  a",
+      "when 2",
+      "  b",
+      "end"
+    ]
+    assert_equal 0, calc(lines, 1)  # when 1
+    assert_equal 2, calc(lines, 2)  # a
+    assert_equal 0, calc(lines, 3)  # when 2
+    assert_equal 2, calc(lines, 4)  # b
+    assert_equal 0, calc(lines, 5)  # end
+  end
+
+  def test_rescue_ensure
+    lines = [
+      "begin",
+      "  risky",
+      "rescue => e",
+      "  handle",
+      "ensure",
+      "  cleanup",
+      "end"
+    ]
+    assert_equal 2, calc(lines, 1)  # risky
+    assert_equal 0, calc(lines, 2)  # rescue
+    assert_equal 2, calc(lines, 3)  # handle
+    assert_equal 0, calc(lines, 4)  # ensure
+    assert_equal 2, calc(lines, 5)  # cleanup
+    assert_equal 0, calc(lines, 6)  # end
+  end
+
+  def test_unless_until_while_for
+    %w[unless until while for].each do |kw|
+      lines = ["#{kw} cond", "  body", "end"]
+      assert_equal 2, calc(lines, 1), "body after #{kw}"
+      assert_equal 0, calc(lines, 2), "end after #{kw}"
+    end
+  end
+
+  def test_module_nesting
+    lines = [
+      "module A",
+      "  module B",
+      "    def foo",
+      "      bar",
+      "    end",
+      "  end",
+      "end"
+    ]
+    assert_equal 2, calc(lines, 1)  # module B
+    assert_equal 4, calc(lines, 2)  # def foo
+    assert_equal 6, calc(lines, 3)  # bar
+    assert_equal 4, calc(lines, 4)  # end (inner)
+    assert_equal 2, calc(lines, 5)  # end (mid)
+    assert_equal 0, calc(lines, 6)  # end (outer)
+  end
+
+  def test_comment_lines_are_skipped
+    lines = [
+      "def foo",
+      "  # comment",
+      "  bar",
+      "end"
+    ]
+    assert_equal 2, calc(lines, 1)  # comment
+    assert_equal 2, calc(lines, 2)  # bar
+    assert_equal 0, calc(lines, 3)  # end
+  end
+
+  def test_shiftwidth_4
+    lines = ["def foo", "    bar", "end"]
+    assert_equal 4, calc(lines, 1, 4)
+    assert_equal 0, calc(lines, 2, 4)
+  end
+
+  def test_paren_bracket_nesting
+    lines = [
+      "x = [",
+      "  1,",
+      "  2",
+      "]"
+    ]
+    assert_equal 2, calc(lines, 1)
+    assert_equal 2, calc(lines, 2)
+    assert_equal 0, calc(lines, 3)
+  end
+
+  def test_empty_lines_preserve_depth
+    lines = [
+      "def foo",
+      "",
+      "  bar",
+      "end"
+    ]
+    assert_equal 2, calc(lines, 1)  # empty line inside def
+    assert_equal 2, calc(lines, 2)  # bar
+    assert_equal 0, calc(lines, 3)  # end
+  end
+end

data/test/input_screen_integration_test.rb

@@ -56,7 +56,7 @@ class InputScreenIntegrationTest < Minitest::Test
     app.instance_variable_set(:@screen, screen)
 
     stdin = FakeTTY.new("\e[6~")
-    input = RuVim::Input.new(stdin: stdin)
+    input = RuVim::Input.new(stdin)
 
     with_fake_select do
       key = input.read_key(timeout: 0.2)
@@ -72,11 +72,49 @@ class InputScreenIntegrationTest < Minitest::Test
 
   def test_input_keeps_repeated_arrow_sequences_separate
     stdin = FakeTTY.new("\e[A\e[A")
-    input = RuVim::Input.new(stdin: stdin)
+    input = RuVim::Input.new(stdin)
 
     with_fake_select do
       assert_equal :up, input.read_key(timeout: 0.2)
       assert_equal :up, input.read_key(timeout: 0.2)
     end
   end
+
+  def test_input_reads_ctrl_z
+    stdin = FakeTTY.new("\u001a")
+    input = RuVim::Input.new(stdin)
+
+    with_fake_select do
+      assert_equal :ctrl_z, input.read_key(timeout: 0.2)
+    end
+  end
+
+  def test_input_shift_arrow_sequences
+    {
+      "\e[1;2A" => :shift_up,
+      "\e[1;2B" => :shift_down,
+      "\e[1;2C" => :shift_right,
+      "\e[1;2D" => :shift_left
+    }.each do |seq, expected|
+      stdin = FakeTTY.new(seq)
+      input = RuVim::Input.new(stdin)
+
+      with_fake_select do
+        assert_equal expected, input.read_key(timeout: 0.2), "Expected #{expected} for sequence #{seq.inspect}"
+      end
+    end
+  end
+
+  def test_has_pending_input_returns_true_when_data_available
+    stdin = FakeTTY.new("abc")
+    input = RuVim::Input.new(stdin)
+
+    with_fake_select do
+      assert input.has_pending_input?
+      input.read_key(timeout: 0)
+      input.read_key(timeout: 0)
+      input.read_key(timeout: 0)
+      refute input.has_pending_input?
+    end
+  end
 end