ruvim 0.3.0 → 0.4.0

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

data/test/config_dsl_test.rb

@@ -75,4 +75,91 @@ class ConfigDSLTest < Minitest::Test
     assert_equal :match, match.status
     assert match.invocation.id.start_with?("user.keymap.global.")
   end
+
+  def test_nmap_with_command_id_string
+    @command_registry.register("test.cmd", call: ->(_ctx, **) {}, desc: "test", source: :builtin)
+    @dsl.nmap("T", "test.cmd")
+    match = @keymaps.resolve(:normal, ["T"])
+    assert_equal :match, match.status
+    assert_equal "test.cmd", match.invocation.id
+  end
+
+  def test_nmap_without_command_id_or_block_raises
+    # ConfigDSL < BasicObject, so raise becomes NoMethodError for ::ArgumentError
+    assert_raises(NoMethodError, ArgumentError) { @dsl.nmap("T") }
+  end
+
+  def test_imap_without_block_or_id_raises
+    assert_raises(NoMethodError, ArgumentError) { @dsl.imap("T") }
+  end
+
+  def test_command_registers_user_command
+    @dsl.command("my.cmd", desc: "custom") { |_ctx, **| }
+    spec = @command_registry.fetch("my.cmd")
+    assert_equal :user, spec.source
+    assert_equal "custom", spec.desc
+  end
+
+  def test_command_without_block_raises
+    assert_raises(NoMethodError, ArgumentError) { @dsl.command("my.cmd") }
+  end
+
+  def test_nmap_with_filetype
+    dsl = RuVim::ConfigDSL.new(
+      command_registry: @command_registry,
+      ex_registry: @ex_registry,
+      keymaps: @keymaps,
+      command_host: RuVim::GlobalCommands.instance,
+      filetype: "ruby"
+    )
+    dsl.nmap("K", desc: "ft test") { |_ctx, **| }
+    editor = fresh_editor
+    editor.current_buffer.options["filetype"] = "ruby"
+    match = @keymaps.resolve_with_context(:normal, ["K"], editor: editor)
+    assert_equal :match, match.status
+  end
+
+  def test_set_option_requires_editor
+    assert_raises(NoMethodError, ArgumentError) { @dsl.set("number") }
+  end
+
+  def test_set_boolean_option
+    editor = fresh_editor
+    dsl = RuVim::ConfigDSL.new(
+      command_registry: @command_registry,
+      ex_registry: @ex_registry,
+      keymaps: @keymaps,
+      command_host: RuVim::GlobalCommands.instance,
+      editor: editor
+    )
+    dsl.set("number")
+    assert editor.get_option("number")
+  end
+
+  def test_set_no_prefix_disables_option
+    editor = fresh_editor
+    dsl = RuVim::ConfigDSL.new(
+      command_registry: @command_registry,
+      ex_registry: @ex_registry,
+      keymaps: @keymaps,
+      command_host: RuVim::GlobalCommands.instance,
+      editor: editor
+    )
+    dsl.set("number")
+    dsl.set("nonumber")
+    refute editor.get_option("number")
+  end
+
+  def test_set_with_value
+    editor = fresh_editor
+    dsl = RuVim::ConfigDSL.new(
+      command_registry: @command_registry,
+      ex_registry: @ex_registry,
+      keymaps: @keymaps,
+      command_host: RuVim::GlobalCommands.instance,
+      editor: editor
+    )
+    dsl.set("tabstop=4")
+    assert_equal 4, editor.get_option("tabstop")
+  end
 end

data/test/display_width_test.rb

@@ -15,4 +15,45 @@ class DisplayWidthTest < Minitest::Test
       ENV["RUVIM_AMBIGUOUS_WIDTH"] = prev
     end
   end
+
+  def test_zero_codepoint_returns_zero
+    assert_equal 0, RuVim::DisplayWidth.uncached_codepoint_width(0)
+  end
+
+  def test_expand_tabs_basic
+    assert_equal "  hello", RuVim::DisplayWidth.expand_tabs("\thello", tabstop: 2)
+  end
+
+  def test_expand_tabs_mid_column
+    assert_equal "a hello", RuVim::DisplayWidth.expand_tabs("a\thello", tabstop: 2)
+  end
+
+  def test_expand_tabs_with_tabstop_4
+    assert_equal "    hello", RuVim::DisplayWidth.expand_tabs("\thello", tabstop: 4)
+  end
+
+  def test_expand_tabs_preserves_non_tab_chars
+    assert_equal "hello", RuVim::DisplayWidth.expand_tabs("hello", tabstop: 2)
+  end
+
+  def test_expand_tabs_with_start_col
+    result = RuVim::DisplayWidth.expand_tabs("\tx", tabstop: 4, start_col: 1)
+    assert_equal "   x", result
+  end
+
+  def test_wide_codepoint_cjk
+    assert_equal 2, RuVim::DisplayWidth.cell_width("漢")
+  end
+
+  def test_wide_codepoint_fullwidth_form
+    assert_equal 2, RuVim::DisplayWidth.cell_width("Ａ")
+  end
+
+  def test_combining_mark_returns_zero
+    assert_equal 0, RuVim::DisplayWidth.cell_width("\u0300")
+  end
+
+  def test_zero_width_joiner_returns_zero
+    assert_equal 0, RuVim::DisplayWidth.cell_width("\u200D")
+  end
 end

data/test/file_watcher_test.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "ruvim/file_watcher"
+require "tempfile"
+
+class FileWatcherTest < Minitest::Test
+  def setup
+    @tmpfile = Tempfile.new("file_watcher_test")
+    @tmpfile.write("initial\n")
+    @tmpfile.flush
+    @path = @tmpfile.path
+  end
+
+  def teardown
+    @watcher&.stop
+    @tmpfile&.close!
+  end
+
+  def test_polling_watcher_detects_append
+    received = Queue.new
+    @watcher = RuVim::FileWatcher::PollingWatcher.new(@path) do |type, data|
+      received << [type, data]
+    end
+    @watcher.start
+
+    File.open(@path, "a") { |f| f.write("appended\n") }
+
+    event = nil
+    assert_eventually(timeout: 2) { event = received.pop(true) rescue nil; !event.nil? }
+    assert_equal :data, event[0]
+    assert_includes event[1], "appended"
+  ensure
+    @watcher&.stop
+  end
+
+  def test_polling_watcher_stop
+    @watcher = RuVim::FileWatcher::PollingWatcher.new(@path) { |_, _| }
+    @watcher.start
+    assert @watcher.alive?
+    @watcher.stop
+    refute @watcher.alive?
+  end
+
+  def test_polling_watcher_detects_truncation
+    received = Queue.new
+    @watcher = RuVim::FileWatcher::PollingWatcher.new(@path) do |type, data|
+      received << [type, data]
+    end
+    @watcher.start
+
+    # Append first so offset advances
+    File.open(@path, "a") { |f| f.write("extra\n") }
+    assert_eventually(timeout: 2) { received.pop(true) rescue nil }
+
+    # Truncate the file
+    File.write(@path, "")
+
+    event = nil
+    assert_eventually(timeout: 3) { event = received.pop(true) rescue nil; event&.first == :truncated }
+    assert_equal :truncated, event[0]
+    assert_nil event[1]
+  ensure
+    @watcher&.stop
+  end
+
+  def test_polling_watcher_detects_deletion
+    received = Queue.new
+    @watcher = RuVim::FileWatcher::PollingWatcher.new(@path) do |type, data|
+      received << [type, data]
+    end
+    @watcher.start
+
+    File.delete(@path)
+
+    event = nil
+    assert_eventually(timeout: 3) { event = received.pop(true) rescue nil; event&.first == :deleted }
+    assert_equal :deleted, event[0]
+    assert_nil event[1]
+  ensure
+    @watcher&.stop
+  end
+
+  def test_polling_watcher_waits_for_missing_file
+    missing_path = File.join(Dir.pwd, "follow_missing_test_#{$$}.log")
+    File.delete(missing_path) if File.exist?(missing_path)
+
+    received = Queue.new
+    watcher = RuVim::FileWatcher::PollingWatcher.new(missing_path) do |type, data|
+      received << [type, data]
+    end
+    watcher.start
+
+    sleep 0.2
+    assert watcher.alive?
+
+    File.write(missing_path, "hello\n")
+
+    event = nil
+    assert_eventually(timeout: 3) { event = received.pop(true) rescue nil; !event.nil? }
+    assert_equal :data, event[0]
+    assert_includes event[1], "hello"
+  ensure
+    watcher&.stop
+    File.delete(missing_path) if File.exist?(missing_path)
+  end
+
+  def test_inotify_watcher_detects_append
+    skip "inotify not available" unless RuVim::FileWatcher::InotifyWatcher.available?
+
+    received = Queue.new
+    @watcher = RuVim::FileWatcher::InotifyWatcher.new(@path) do |type, data|
+      received << [type, data]
+    end
+    @watcher.start
+
+    File.open(@path, "a") { |f| f.write("inotify appended\n") }
+
+    event = nil
+    assert_eventually(timeout: 2) { event = received.pop(true) rescue nil; !event.nil? }
+    assert_equal :data, event[0]
+    assert_includes event[1], "inotify appended"
+  ensure
+    @watcher&.stop
+  end
+
+  def test_inotify_watcher_stop
+    skip "inotify not available" unless RuVim::FileWatcher::InotifyWatcher.available?
+
+    @watcher = RuVim::FileWatcher::InotifyWatcher.new(@path) { |_, _| }
+    @watcher.start
+    assert @watcher.alive?
+    @watcher.stop
+    refute @watcher.alive?
+  end
+
+  def test_inotify_watcher_detects_truncation
+    skip "inotify not available" unless RuVim::FileWatcher::InotifyWatcher.available?
+
+    received = Queue.new
+    @watcher = RuVim::FileWatcher::InotifyWatcher.new(@path) do |type, data|
+      received << [type, data]
+    end
+    @watcher.start
+
+    File.open(@path, "a") { |f| f.write("extra\n") }
+    assert_eventually(timeout: 2) { received.pop(true) rescue nil }
+
+    File.write(@path, "")
+
+    event = nil
+    assert_eventually(timeout: 3) { event = received.pop(true) rescue nil; event&.first == :truncated }
+    assert_equal :truncated, event[0]
+  ensure
+    @watcher&.stop
+  end
+
+  def test_create_prefers_inotify
+    watcher = RuVim::FileWatcher.create(@path) { |_, _| }
+    if RuVim::FileWatcher::InotifyWatcher.available?
+      assert_kind_of RuVim::FileWatcher::InotifyWatcher, watcher
+    else
+      assert_kind_of RuVim::FileWatcher::PollingWatcher, watcher
+    end
+  ensure
+    watcher&.stop
+  end
+
+  def test_create_falls_back_to_polling_for_missing_file
+    missing_path = File.join(Dir.pwd, "follow_create_test_#{$$}.log")
+    File.delete(missing_path) if File.exist?(missing_path)
+
+    watcher = RuVim::FileWatcher.create(missing_path) { |_, _| }
+    assert_kind_of RuVim::FileWatcher::PollingWatcher, watcher
+  ensure
+    watcher&.stop
+    File.delete(missing_path) if File.exist?(missing_path)
+  end
+
+  def test_polling_backoff_resets_on_change
+    @watcher = RuVim::FileWatcher::PollingWatcher.new(@path) { |_, _| }
+    assert_equal RuVim::FileWatcher::PollingWatcher::MIN_INTERVAL, @watcher.current_interval
+  end
+
+  private
+
+  def assert_eventually(timeout: 2, interval: 0.05)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+    loop do
+      return if yield
+      if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+        flunk "Timed out waiting for condition"
+      end
+      sleep interval
+    end
+  end
+end