ruvim 0.4.0 → 0.6.0

data/test/run_command_test.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class RunCommandTest < Minitest::Test
+  TerminalStub = Struct.new(:winsize) do
+    def write(_data) = nil
+  end
+
+  def setup
+    @app = RuVim::App.new(clean: true)
+    @editor = @app.instance_variable_get(:@editor)
+    @key_handler = @app.instance_variable_get(:@key_handler)
+    @editor.materialize_intro_buffer!
+  end
+
+  def feed(*keys)
+    keys.each { |k| @key_handler.handle(k) }
+  end
+
+  def buf
+    @editor.current_buffer
+  end
+
+  def win
+    @editor.current_window
+  end
+
+  # --- runprg option ---
+
+  def test_runprg_option_exists
+    assert_nil @editor.get_option("runprg")
+  end
+
+  def test_runprg_set_via_ex
+    feed(*":set runprg=ruby\\ -w\\ %".chars, :enter)
+    assert_equal "ruby -w %", @editor.get_option("runprg")
+  end
+
+  # --- % expansion ---
+
+  def test_expand_run_command_replaces_percent_with_filename
+    buf.instance_variable_set(:@path, "/tmp/test.rb")
+    gc = RuVim::GlobalCommands.instance
+    result = gc.send(:expand_run_command, "ruby -w %", buf)
+    assert_equal "ruby -w /tmp/test.rb", result
+  end
+
+  def test_expand_run_command_without_percent
+    gc = RuVim::GlobalCommands.instance
+    result = gc.send(:expand_run_command, "echo hello", buf)
+    assert_equal "echo hello", result
+  end
+
+  def test_expand_run_command_percent_with_no_path_raises
+    gc = RuVim::GlobalCommands.instance
+    assert_raises(RuVim::CommandError) do
+      gc.send(:expand_run_command, "ruby %", buf)
+    end
+  end
+
+  # --- :run with args ---
+
+  def test_run_with_args_creates_shell_output_buffer
+    feed(*":run echo hello".chars, :enter)
+    output_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+    assert output_buf, "Expected [Shell Output] buffer to be created"
+    assert output_buf.readonly?
+  end
+
+  def test_run_opens_in_horizontal_split
+    feed(*":run echo hello".chars, :enter)
+    # Should have 2 windows after split
+    leaves = @editor.send(:tree_leaves, @editor.layout_tree)
+    assert_equal 2, leaves.length, "Expected 2 windows (source + output)"
+    # Current window should show the output buffer
+    output_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+    assert_equal output_buf.id, @editor.current_window.buffer_id
+  end
+
+  def test_run_reuses_existing_output_window
+    feed(*":run echo first".chars, :enter)
+    leaves_after_first = @editor.send(:tree_leaves, @editor.layout_tree)
+
+    # Focus source window and run again
+    feed(*":wincmd w".chars, :enter)
+    feed(*":run echo second".chars, :enter)
+
+    leaves_after_second = @editor.send(:tree_leaves, @editor.layout_tree)
+    assert_equal leaves_after_first.length, leaves_after_second.length, "Should not create additional splits"
+  end
+
+  def test_run_reuses_shell_output_buffer
+    feed(*":run echo first".chars, :enter)
+    first_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+    first_id = first_buf.id
+
+    # Switch to source window and run again
+    feed(*":wincmd w".chars, :enter)
+    feed(*":run echo second".chars, :enter)
+    second_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+
+    assert_equal first_id, second_buf.id, "Should reuse the same [Shell Output] buffer"
+  end
+
+  # --- :run without args uses runprg ---
+
+  def test_run_no_args_uses_runprg
+    buf.instance_variable_set(:@path, "/tmp/test.rb")
+    buf.options["runprg"] = "echo %"
+    feed(*":run".chars, :enter)
+    output_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+    assert output_buf, "Expected [Shell Output] buffer to be created"
+  end
+
+  def test_run_no_args_no_runprg_no_history_shows_error
+    feed(*":run".chars, :enter)
+    assert_match(/runprg/, @editor.message.to_s)
+  end
+
+  # --- per-buffer run history ---
+
+  def test_run_remembers_last_command_per_buffer
+    buf.instance_variable_set(:@path, "/tmp/test.rb")
+    feed(*":run echo test1".chars, :enter)
+
+    # Switch back and run again without args
+    feed(*":bprev".chars, :enter)
+    feed(*":run".chars, :enter)
+
+    output_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+    assert output_buf
+  end
+
+  # --- filetype default runprg ---
+
+  def test_ruby_filetype_sets_default_runprg
+    buf.instance_variable_set(:@path, "/tmp/test.rb")
+    @editor.send(:assign_filetype, buf, "ruby")
+    assert_equal "ruby -w %", buf.options["runprg"]
+  end
+
+  def test_python_filetype_sets_default_runprg
+    buf.instance_variable_set(:@path, "/tmp/test.py")
+    @editor.send(:assign_filetype, buf, "python")
+    assert_equal "python3 %", buf.options["runprg"]
+  end
+
+  # --- Ctrl-C stops run stream ---
+
+  def test_ctrl_c_on_run_output_buffer_stops_stream
+    feed(*":run echo hello".chars, :enter)
+    output_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+    assert output_buf
+    assert output_buf.stream.stop_handler, "Expected stream to have a stop_handler"
+
+    @editor.stream_stop_or_cancel!
+    assert_includes @editor.message.to_s, "stopped"
+  end
+
+  # --- auto-save before :run ---
+
+  def test_run_auto_saves_modified_buffer
+    Tempfile.create(["ruvim-run-save", ".rb"]) do |f|
+      f.write("original\n")
+      f.flush
+
+      app = RuVim::App.new(path: f.path, clean: true)
+      editor = app.instance_variable_get(:@editor)
+      kh = app.instance_variable_get(:@key_handler)
+      buf = editor.current_buffer
+
+      # Simulate editing
+      buf.lines[0] = "modified"
+      buf.modified = true
+
+      ":run echo ok".chars.each { |k| kh.handle(k) }
+      kh.handle(:enter)
+
+      # File should be saved
+      assert_equal "modified", File.read(f.path)
+      assert_equal false, buf.modified?
+    end
+  end
+
+  def test_run_does_not_save_unmodified_buffer
+    Tempfile.create(["ruvim-run-nosave", ".rb"]) do |f|
+      f.write("original\n")
+      f.flush
+      mtime_before = File.mtime(f.path)
+
+      app = RuVim::App.new(path: f.path, clean: true)
+      kh = app.instance_variable_get(:@key_handler)
+
+      sleep 0.01 # ensure mtime would differ if written
+      ":run echo ok".chars.each { |k| kh.handle(k) }
+      kh.handle(:enter)
+
+      assert_equal mtime_before, File.mtime(f.path)
+    end
+  end
+
+  # --- streaming output arrives incrementally ---
+
+  def test_run_streams_output_incrementally
+    sh = @app.instance_variable_get(:@stream_mixer)
+    # Run a command that prints lines with small delays
+    cmd = "ruby -e 'STDOUT.sync=true; 3.times{puts _1; sleep 0.1}'"
+    feed(*":run #{cmd}".chars, :enter)
+    output_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+    assert output_buf, "Expected [Shell Output] buffer"
+
+    # Wait for at least one line to arrive (but not necessarily all)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
+    loop do
+      sh.drain_events!
+      break if output_buf.lines.any? { |l| l.include?("0") }
+      if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+        flunk "Timed out waiting for streamed output; lines=#{output_buf.lines.inspect}"
+      end
+      sleep 0.05
+    end
+
+    # Should have received at least the first line while command is still running
+    assert_includes output_buf.lines, "0"
+  ensure
+    output_buf&.stream&.stop!
+  end
+
+  # --- status line shows run command ---
+
+  def test_ctrl_c_key_stops_running_stream
+    sh = @app.instance_variable_get(:@stream_mixer)
+    feed(*":run sleep 10".chars, :enter)
+    output_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+    assert output_buf, "Expected [Shell Output] buffer"
+    assert_equal :live, output_buf.stream.state, "Buffer should be streaming"
+    assert output_buf.stream.stop_handler, "Buffer should have stop handler"
+
+    # Simulate Ctrl-C key press
+    feed(:ctrl_c)
+    sh.drain_events!
+
+    assert_equal :closed, output_buf.stream.state, "Stream should be stopped after Ctrl-C"
+  ensure
+    output_buf&.stream&.stop! rescue nil
+  end
+
+  # --- stream_status shows correct label ---
+
+  def test_run_output_stream_status_live
+    feed(*":run sleep 10".chars, :enter)
+    output_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+    assert_equal "run", output_buf.stream_status
+  ensure
+    output_buf&.stream&.stop! rescue nil
+  end
+
+  def test_run_output_stream_status_exit
+    feed(*":run echo done".chars, :enter)
+    output_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+    sh = @app.instance_variable_get(:@stream_mixer)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
+    loop do
+      sh.drain_events!
+      break if output_buf.stream.state == :closed
+      flunk "Timed out" if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+      sleep 0.02
+    end
+    assert_match(/\Arun\/exit 0\z/, output_buf.stream_status)
+  end
+
+  def test_stdin_stream_status_live
+    r, w = IO.pipe
+    buf = @editor.current_buffer
+    buf.stream = RuVim::Stream::Stdin.new(io: r, buffer_id: buf.id, queue: Queue.new) {}
+    assert_equal "stdin", buf.stream_status
+  ensure
+    buf&.stream&.stop!
+    w&.close rescue nil
+  end
+
+  def test_stdin_stream_status_closed
+    r, w = IO.pipe
+    buf = @editor.current_buffer
+    buf.stream = RuVim::Stream::Stdin.new(io: r, buffer_id: buf.id, queue: Queue.new) {}
+    buf.stream.stop!
+    assert_equal "stdin/EOF", buf.stream_status
+  ensure
+    w&.close rescue nil
+  end
+
+  def test_run_stores_command_on_output_buffer
+    feed(*":run echo hello".chars, :enter)
+    output_buf = @editor.buffers.values.find { |b| b.name == "[Shell Output]" }
+    assert_equal "echo hello", output_buf.stream_command
+  end
+
+  def test_status_line_includes_run_command
+    feed(*":run echo hello".chars, :enter)
+    term = TerminalStub.new([6, 80])
+    screen = RuVim::Screen.new(terminal: term)
+    line = screen.send(:status_line, @editor, 80)
+    assert_includes line, "echo hello"
+    assert_includes line, "[run]"
+  end
+end

data/test/screen_test.rb

@@ -104,14 +104,18 @@ class ScreenTest < Minitest::Test
   def test_status_line_shows_stream_state_for_stdin_buffer
     editor = RuVim::Editor.new
     buf = editor.add_virtual_buffer(kind: :stream, name: "[stdin]", lines: [""], readonly: true, modifiable: false)
-    buf.stream_state = :closed
+    r, w = IO.pipe
+    buf.stream = RuVim::Stream::Stdin.new(io: r, buffer_id: buf.id, queue: Queue.new) {}
+    buf.stream.stop!
     editor.add_window(buffer_id: buf.id)
 
     term = TerminalStub.new([6, 60])
     screen = RuVim::Screen.new(terminal: term)
     line = screen.send(:status_line, editor, 60)
 
-    assert_includes line, "[stdin/closed]"
+    assert_includes line, "[stdin/EOF]"
+  ensure
+    w&.close rescue nil
   end
 
   def test_render_uses_dim_and_brighter_line_number_gutter_colors
@@ -380,7 +384,7 @@ class ScreenTest < Minitest::Test
     # Create rows where raw lines differ in length but formatted lines are aligned
     buf.replace_all_lines!(["Short\tSecond\tThird", "LongerField\tB\tC"])
     buf.options["filetype"] = "tsv"
-    RuVim::RichView.open!(editor, format: "tsv")
+    RuVim::RichView.open!(editor, format: :tsv)
 
     # Move cursor to end of line (like pressing $)
     win.cursor_y = 0
@@ -420,7 +424,7 @@ class ScreenTest < Minitest::Test
       "緑\tキウイフルーツジャム\t静岡"
     ])
     buf.options["filetype"] = "tsv"
-    RuVim::RichView.open!(editor, format: "tsv")
+    RuVim::RichView.open!(editor, format: :tsv)
 
     # Move to end of line to trigger horizontal scroll
     win.cursor_y = 2
@@ -503,7 +507,7 @@ class ScreenTest < Minitest::Test
     win = editor.add_window(buffer_id: buf.id)
     buf.replace_all_lines!(["A\tB\tC", "DD\tEE\tFF"])
     buf.options["filetype"] = "tsv"
-    RuVim::RichView.open!(editor, format: "tsv")
+    RuVim::RichView.open!(editor, format: :tsv)
 
     # Move cursor to end of raw line
     win.cursor_y = 0
@@ -590,4 +594,63 @@ class ScreenTest < Minitest::Test
     # win2 + win3 heights + separator should equal text_rows
     assert_equal text_rows, rects[win2.id][:height] + rects[win3.id][:height] + 1
   end
+
+  def test_cursor_hidden_in_normal_mode
+    editor = RuVim::Editor.new
+    buf = editor.add_empty_buffer
+    editor.add_window(buffer_id: buf.id)
+    editor.enter_normal_mode
+
+    term = TerminalStub.new([8, 20])
+    screen = RuVim::Screen.new(terminal: term)
+    screen.render(editor)
+
+    output = term.writes.join
+    # Normal mode hides terminal cursor (cell rendering handles visibility)
+    refute_includes output, "\e[?25h", "Normal mode should hide terminal cursor"
+  end
+
+  def test_cursor_bar_in_insert_mode
+    editor = RuVim::Editor.new
+    buf = editor.add_empty_buffer
+    editor.add_window(buffer_id: buf.id)
+    editor.enter_insert_mode
+
+    term = TerminalStub.new([8, 20])
+    screen = RuVim::Screen.new(terminal: term)
+    screen.render(editor)
+
+    output = term.writes.join
+    assert_includes output, "\e[6 q", "Insert mode should set steady bar cursor"
+    assert_includes output, "\e[?25h", "Insert mode should show terminal cursor"
+  end
+
+  def test_cursor_hidden_in_visual_mode
+    editor = RuVim::Editor.new
+    buf = editor.add_empty_buffer
+    editor.add_window(buffer_id: buf.id)
+    editor.enter_visual(:visual_char)
+
+    term = TerminalStub.new([8, 20])
+    screen = RuVim::Screen.new(terminal: term)
+    screen.render(editor)
+
+    output = term.writes.join
+    refute_includes output, "\e[?25h", "Visual mode should hide terminal cursor"
+  end
+
+  def test_cursor_bar_in_command_line_mode
+    editor = RuVim::Editor.new
+    buf = editor.add_empty_buffer
+    editor.add_window(buffer_id: buf.id)
+    editor.enter_command_line_mode
+
+    term = TerminalStub.new([8, 20])
+    screen = RuVim::Screen.new(terminal: term)
+    screen.render(editor)
+
+    output = term.writes.join
+    assert_includes output, "\e[6 q", "Command-line mode should set steady bar cursor"
+    assert_includes output, "\e[?25h", "Command-line mode should show terminal cursor"
+  end
 end

data/test/stream_test.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class StreamTest < Minitest::Test
+  def make_queue
+    Queue.new
+  end
+
+  def noop
+    -> {}
+  end
+
+  # --- Stream::Stdin ---
+
+  def test_stdin_starts_live
+    r, w = IO.pipe
+    s = RuVim::Stream::Stdin.new(io: r, buffer_id: 1, queue: make_queue, &noop)
+    assert_equal :live, s.state
+    assert_equal "stdin", s.status
+  ensure
+    s&.stop!
+    w&.close rescue nil
+  end
+
+  def test_stdin_status_closed
+    r, w = IO.pipe
+    s = RuVim::Stream::Stdin.new(io: r, buffer_id: 1, queue: make_queue, &noop)
+    s.stop!
+    assert_equal :closed, s.state
+    assert_equal "stdin/EOF", s.status
+  ensure
+    w&.close rescue nil
+  end
+
+  def test_stdin_command_is_nil
+    r, w = IO.pipe
+    s = RuVim::Stream::Stdin.new(io: r, buffer_id: 1, queue: make_queue, &noop)
+    assert_nil s.command
+  ensure
+    s&.stop!
+    w&.close rescue nil
+  end
+
+  # --- Stream::Run ---
+
+  def test_run_starts_live
+    q = make_queue
+    s = RuVim::Stream::Run.new(command: "echo hello", buffer_id: 1, queue: q, &noop)
+    assert_equal :live, s.state
+    assert_equal "run", s.status
+    assert_equal "echo hello", s.command
+  ensure
+    s&.stop!
+  end
+
+  def test_run_status_closed_with_exit
+    q = make_queue
+    s = RuVim::Stream::Run.new(command: "echo hello", buffer_id: 1, queue: q, &noop)
+    s.stop!
+    s.exit_status = Struct.new(:exitstatus).new(0)
+    assert_equal "run/exit 0", s.status
+  end
+
+  def test_run_status_error
+    q = make_queue
+    s = RuVim::Stream::Run.new(command: "echo hello", buffer_id: 1, queue: q, &noop)
+    s.state = :error
+    assert_equal "run/error", s.status
+  ensure
+    s&.stop!
+  end
+
+  # --- Stream::Follow ---
+
+  def test_follow_starts_live
+    Tempfile.create(["stream_test", ".txt"]) do |f|
+      f.write("test\n"); f.flush
+      s = RuVim::Stream::Follow.new(path: f.path, buffer_id: 1, queue: make_queue, &noop)
+      assert_equal :live, s.state
+      assert_match(/\Afollow/, s.status)
+      assert_nil s.command
+    ensure
+      s&.stop!
+    end
+  end
+
+  def test_follow_stop_clears_state
+    Tempfile.create(["stream_test", ".txt"]) do |f|
+      f.write("test\n"); f.flush
+      s = RuVim::Stream::Follow.new(path: f.path, buffer_id: 1, queue: make_queue, &noop)
+      s.stop!
+      assert_nil s.state
+      assert_nil s.status
+    end
+  end
+
+  # --- Stream::FileLoad ---
+
+  def test_file_load_starts_live
+    Tempfile.create(["stream_test", ".txt"]) do |f|
+      f.write("data\n"); f.flush
+      io = File.open(f.path, "rb")
+      s = RuVim::Stream::FileLoad.new(io: io, file_size: f.size, buffer_id: 1, queue: make_queue, &noop)
+      assert_equal :live, s.state
+      assert_equal "load", s.status
+    ensure
+      s&.stop!
+    end
+  end
+
+  def test_file_load_status_error
+    Tempfile.create(["stream_test", ".txt"]) do |f|
+      f.write("data\n"); f.flush
+      io = File.open(f.path, "rb")
+      s = RuVim::Stream::FileLoad.new(io: io, file_size: f.size, buffer_id: 1, queue: make_queue, &noop)
+      s.state = :error
+      assert_equal "load/error", s.status
+    ensure
+      s&.stop!
+    end
+  end
+
+  # --- Stream::Git ---
+
+  def test_git_status_always_nil
+    q = make_queue
+    s = RuVim::Stream::Git.new(cmd: ["echo", "test"], root: ".", buffer_id: 1, queue: q, &noop)
+    assert_nil s.status
+  ensure
+    s&.stop!
+  end
+
+  # --- common ---
+
+  def test_live_predicate
+    q = make_queue
+    s = RuVim::Stream::Run.new(command: "sleep 10", buffer_id: 1, queue: q, &noop)
+    assert s.live?
+    s.stop!
+    refute s.live?
+  end
+
+  def test_buffer_stream_status_delegates
+    q = make_queue
+    app = RuVim::App.new(clean: true)
+    editor = app.instance_variable_get(:@editor)
+    editor.materialize_intro_buffer!
+    buf = editor.current_buffer
+    buf.stream = RuVim::Stream::Run.new(command: "echo test", buffer_id: buf.id, queue: q, &noop)
+    assert_equal "run", buf.stream_status
+    assert_equal "echo test", buf.stream_command
+  ensure
+    buf&.stream&.stop!
+  end
+
+  def test_buffer_stream_status_nil_without_stream
+    app = RuVim::App.new(clean: true)
+    editor = app.instance_variable_get(:@editor)
+    editor.materialize_intro_buffer!
+    buf = editor.current_buffer
+    assert_nil buf.stream_status
+    assert_nil buf.stream_command
+  end
+end

data/test/window_test.rb

@@ -31,6 +31,65 @@ class WindowTest < Minitest::Test
     assert_operator win.col_offset, :>, 0
   end
 
+  def test_move_left
+    buffer = RuVim::Buffer.new(id: 1, lines: ["abcde"])
+    win = RuVim::Window.new(id: 1, buffer_id: 1)
+    win.cursor_x = 3
+
+    win.move_left(buffer)
+    assert_equal 2, win.cursor_x
+
+    win.move_left(buffer, 2)
+    assert_equal 0, win.cursor_x
+
+    # Should not go below 0
+    win.move_left(buffer)
+    assert_equal 0, win.cursor_x
+  end
+
+  def test_move_right
+    buffer = RuVim::Buffer.new(id: 1, lines: ["abcde"])
+    win = RuVim::Window.new(id: 1, buffer_id: 1)
+    win.cursor_x = 0
+
+    win.move_right(buffer)
+    assert_equal 1, win.cursor_x
+
+    win.move_right(buffer, 2)
+    assert_equal 3, win.cursor_x
+
+    # Should not go beyond line length
+    win.move_right(buffer, 10)
+    assert_equal 5, win.cursor_x
+  end
+
+  def test_move_left_with_multibyte
+    buffer = RuVim::Buffer.new(id: 1, lines: ["ab日本c"])
+    win = RuVim::Window.new(id: 1, buffer_id: 1)
+    win.cursor_x = 4 # on "c"
+
+    win.move_left(buffer)
+    assert_equal 3, win.cursor_x # on "本"
+
+    win.move_left(buffer)
+    assert_equal 2, win.cursor_x # on "日"
+  end
+
+  def test_move_up
+    buffer = RuVim::Buffer.new(id: 1, lines: ["abc", "def", "ghi"])
+    win = RuVim::Window.new(id: 1, buffer_id: 1)
+    win.cursor_y = 2
+    win.cursor_x = 1
+
+    win.move_up(buffer)
+    assert_equal 1, win.cursor_y
+    assert_equal 1, win.cursor_x
+
+    # Should not go below 0
+    win.move_up(buffer, 5)
+    assert_equal 0, win.cursor_y
+  end
+
   def test_move_down_preserves_preferred_column_across_empty_line
     long = "x" * 80
     buffer = RuVim::Buffer.new(id: 1, lines: [long, "", long])