ruvim 0.1.0 → 0.3.0

data/test/indent_test.rb

@@ -0,0 +1,201 @@
+require_relative "test_helper"
+
+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

@@ -30,6 +30,21 @@ class InputScreenIntegrationTest < Minitest::Test
     end
   end
 
+  def with_fake_select
+    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
+    yield
+  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
+
   def test_input_pagedown_to_app_and_screen_render
     app = RuVim::App.new(clean: true)
     editor = app.instance_variable_get(:@editor)
@@ -41,17 +56,9 @@ class InputScreenIntegrationTest < Minitest::Test
     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
+    input = RuVim::Input.new(stdin)
 
-    begin
+    with_fake_select do
       key = input.read_key(timeout: 0.2)
       assert_equal :pagedown, key
 
@@ -60,10 +67,54 @@ class InputScreenIntegrationTest < Minitest::Test
 
       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
+
+  def test_input_keeps_repeated_arrow_sequences_separate
+    stdin = FakeTTY.new("\e[A\e[A")
+    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

data/test/markdown_renderer_test.rb

@@ -0,0 +1,279 @@
+require_relative "test_helper"
+
+class MarkdownRendererTest < Minitest::Test
+  def renderer
+    RuVim::RichView::MarkdownRenderer
+  end
+
+  # --- Registration ---
+
+  def test_renderer_registered_for_markdown
+    assert_equal renderer, RuVim::RichView.renderer_for("markdown")
+  end
+
+  def test_delimiter_for_markdown
+    assert_nil renderer.delimiter_for("markdown")
+  end
+
+  # --- Headings ---
+
+  def test_heading_h1_bold
+    lines = ["# Hello"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_equal 1, result.length
+    assert_match(/\e\[1[;m]/, result[0])  # bold (standalone or combined)
+    assert_includes result[0], "# Hello"
+  end
+
+  def test_heading_h2
+    lines = ["## Section"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "## Section"
+    assert_match(/\e\[1[;m]/, result[0])  # bold
+  end
+
+  def test_heading_h3_to_h6
+    (3..6).each do |level|
+      hashes = "#" * level
+      lines = ["#{hashes} Title"]
+      result = renderer.render_visible(lines, delimiter: nil)
+      assert_includes result[0], "#{hashes} Title", "H#{level} text should be preserved"
+      assert_includes result[0], "\e[", "H#{level} should have ANSI styling"
+    end
+  end
+
+  # --- Inline elements ---
+
+  def test_inline_bold
+    lines = ["hello **bold** world"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "\e[1m"   # bold on
+    assert_includes result[0], "\e[22m"  # bold off
+    assert_includes result[0], "**bold**"
+  end
+
+  def test_inline_italic
+    lines = ["hello *italic* world"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "\e[3m"   # italic on
+    assert_includes result[0], "\e[23m"  # italic off
+    assert_includes result[0], "*italic*"
+  end
+
+  def test_inline_code
+    lines = ["use `foo()` here"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "\e[33m"  # yellow
+    assert_includes result[0], "`foo()`"
+  end
+
+  def test_inline_link
+    lines = ["click [here](http://example.com) now"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "\e[4m"   # underline for text
+    assert_includes result[0], "here"
+    assert_includes result[0], "http://example.com"
+  end
+
+  def test_checkbox_unchecked
+    lines = ["- [ ] todo item"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "\e[90m"  # dim
+    assert_includes result[0], "[ ]"
+  end
+
+  def test_checkbox_checked
+    lines = ["- [x] done item"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "\e[32m"  # green
+    assert_includes result[0], "[x]"
+  end
+
+  # --- Code blocks ---
+
+  def test_code_fence_styling
+    lines = ["```ruby", "puts 'hi'", "```"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    # Fence lines should be dim
+    assert_includes result[0], "\e[90m"
+    # Content should be warm-colored
+    assert_includes result[1], "\e[38;5;223m"
+    # Closing fence should be dim
+    assert_includes result[2], "\e[90m"
+  end
+
+  def test_code_fence_tilde
+    lines = ["~~~", "code line", "~~~"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "\e[90m"
+    assert_includes result[1], "\e[38;5;223m"
+  end
+
+  def test_code_block_context_from_pre_context
+    # Simulate rendering in the middle of a code block
+    # pre_context_lines should carry the open fence state
+    pre_context = ["```ruby", "line1"]
+    lines = ["line2", "```"]
+    result = renderer.render_visible(lines, delimiter: nil, context: { pre_context_lines: pre_context })
+    # line2 should be inside code block (warm color)
+    assert_includes result[0], "\e[38;5;223m"
+    # closing fence
+    assert_includes result[1], "\e[90m"
+  end
+
+  def test_needs_pre_context
+    assert renderer.needs_pre_context?
+  end
+
+  # --- HR ---
+
+  def test_hr_dashes
+    lines = ["---"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "\u2500"  # box drawing horizontal
+  end
+
+  def test_hr_asterisks
+    lines = ["***"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "\u2500"
+  end
+
+  def test_hr_underscores
+    lines = ["___"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "\u2500"
+  end
+
+  # --- Block quotes ---
+
+  def test_block_quote
+    lines = ["> quoted text"]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_includes result[0], "\e[36m"  # cyan
+    assert_includes result[0], "> quoted text"
+  end
+
+  # --- Tables ---
+
+  def test_table_basic
+    lines = [
+      "| Name  | Age |",
+      "| ----- | --- |",
+      "| Alice | 30  |"
+    ]
+    result = renderer.render_visible(lines, delimiter: nil)
+    assert_equal 3, result.length
+    # Data rows should use box-drawing vertical bar
+    assert_includes result[0], "\u2502"  # │
+    assert_includes result[2], "\u2502"
+    # Separator row should use box-drawing
+    assert_includes result[1], "\u2500"  # ─
+    assert_includes result[1], "\u253c"  # ┼
+  end
+
+  def test_table_column_alignment
+    lines = [
+      "| Short | Long column |",
+      "| ----- | ----------- |",
+      "| A     | B           |"
+    ]
+    result = renderer.render_visible(lines, delimiter: nil)
+    # Both data rows should have same display width
+    w0 = display_width_without_ansi(result[0])
+    w2 = display_width_without_ansi(result[2])
+    assert_equal w0, w2
+  end
+
+  # --- cursor_display_col ---
+
+  def test_cursor_display_col_non_table_line
+    # For non-table lines, should return screen_col_for_char_index
+    line = "hello world"
+    col = renderer.cursor_display_col(line, 5, visible_lines: [line], delimiter: nil)
+    expected = RuVim::TextMetrics.screen_col_for_char_index(line, 5)
+    assert_equal expected, col
+  end
+
+  def test_cursor_display_col_table_line
+    lines = [
+      "| Name  | Age |",
+      "| ----- | --- |",
+      "| Alice | 30  |"
+    ]
+    # Cursor at start of "Alice" (index within raw line)
+    raw_line = lines[2]
+    col = renderer.cursor_display_col(raw_line, 2, visible_lines: lines, delimiter: nil)
+    # Should be > 0 (after the leading │ and padding)
+    assert col >= 0
+  end
+
+  # --- ANSI support in render_rich_view_line_sc ---
+
+  def test_render_rich_view_line_sc_with_ansi
+    screen = create_test_screen
+    # Line with ANSI bold: "\e[1m" is 4 chars but 0 display width
+    text = "\e[1mhello\e[m world"
+    result = screen.send(:render_rich_view_line_sc, text, width: 20, skip_sc: 0)
+    # Should contain the ANSI sequences and the text
+    assert_includes result, "\e[1m"
+    assert_includes result, "hello"
+    assert_includes result, "world"
+    # Should end with reset
+    assert result.end_with?("\e[m") || result.include?("\e[m")
+  end
+
+  def test_render_rich_view_line_sc_ansi_skip
+    screen = create_test_screen
+    # ANSI at start, skip some display columns
+    text = "\e[1mhello\e[m world"
+    result = screen.send(:render_rich_view_line_sc, text, width: 5, skip_sc: 3)
+    # Should show "lo wo" or similar (skipping 3 display cols of "hello")
+    assert_includes result, "lo"
+  end
+
+  # --- Integration test ---
+
+  def test_markdown_rich_mode_integration
+    editor = fresh_editor
+    buf = editor.current_buffer
+    buf.replace_all_lines!(["# Title", "", "Some **bold** text"])
+    buf.options["filetype"] = "markdown"
+
+    RuVim::RichView.open!(editor, format: "markdown")
+    assert_equal :rich, editor.mode
+    state = editor.rich_state
+    assert_equal "markdown", state[:format]
+
+    # Render visible lines
+    lines = (0...buf.line_count).map { |i| buf.line_at(i) }
+    rendered = RuVim::RichView.render_visible_lines(editor, lines)
+    assert_equal 3, rendered.length
+    # Heading should have styling
+    assert_includes rendered[0], "\e["
+
+    RuVim::RichView.close!(editor)
+    assert_equal :normal, editor.mode
+  end
+
+  def test_detect_format_markdown
+    editor = fresh_editor
+    buf = editor.current_buffer
+    buf.options["filetype"] = "markdown"
+    assert_equal "markdown", RuVim::RichView.detect_format(buf)
+  end
+
+  private
+
+  def display_width_without_ansi(str)
+    # Strip ANSI escape sequences for width calculation
+    clean = str.gsub(/\e\[[0-9;]*m/, "")
+    RuVim::DisplayWidth.display_width(clean)
+  end
+
+  def create_test_screen
+    terminal = Object.new
+    def terminal.winsize; [24, 80]; end
+    RuVim::Screen.new(terminal: terminal)
+  end
+end