ruvim 0.2.0 → 0.4.0

data/test/app_startup_test.rb

@@ -1,6 +1,7 @@
 require_relative "test_helper"
 require "tempfile"
 require "stringio"
+require "tmpdir"
 
 class AppStartupTest < Minitest::Test
   def test_startup_ex_command_runs_after_boot
@@ -107,6 +108,34 @@ class AppStartupTest < Minitest::Test
     end
   end
 
+  def test_startup_horizontal_split_focuses_first_file
+    Tempfile.create(["ruvim-a", ".txt"]) do |a|
+      Tempfile.create(["ruvim-b", ".txt"]) do |b|
+        a.write("a\n"); a.flush
+        b.write("b\n"); b.flush
+
+        app = RuVim::App.new(paths: [a.path, b.path], clean: true, startup_open_layout: :horizontal)
+        editor = app.instance_variable_get(:@editor)
+
+        assert_equal a.path, editor.current_buffer.path
+      end
+    end
+  end
+
+  def test_startup_vertical_split_focuses_first_file
+    Tempfile.create(["ruvim-a", ".txt"]) do |a|
+      Tempfile.create(["ruvim-b", ".txt"]) do |b|
+        a.write("a\n"); a.flush
+        b.write("b\n"); b.flush
+
+        app = RuVim::App.new(paths: [a.path, b.path], clean: true, startup_open_layout: :vertical)
+        editor = app.instance_variable_get(:@editor)
+
+        assert_equal a.path, editor.current_buffer.path
+      end
+    end
+  end
+
   def test_startup_tab_layout_opens_multiple_tabs
     Tempfile.create(["ruvim-a", ".txt"]) do |a|
       Tempfile.create(["ruvim-b", ".txt"]) do |b|
@@ -121,6 +150,21 @@ class AppStartupTest < Minitest::Test
     end
   end
 
+  def test_startup_tab_layout_focuses_first_tab
+    Tempfile.create(["ruvim-a", ".txt"]) do |a|
+      Tempfile.create(["ruvim-b", ".txt"]) do |b|
+        a.write("a\n"); a.flush
+        b.write("b\n"); b.flush
+
+        app = RuVim::App.new(paths: [a.path, b.path], clean: true, startup_open_layout: :tab)
+        editor = app.instance_variable_get(:@editor)
+
+        assert_equal 1, editor.current_tabpage_number
+        assert_equal a.path, editor.current_buffer.path
+      end
+    end
+  end
+
   def test_restricted_mode_disables_ex_ruby
     app = RuVim::App.new(clean: true, restricted: true)
     editor = app.instance_variable_get(:@editor)
@@ -206,4 +250,147 @@ class AppStartupTest < Minitest::Test
       assert_match(/startup_actions\.done/, text)
     end
   end
+
+  def test_stdin_stream_mode_uses_stream_buffer_and_appends_input
+    app = RuVim::App.new(
+      clean: true,
+      stdin: StringIO.new("line1\nline2\n"),
+      ui_stdin: StringIO.new,
+      stdin_stream_mode: true
+    )
+    editor = app.instance_variable_get(:@editor)
+
+    20.times do
+      app.send(:drain_stream_events!)
+      thread = app.instance_variable_get(:@stream_reader_thread)
+      break unless thread&.alive?
+      sleep 0.005
+    end
+
+    buf = editor.current_buffer
+    assert_equal :stream, buf.kind
+    assert_equal "[stdin]", buf.display_name
+    assert_equal true, buf.readonly?
+    assert_equal false, buf.modifiable?
+    assert_includes [:live, :closed], buf.stream_state
+    assert_equal ["line1", "line2", ""], buf.lines
+    assert_match(/\[stdin\] (follow|EOF)/, editor.message)
+  ensure
+    app&.send(:shutdown_stream_reader!)
+  end
+
+  def test_large_file_threshold_uses_async_loader
+    prev = ENV["RUVIM_ASYNC_FILE_THRESHOLD_BYTES"]
+    app = nil
+    Tempfile.create(["ruvim-large-async", ".txt"]) do |f|
+      begin
+        f.write("a\nb\nc\n")
+        f.flush
+
+        ENV["RUVIM_ASYNC_FILE_THRESHOLD_BYTES"] = "1"
+        app = RuVim::App.new(clean: true)
+        editor = app.instance_variable_get(:@editor)
+
+        buf = editor.open_path(f.path)
+        assert_match(/loading/i, editor.message)
+        assert_includes [:live, :closed], buf.loading_state
+        assert_equal false, buf.modifiable?
+
+        100.times do
+          app.send(:drain_stream_events!)
+          break if buf.loading_state != :live
+          state = app.instance_variable_get(:@async_file_loads)[buf.id]
+          break unless state && state[:thread]&.alive?
+          sleep 0.005
+        end
+        app.send(:drain_stream_events!)
+
+        assert_equal :closed, buf.loading_state
+        assert_equal true, buf.modifiable?
+        assert_equal %w[a b c], buf.lines
+        assert_match(/#{Regexp.escape(f.path)}/, editor.message)
+      ensure
+        ENV["RUVIM_ASYNC_FILE_THRESHOLD_BYTES"] = prev
+        app&.send(:shutdown_background_readers!)
+      end
+    end
+  end
+
+  def test_very_large_file_shows_prefix_then_appends_rest
+    prev_async = ENV["RUVIM_ASYNC_FILE_THRESHOLD_BYTES"]
+    prev_prefix = ENV["RUVIM_ASYNC_FILE_PREFIX_BYTES"]
+    app = nil
+    Tempfile.create(["ruvim-large-prefix", ".txt"]) do |f|
+      begin
+        f.write("ab\ncd\nef\n")
+        f.flush
+
+        ENV["RUVIM_ASYNC_FILE_THRESHOLD_BYTES"] = "1"
+        ENV["RUVIM_ASYNC_FILE_PREFIX_BYTES"] = "4"
+        app = RuVim::App.new(clean: true)
+        editor = app.instance_variable_get(:@editor)
+
+        buf = editor.open_path(f.path)
+        assert_equal :live, buf.loading_state
+        assert_equal ["ab", "c"], buf.lines
+        assert_match(/showing first/i, editor.message)
+
+        100.times do
+          app.send(:drain_stream_events!)
+          break if buf.loading_state != :live
+          sleep 0.005
+        end
+        app.send(:drain_stream_events!)
+
+        assert_equal :closed, buf.loading_state
+        assert_equal %w[ab cd ef], buf.lines
+      ensure
+        ENV["RUVIM_ASYNC_FILE_THRESHOLD_BYTES"] = prev_async
+        ENV["RUVIM_ASYNC_FILE_PREFIX_BYTES"] = prev_prefix
+        app&.send(:shutdown_background_readers!)
+      end
+    end
+  end
+
+  def test_command_line_history_persists_in_xdg_state_home
+    Dir.mktmpdir("ruvim-history-xdg") do |dir|
+      prev_xdg = ENV["XDG_STATE_HOME"]
+      prev_home = ENV["HOME"]
+      ENV["XDG_STATE_HOME"] = dir
+      ENV["HOME"] = dir
+
+      app1 = RuVim::App.new(clean: true)
+      app1.send(:push_command_line_history, ":", "set number")
+      app1.send(:push_command_line_history, "/", "foo")
+      app1.send(:push_command_line_history, "?", "bar")
+      app1.send(:save_command_line_history!)
+
+      path = File.join(dir, "ruvim", "history.json")
+      assert_equal true, File.file?(path)
+
+      app2 = RuVim::App.new(clean: true)
+      hist = app2.instance_variable_get(:@cmdline_history)
+      assert_equal ["set number"], hist[":"]
+      assert_equal ["foo"], hist["/"]
+      assert_equal ["bar"], hist["?"]
+    ensure
+      ENV["XDG_STATE_HOME"] = prev_xdg
+      ENV["HOME"] = prev_home
+    end
+  end
+
+  def test_command_line_history_path_falls_back_to_home_dot_ruvim
+    Dir.mktmpdir("ruvim-history-home") do |dir|
+      prev_xdg = ENV["XDG_STATE_HOME"]
+      prev_home = ENV["HOME"]
+      ENV.delete("XDG_STATE_HOME")
+      ENV["HOME"] = dir
+
+      app = RuVim::App.new(clean: true)
+      assert_equal File.join(dir, ".ruvim", "history.json"), app.send(:command_line_history_file_path)
+    ensure
+      ENV["XDG_STATE_HOME"] = prev_xdg
+      ENV["HOME"] = prev_home
+    end
+  end
 end

data/test/arglist_test.rb

@@ -0,0 +1,113 @@
+require "test_helper"
+
+class ArglistTest < Minitest::Test
+  def setup
+    @editor = RuVim::Editor.new
+  end
+
+  def test_initial_arglist_is_empty
+    assert_empty @editor.arglist
+    assert_equal 0, @editor.arglist_index
+  end
+
+  def test_set_arglist
+    paths = %w[file1.txt file2.txt file3.txt]
+    @editor.set_arglist(paths)
+    
+    assert_equal paths, @editor.arglist
+    assert_equal 0, @editor.arglist_index
+    assert_equal "file1.txt", @editor.arglist_current
+  end
+
+  def test_arglist_next
+    @editor.set_arglist(%w[file1.txt file2.txt file3.txt])
+    
+    assert_equal "file2.txt", @editor.arglist_next
+    assert_equal 1, @editor.arglist_index
+    
+    assert_equal "file3.txt", @editor.arglist_next
+    assert_equal 2, @editor.arglist_index
+    
+    error = assert_raises(RuVim::CommandError) do
+      @editor.arglist_next
+    end
+    assert_equal "Already at last argument", error.message
+  end
+
+  def test_arglist_prev
+    @editor.set_arglist(%w[file1.txt file2.txt file3.txt])
+    @editor.arglist_next(2) # Move to index 2
+    
+    assert_equal "file2.txt", @editor.arglist_prev
+    assert_equal 1, @editor.arglist_index
+    
+    assert_equal "file1.txt", @editor.arglist_prev
+    assert_equal 0, @editor.arglist_index
+    
+    error = assert_raises(RuVim::CommandError) do
+      @editor.arglist_prev
+    end
+    assert_equal "Already at first argument", error.message
+  end
+
+  def test_arglist_first
+    @editor.set_arglist(%w[file1.txt file2.txt file3.txt])
+    @editor.arglist_next(2) # Move to index 2
+    
+    assert_equal "file1.txt", @editor.arglist_first
+    assert_equal 0, @editor.arglist_index
+  end
+
+  def test_arglist_last
+    @editor.set_arglist(%w[file1.txt file2.txt file3.txt])
+    
+    assert_equal "file3.txt", @editor.arglist_last
+    assert_equal 2, @editor.arglist_index
+  end
+
+  def test_arglist_next_with_count
+    @editor.set_arglist(%w[file1.txt file2.txt file3.txt file4.txt])
+    
+    assert_equal "file3.txt", @editor.arglist_next(2)
+    assert_equal 2, @editor.arglist_index
+  end
+
+  def test_arglist_prev_with_count
+    @editor.set_arglist(%w[file1.txt file2.txt file3.txt file4.txt])
+    @editor.arglist_last
+    
+    assert_equal "file2.txt", @editor.arglist_prev(2)
+    assert_equal 1, @editor.arglist_index
+  end
+
+  def test_arglist_empty_operations
+    assert_nil @editor.arglist_current
+    assert_nil @editor.arglist_first
+    assert_nil @editor.arglist_last
+  end
+
+  def test_startup_multiple_files_creates_buffers
+    # Simulate what open_startup_paths! does without layout option:
+    # all files should be loaded as buffers so they appear in :ls
+    paths = [File.expand_path("../../t.md", __FILE__),
+             File.expand_path("../../t.rb", __FILE__)]
+    existing = paths.select { |p| File.exist?(p) }
+    skip "need t.md and t.rb in project root" if existing.length < 2
+
+    @editor.ensure_bootstrap_buffer!
+    @editor.set_arglist(paths)
+
+    # Open first file (displayed in current window)
+    first_buf = @editor.add_buffer_from_file(paths[0])
+    @editor.switch_to_buffer(first_buf.id)
+
+    # Load remaining files as buffers (not displayed, but registered)
+    paths[1..].each { |p| @editor.add_buffer_from_file(p) }
+
+    # All files should be in the buffer list
+    all_paths = @editor.buffer_ids.map { |id| @editor.buffers[id].path }
+    paths.each do |p|
+      assert_includes all_paths, p, "#{p} should appear in buffer list"
+    end
+  end
+end

data/test/buffer_test.rb

@@ -1,4 +1,5 @@
 require_relative "test_helper"
+require "tmpdir"
 
 class BufferTest < Minitest::Test
   def test_insert_and_undo_redo_group
@@ -25,48 +26,66 @@ class BufferTest < Minitest::Test
   end
 
   def test_reload_from_file_clears_modified_and_history
-    path = "/tmp/ruvim_buffer_reload_test.txt"
-    File.write(path, "one\n")
-    b = RuVim::Buffer.from_file(id: 1, path: path)
-    b.insert_char(0, 0, "X")
-    assert b.modified?
-    assert b.can_undo?
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "ruvim_buffer_reload_test.txt")
+      File.write(path, "one\n")
+      b = RuVim::Buffer.from_file(id: 1, path: path)
+      b.insert_char(0, 0, "X")
+      assert b.modified?
+      assert b.can_undo?
 
-    b.reload_from_file!
-    assert_equal ["one"], b.lines
-    refute b.modified?
-    refute b.can_undo?
+      b.reload_from_file!
+      assert_equal ["one"], b.lines
+      refute b.modified?
+      refute b.can_undo?
+    end
   end
 
   def test_utf8_file_is_loaded_as_utf8_text_not_binary_bytes
-    path = "/tmp/ruvim_utf8_test.txt"
-    File.binwrite(path, "bar 日本語 編集\n".encode("UTF-8"))
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "ruvim_utf8_test.txt")
+      File.binwrite(path, "bar 日本語 編集\n".encode("UTF-8"))
 
-    b = RuVim::Buffer.from_file(id: 1, path: path)
-    assert_equal Encoding::UTF_8, b.line_at(0).encoding
-    assert_equal "bar 日本語 編集", b.line_at(0)
-    assert_equal 10, b.line_length(0)
+      b = RuVim::Buffer.from_file(id: 1, path: path)
+      assert_equal Encoding::UTF_8, b.line_at(0).encoding
+      assert_equal "bar 日本語 編集", b.line_at(0)
+      assert_equal 10, b.line_length(0)
+    end
   end
 
   def test_invalid_bytes_are_decoded_to_valid_utf8_with_replacement
-    path = "/tmp/ruvim_invalid_bytes_test.txt"
-    File.binwrite(path, "A\xFFB\n".b)
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "ruvim_invalid_bytes_test.txt")
+      File.binwrite(path, "A\xFFB\n".b)
 
-    b = RuVim::Buffer.from_file(id: 1, path: path)
-    line = b.line_at(0)
-    assert_equal Encoding::UTF_8, line.encoding
-    assert_equal true, line.valid_encoding?
-    assert_match(/A.*B/, line)
+      b = RuVim::Buffer.from_file(id: 1, path: path)
+      line = b.line_at(0)
+      assert_equal Encoding::UTF_8, line.encoding
+      assert_equal true, line.valid_encoding?
+      assert_match(/A.*B/, line)
+    end
   end
 
   def test_write_to_saves_utf8_text
-    path = "/tmp/ruvim_write_utf8_test.txt"
-    b = RuVim::Buffer.new(id: 1, lines: ["日本語", "abc"])
-    b.write_to(path)
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "ruvim_write_utf8_test.txt")
+      b = RuVim::Buffer.new(id: 1, lines: ["日本語", "abc"])
+      b.write_to(path)
+
+      data = File.binread(path)
+      text = data.force_encoding(Encoding::UTF_8)
+      assert_equal true, text.valid_encoding?
+      assert_equal "日本語\nabc", text
+    end
+  end
 
-    data = File.binread(path)
-    text = data.force_encoding(Encoding::UTF_8)
-    assert_equal true, text.valid_encoding?
-    assert_equal "日本語\nabc", text
+  def test_append_stream_text_updates_lines_without_marking_modified
+    b = RuVim::Buffer.new(id: 1, lines: [""])
+    b.append_stream_text!("a\n")
+    b.append_stream_text!("b")
+    b.append_stream_text!("\n\nc\n")
+
+    assert_equal ["a", "b", "", "c", ""], b.lines
+    refute b.modified?
   end
 end

data/test/cli_test.rb

@@ -153,6 +153,20 @@ class CLITest < Minitest::Test
     assert_equal "", err.string
   end
 
+  def test_parse_follow_option
+    opts = RuVim::CLI.parse(["-f", "log.txt"])
+
+    assert_equal ["log.txt"], opts.files
+    assert_equal true, opts.follow
+  end
+
+  def test_help_mentions_follow_option
+    out = StringIO.new
+    err = StringIO.new
+    RuVim::CLI.run(["--help"], stdout: out, stderr: err, stdin: StringIO.new)
+    assert_match(/-f\s+Open file in follow mode/, out.string)
+  end
+
   def test_run_returns_error_for_missing_config_file
     out = StringIO.new
     err = StringIO.new

data/test/clipboard_test.rb

@@ -0,0 +1,67 @@
+require_relative "test_helper"
+
+class ClipboardTest < Minitest::Test
+  def setup
+    RuVim::Clipboard.reset_backend!
+  end
+
+  def teardown
+    RuVim::Clipboard.reset_backend!
+  end
+
+  def test_available_returns_true_when_backend_exists
+    RuVim::Clipboard.instance_variable_set(:@backend, { write: %w[echo], read: %w[echo] })
+    assert RuVim::Clipboard.available?
+  end
+
+  def test_available_returns_false_when_no_backend
+    RuVim::Clipboard.instance_variable_set(:@backend, false)
+    refute RuVim::Clipboard.available?
+  end
+
+  def test_read_returns_nil_when_no_read_cmd
+    RuVim::Clipboard.instance_variable_set(:@backend, { write: nil, read: nil })
+    assert_nil RuVim::Clipboard.read
+  end
+
+  def test_read_returns_output_on_success
+    RuVim::Clipboard.instance_variable_set(:@backend, { write: %w[true], read: %w[echo hello] })
+    result = RuVim::Clipboard.read
+    assert_equal "hello\n", result
+  end
+
+  def test_read_returns_nil_on_command_failure
+    RuVim::Clipboard.instance_variable_set(:@backend, { write: %w[true], read: %w[false] })
+    assert_nil RuVim::Clipboard.read
+  end
+
+  def test_write_returns_false_when_no_write_cmd
+    RuVim::Clipboard.instance_variable_set(:@backend, { write: nil, read: nil })
+    refute RuVim::Clipboard.write("test")
+  end
+
+  def test_write_sends_text_to_command
+    RuVim::Clipboard.instance_variable_set(:@backend, { write: %w[cat], read: %w[true] })
+    assert RuVim::Clipboard.write("hello")
+  end
+
+  def test_pbcopy_backend_format
+    expected = { write: %w[pbcopy], read: %w[pbpaste] }
+    assert_equal expected, RuVim::Clipboard.pbcopy_backend
+  end
+
+  def test_wayland_backend_format
+    expected = { write: %w[wl-copy], read: %w[wl-paste -n] }
+    assert_equal expected, RuVim::Clipboard.wayland_backend
+  end
+
+  def test_xclip_backend_format
+    expected = { write: %w[xclip -selection clipboard -in], read: %w[xclip -selection clipboard -out] }
+    assert_equal expected, RuVim::Clipboard.xclip_backend
+  end
+
+  def test_xsel_backend_format
+    expected = { write: %w[xsel --clipboard --input], read: %w[xsel --clipboard --output] }
+    assert_equal expected, RuVim::Clipboard.xsel_backend
+  end
+end

data/test/command_line_test.rb

@@ -0,0 +1,118 @@
+require_relative "test_helper"
+
+class CommandLineTest < Minitest::Test
+  def setup
+    @cl = RuVim::CommandLine.new
+  end
+
+  def test_initial_state
+    assert_equal ":", @cl.prefix
+    assert_equal "", @cl.text
+    assert_equal 0, @cl.cursor
+  end
+
+  def test_reset_with_custom_prefix
+    @cl.reset(prefix: "/")
+    assert_equal "/", @cl.prefix
+    assert_equal "", @cl.text
+    assert_equal 0, @cl.cursor
+  end
+
+  def test_insert_appends_at_cursor
+    @cl.insert("abc")
+    assert_equal "abc", @cl.text
+    assert_equal 3, @cl.cursor
+  end
+
+  def test_insert_at_middle
+    @cl.insert("ac")
+    @cl.instance_variable_set(:@cursor, 1)
+    @cl.insert("b")
+    assert_equal "abc", @cl.text
+    assert_equal 2, @cl.cursor
+  end
+
+  def test_backspace_at_zero_does_nothing
+    @cl.backspace
+    assert_equal "", @cl.text
+    assert_equal 0, @cl.cursor
+  end
+
+  def test_backspace_deletes_character
+    @cl.insert("abc")
+    @cl.backspace
+    assert_equal "ab", @cl.text
+    assert_equal 2, @cl.cursor
+  end
+
+  def test_move_left
+    @cl.insert("abc")
+    @cl.move_left
+    assert_equal 2, @cl.cursor
+  end
+
+  def test_move_left_at_zero_stays
+    @cl.move_left
+    assert_equal 0, @cl.cursor
+  end
+
+  def test_move_right
+    @cl.insert("abc")
+    @cl.instance_variable_set(:@cursor, 1)
+    @cl.move_right
+    assert_equal 2, @cl.cursor
+  end
+
+  def test_move_right_at_end_stays
+    @cl.insert("abc")
+    @cl.move_right
+    assert_equal 3, @cl.cursor
+  end
+
+  def test_content_includes_prefix
+    @cl.insert("hello")
+    assert_equal ":hello", @cl.content
+  end
+
+  def test_content_with_custom_prefix
+    @cl.reset(prefix: "/")
+    @cl.insert("search")
+    assert_equal "/search", @cl.content
+  end
+
+  def test_clear_resets_text_and_cursor
+    @cl.insert("hello")
+    @cl.clear
+    assert_equal "", @cl.text
+    assert_equal 0, @cl.cursor
+    assert_equal ":", @cl.prefix
+  end
+
+  def test_replace_text
+    @cl.insert("old")
+    @cl.replace_text("new text")
+    assert_equal "new text", @cl.text
+    assert_equal 8, @cl.cursor
+  end
+
+  def test_replace_span_end_cursor
+    @cl.insert("hello world")
+    @cl.replace_span(6, 11, "ruby")
+    assert_equal "hello ruby", @cl.text
+    assert_equal 10, @cl.cursor
+  end
+
+  def test_replace_span_start_cursor
+    @cl.insert("hello world")
+    @cl.replace_span(6, 11, "ruby", cursor_at: :start)
+    assert_equal "hello ruby", @cl.text
+    assert_equal 6, @cl.cursor
+  end
+
+  def test_replace_span_integer_cursor
+    @cl.insert("hello world")
+    @cl.replace_span(6, 11, "ruby", cursor_at: 8)
+    assert_equal "hello ruby", @cl.text
+    assert_equal 8, @cl.cursor
+  end
+end