ruvim 0.3.0 → 0.6.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_invocation_test.rb

@@ -0,0 +1,33 @@
+require_relative "test_helper"
+
+class CommandInvocationTest < Minitest::Test
+  def test_bang_defaults_to_false
+    inv = RuVim::CommandInvocation.new(id: "test")
+    assert_equal false, inv.bang
+  end
+
+  def test_bang_true
+    inv = RuVim::CommandInvocation.new(id: "test", bang: true)
+    assert_equal true, inv.bang
+  end
+
+  def test_bang_false
+    inv = RuVim::CommandInvocation.new(id: "test", bang: false)
+    assert_equal false, inv.bang
+  end
+
+  def test_argv_defaults_to_empty_array
+    inv = RuVim::CommandInvocation.new(id: "test")
+    assert_equal [], inv.argv
+  end
+
+  def test_kwargs_defaults_to_empty_hash
+    inv = RuVim::CommandInvocation.new(id: "test")
+    assert_equal({}, inv.kwargs)
+  end
+
+  def test_count_defaults_to_nil
+    inv = RuVim::CommandInvocation.new(id: "test")
+    assert_nil inv.count
+  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,138 @@ 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
+
+  def test_ex_command_registers_and_allows_re_register
+    dsl = RuVim::ConfigDSL.new(
+      command_registry: @command_registry,
+      ex_registry: RuVim::ExCommandRegistry.instance,
+      keymaps: @keymaps,
+      command_host: RuVim::GlobalCommands.instance
+    )
+    saved_specs = RuVim::ExCommandRegistry.instance.instance_variable_get(:@specs).dup
+    saved_lookup = RuVim::ExCommandRegistry.instance.instance_variable_get(:@lookup).dup
+
+    dsl.ex_command("testusercmd", desc: "test") { |_ctx, **| }
+    assert RuVim::ExCommandRegistry.instance.registered?("testusercmd")
+
+    # Re-registering should not raise (unregisters first)
+    dsl.ex_command("testusercmd", desc: "test v2") { |_ctx, **| }
+    assert RuVim::ExCommandRegistry.instance.registered?("testusercmd")
+  ensure
+    RuVim::ExCommandRegistry.instance.instance_variable_set(:@specs, saved_specs)
+    RuVim::ExCommandRegistry.instance.instance_variable_set(:@lookup, saved_lookup)
+  end
+
+  def test_setlocal_sets_local_scope
+    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.setlocal("number")
+    assert editor.get_option("number")
+  end
+
+  def test_setglobal_sets_global_scope
+    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.setglobal("ignorecase")
+    assert editor.get_option("ignorecase")
+  end
 end

data/test/dispatcher_test.rb

@@ -119,19 +119,89 @@ class DispatcherTest < Minitest::Test
     assert_includes body, "42"
   end
 
-  def test_dispatch_ex_shell_captures_stdout_and_stderr_into_virtual_buffer
+  def test_dispatch_ex_shell_uses_shell_executor_when_available
+    executed_command = nil
+    fake_status = Struct.new(:exitstatus).new(0)
+    @editor.shell_executor = ->(cmd) { executed_command = cmd; fake_status }
+
+    @dispatcher.dispatch_ex(@editor, "!echo hello")
+
+    assert_equal "echo hello", executed_command
+    assert_equal "shell exit 0", @editor.message
+  end
+
+  def test_dispatch_ex_shell_falls_back_to_capture_without_executor
+    @editor.shell_executor = nil
     @dispatcher.dispatch_ex(@editor, "!echo out; echo err 1>&2")
 
     assert_equal "[Shell Output]", @editor.message
     assert_equal :help, @editor.current_buffer.kind
     body = @editor.current_buffer.lines.join("\n")
-    assert_includes body, "[command]"
-    assert_includes body, "echo out; echo err 1>&2"
     assert_includes body, "[stdout]"
     assert_includes body, "out"
     assert_includes body, "[stderr]"
     assert_includes body, "err"
-    assert_includes body, "[status]"
+  end
+
+  def test_dispatch_ex_read_file_inserts_after_cursor_line
+    @editor.materialize_intro_buffer!
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "data.txt")
+      File.write(path, "aaa\nbbb\n")
+      @editor.current_buffer.replace_all_lines!(%w[line1 line2 line3])
+      @editor.current_window.cursor_y = 1  # on line2
+
+      @dispatcher.dispatch_ex(@editor, "r #{path}")
+
+      assert_equal %w[line1 line2 aaa bbb line3], @editor.current_buffer.lines
+    end
+  end
+
+  def test_dispatch_ex_read_with_range_inserts_after_specified_line
+    @editor.materialize_intro_buffer!
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "data.txt")
+      File.write(path, "inserted\n")
+      @editor.current_buffer.replace_all_lines!(%w[line1 line2 line3])
+
+      @dispatcher.dispatch_ex(@editor, "2r #{path}")
+
+      assert_equal %w[line1 line2 inserted line3], @editor.current_buffer.lines
+    end
+  end
+
+  def test_dispatch_ex_read_shell_command_inserts_output
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(%w[line1 line2])
+    @editor.current_window.cursor_y = 0
+
+    @dispatcher.dispatch_ex(@editor, "r !echo hello")
+
+    assert_equal %w[line1 hello line2], @editor.current_buffer.lines
+  end
+
+  def test_dispatch_ex_write_to_shell_command
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(%w[hello world])
+
+    Dir.mktmpdir do |dir|
+      outfile = File.join(dir, "out.txt")
+      @dispatcher.dispatch_ex(@editor, "w !cat > #{outfile}")
+
+      assert_equal "hello\nworld\n", File.read(outfile)
+    end
+  end
+
+  def test_dispatch_ex_write_range_to_shell_command
+    @editor.materialize_intro_buffer!
+    @editor.current_buffer.replace_all_lines!(%w[aaa bbb ccc])
+
+    Dir.mktmpdir do |dir|
+      outfile = File.join(dir, "out.txt")
+      @dispatcher.dispatch_ex(@editor, "2,3w !cat > #{outfile}")
+
+      assert_equal "bbb\nccc\n", File.read(outfile)
+    end
   end
 
   def test_dispatch_ex_set_commands

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/ex_command_registry_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class ExCommandRegistryTest < Minitest::Test
+  def setup
+    @registry = RuVim::ExCommandRegistry.instance
+    @saved_specs = @registry.instance_variable_get(:@specs).dup
+    @saved_lookup = @registry.instance_variable_get(:@lookup).dup
+  end
+
+  def teardown
+    @registry.instance_variable_set(:@specs, @saved_specs)
+    @registry.instance_variable_set(:@lookup, @saved_lookup)
+  end
+
+  def test_register_and_resolve
+    @registry.clear!
+    spec = @registry.register("testcmd", call: ->(_ctx) {}, desc: "test")
+    assert_equal "testcmd", spec.name
+
+    resolved = @registry.resolve("testcmd")
+    assert_equal spec, resolved
+  end
+
+  def test_register_with_aliases
+    @registry.clear!
+    spec = @registry.register("testcmd", call: ->(_ctx) {}, aliases: ["tc", "tcmd"])
+
+    assert_equal @registry.resolve("tc"), spec
+    assert_equal @registry.resolve("tcmd"), spec
+  end
+
+  def test_register_duplicate_raises
+    @registry.clear!
+    @registry.register("testcmd", call: ->(_ctx) {})
+
+    assert_raises(RuVim::CommandError) do
+      @registry.register("testcmd", call: ->(_ctx) {})
+    end
+  end
+
+  def test_register_alias_collision_raises
+    @registry.clear!
+    @registry.register("cmd1", call: ->(_ctx) {}, aliases: ["shared"])
+
+    assert_raises(RuVim::CommandError) do
+      @registry.register("cmd2", call: ->(_ctx) {}, aliases: ["shared"])
+    end
+  end
+
+  def test_resolve_returns_nil_for_unknown
+    @registry.clear!
+    assert_nil @registry.resolve("nonexistent")
+  end
+
+  def test_fetch_raises_for_unknown
+    @registry.clear!
+    assert_raises(RuVim::CommandError) do
+      @registry.fetch("nonexistent")
+    end
+  end
+
+  def test_fetch_returns_spec
+    @registry.clear!
+    spec = @registry.register("testcmd", call: ->(_ctx) {})
+    assert_equal spec, @registry.fetch("testcmd")
+  end
+
+  def test_registered?
+    @registry.clear!
+    refute @registry.registered?("testcmd")
+    @registry.register("testcmd", call: ->(_ctx) {})
+    assert @registry.registered?("testcmd")
+  end
+
+  def test_all_returns_sorted
+    @registry.clear!
+    @registry.register("beta", call: ->(_ctx) {})
+    @registry.register("alpha", call: ->(_ctx) {})
+    names = @registry.all.map(&:name)
+    assert_equal ["alpha", "beta"], names
+  end
+
+  def test_unregister
+    @registry.clear!
+    @registry.register("testcmd", call: ->(_ctx) {}, aliases: ["tc"])
+
+    removed = @registry.unregister("testcmd")
+    assert_equal "testcmd", removed.name
+    assert_nil @registry.resolve("testcmd")
+    assert_nil @registry.resolve("tc")
+  end
+
+  def test_unregister_unknown_returns_nil
+    @registry.clear!
+    assert_nil @registry.unregister("nonexistent")
+  end
+
+  def test_clear!
+    @registry.clear!
+    @registry.register("testcmd", call: ->(_ctx) {})
+    @registry.clear!
+    assert_equal [], @registry.all
+  end
+end