ruvim 0.4.0 → 0.6.0

data/test/cli_test.rb

@@ -176,4 +176,67 @@ class CLITest < Minitest::Test
     assert_equal 2, code
     assert_match(/config file not found/, err.string)
   end
+
+  def test_parse_double_dash_stops_options
+    opts = RuVim::CLI.parse(["--", "-R", "--help"])
+    assert_equal ["-R", "--help"], opts.files
+    assert_equal false, opts.readonly
+    assert_equal false, opts.show_help
+  end
+
+  def test_parse_unknown_option_raises
+    assert_raises(RuVim::CLI::ParseError) do
+      RuVim::CLI.parse(["--unknown-flag"])
+    end
+  end
+
+  def test_parse_startuptime_missing_arg_raises
+    assert_raises(RuVim::CLI::ParseError) do
+      RuVim::CLI.parse(["--startuptime"])
+    end
+  end
+
+  def test_parse_cmd_missing_arg_raises
+    assert_raises(RuVim::CLI::ParseError) do
+      RuVim::CLI.parse(["--cmd"])
+    end
+  end
+
+  def test_parse_q_missing_arg_raises
+    assert_raises(RuVim::CLI::ParseError) do
+      RuVim::CLI.parse(["-q"])
+    end
+  end
+
+  def test_parse_u_missing_arg_raises
+    assert_raises(RuVim::CLI::ParseError) do
+      RuVim::CLI.parse(["-u"])
+    end
+  end
+
+  def test_parse_c_missing_arg_raises
+    assert_raises(RuVim::CLI::ParseError) do
+      RuVim::CLI.parse(["-c"])
+    end
+  end
+
+  def test_parse_combined_u_value
+    opts = RuVim::CLI.parse(["-u/tmp/myrc.rb"])
+    assert_equal "/tmp/myrc.rb", opts.config_path
+  end
+
+  def test_parse_verbose_without_level
+    opts = RuVim::CLI.parse(["--verbose"])
+    assert_equal 1, opts.verbose_level
+  end
+
+  def test_parse_multiple_files
+    opts = RuVim::CLI.parse(["a.txt", "b.txt", "c.txt"])
+    assert_equal ["a.txt", "b.txt", "c.txt"], opts.files
+  end
+
+  def test_parse_plus_ex_command
+    opts = RuVim::CLI.parse(["+set number", "file.txt"])
+    assert_equal [{ type: :ex, value: "set number" }], opts.startup_actions
+  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/config_dsl_test.rb

@@ -162,4 +162,51 @@ class ConfigDSLTest < Minitest::Test
     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/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

data/test/follow_test.rb

@@ -13,26 +13,29 @@ class FollowTest < Minitest::Test
     @app = RuVim::App.new(path: @path, clean: true)
     @editor = @app.instance_variable_get(:@editor)
     @dispatcher = @app.instance_variable_get(:@dispatcher)
+    @key_handler = @app.instance_variable_get(:@key_handler)
+    @stream_mixer = @app.instance_variable_get(:@stream_mixer)
   end
 
   def cleanup_follow_app
     return unless @app
 
-    watchers = @app.instance_variable_get(:@follow_watchers)
-    watchers.each_value { |w| w.stop rescue nil }
-    watchers.clear
+    editor = @app&.instance_variable_get(:@editor)
+    return unless editor
+    editor.buffers.each_value do |buf|
+      buf.stream&.stop! rescue nil
+    end
     @tmpfile&.close!
   end
 
   def test_follow_starts_on_file_buffer
     create_follow_app
     @dispatcher.dispatch_ex(@editor, "follow")
-    watchers = @app.instance_variable_get(:@follow_watchers)
     buf = @editor.current_buffer
 
     assert !@editor.message_error?, "Unexpected error: #{@editor.message}"
-    assert_equal :live, buf.stream_state
-    assert watchers.key?(buf.id)
+    assert_equal :live, buf.stream.state
+    assert buf.stream.watcher
     assert_includes @editor.message.to_s, "[follow]"
   ensure
     cleanup_follow_app
@@ -42,10 +45,10 @@ class FollowTest < Minitest::Test
     create_follow_app
     @dispatcher.dispatch_ex(@editor, "follow")
     buf = @editor.current_buffer
-    assert_equal :live, buf.stream_state
+    assert_equal :live, buf.stream.state
 
-    @app.send(:handle_key, :ctrl_c)
-    assert_nil buf.stream_state
+    @key_handler.handle(:ctrl_c)
+    assert_nil buf.stream
     assert_includes @editor.message.to_s, "stopped"
   ensure
     cleanup_follow_app
@@ -55,12 +58,10 @@ class FollowTest < Minitest::Test
     create_follow_app
     @dispatcher.dispatch_ex(@editor, "follow")
     buf = @editor.current_buffer
-    assert_equal :live, buf.stream_state
+    assert_equal :live, buf.stream.state
 
     @dispatcher.dispatch_ex(@editor, "follow")
-    watchers = @app.instance_variable_get(:@follow_watchers)
-    assert_nil buf.stream_state
-    refute watchers.key?(buf.id)
+    assert_nil buf.stream
     assert_includes @editor.message.to_s, "stopped"
   ensure
     cleanup_follow_app
@@ -101,7 +102,7 @@ class FollowTest < Minitest::Test
 
     @dispatcher.dispatch_ex(@editor, "follow")
     assert_includes @editor.message.to_s, "unsaved changes"
-    assert_nil buf.stream_state
+    assert_nil buf.stream
   ensure
     cleanup_follow_app
   end
@@ -129,7 +130,7 @@ class FollowTest < Minitest::Test
     File.open(@path, "a") { |f| f.write("line3\nline4\n") }
 
     assert_eventually(timeout: 3) do
-      @app.send(:drain_stream_events!)
+      @stream_mixer.drain_events!
       buf.line_count > 3
     end
 
@@ -153,7 +154,7 @@ class FollowTest < Minitest::Test
     File.open(@path, "a") { |f| f.write("line3\n") }
 
     assert_eventually(timeout: 3) do
-      @app.send(:drain_stream_events!)
+      @stream_mixer.drain_events!
       buf.line_count > 2
     end
 
@@ -170,16 +171,14 @@ class FollowTest < Minitest::Test
 
     app = RuVim::App.new(paths: [tmp1.path, tmp2.path], follow: true, clean: true)
     editor = app.instance_variable_get(:@editor)
-    watchers = app.instance_variable_get(:@follow_watchers)
-
     bufs = editor.buffers.values.select(&:file_buffer?)
     assert_equal 2, bufs.size
     bufs.each do |buf|
-      assert_equal :live, buf.stream_state, "#{buf.display_name} should be in follow mode"
-      assert watchers.key?(buf.id), "#{buf.display_name} should have a watcher"
+      assert_equal :live, buf.stream.state, "#{buf.display_name} should be in follow mode"
+      assert buf.stream.watcher, "#{buf.display_name} should have a watcher"
     end
   ensure
-    watchers&.each_value { |w| w.stop rescue nil }
+    bufs&.each { |b| b.stream&.stop! rescue nil }
     tmp1&.close!
     tmp2&.close!
   end

data/test/gh_link_test.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class GhLinkTest < Minitest::Test
+  def setup
+    @app = RuVim::App.new(clean: true)
+    @editor = @app.instance_variable_get(:@editor)
+    @dispatcher = @app.instance_variable_get(:@dispatcher)
+    @editor.materialize_intro_buffer!
+  end
+
+  # --- URL parsing ---
+
+  def test_parse_ssh_remote
+    url = RuVim::Gh::Link.github_url_from_remote("git@github.com:user/repo.git")
+    assert_equal "https://github.com/user/repo", url
+  end
+
+  def test_parse_ssh_remote_without_dot_git
+    url = RuVim::Gh::Link.github_url_from_remote("git@github.com:user/repo")
+    assert_equal "https://github.com/user/repo", url
+  end
+
+  def test_parse_https_remote
+    url = RuVim::Gh::Link.github_url_from_remote("https://github.com/user/repo.git")
+    assert_equal "https://github.com/user/repo", url
+  end
+
+  def test_parse_https_remote_without_dot_git
+    url = RuVim::Gh::Link.github_url_from_remote("https://github.com/user/repo")
+    assert_equal "https://github.com/user/repo", url
+  end
+
+  def test_parse_non_github_remote_returns_nil
+    url = RuVim::Gh::Link.github_url_from_remote("git@gitlab.com:user/repo.git")
+    assert_nil url
+  end
+
+  def test_parse_empty_remote_returns_nil
+    url = RuVim::Gh::Link.github_url_from_remote("")
+    assert_nil url
+  end
+
+  # --- Link building ---
+
+  def test_build_link_single_line
+    link = RuVim::Gh::Link.build_url("https://github.com/user/repo", "main", "lib/foo.rb", 10)
+    assert_equal "https://github.com/user/repo/blob/main/lib/foo.rb#L10", link
+  end
+
+  def test_build_link_line_range
+    link = RuVim::Gh::Link.build_url("https://github.com/user/repo", "main", "lib/foo.rb", 10, 20)
+    assert_equal "https://github.com/user/repo/blob/main/lib/foo.rb#L10-L20", link
+  end
+
+  def test_build_link_same_start_end
+    link = RuVim::Gh::Link.build_url("https://github.com/user/repo", "main", "lib/foo.rb", 5, 5)
+    assert_equal "https://github.com/user/repo/blob/main/lib/foo.rb#L5", link
+  end
+
+  # --- OSC 52 ---
+
+  def test_osc52_escape_sequence
+    seq = RuVim::Gh::Link.osc52_copy_sequence("hello")
+    expected = "\e]52;c;#{["hello"].pack("m0")}\a"
+    assert_equal expected, seq
+  end
+
+  # --- Remote detection ---
+
+  def test_find_github_remote_with_specific_name
+    # This test runs in the actual ruvim repo
+    name, url = RuVim::Gh::Link.find_github_remote(Dir.pwd, "origin")
+    if url
+      assert_equal "origin", name
+      assert_match(%r{\Ahttps://github\.com/}, url)
+    else
+      skip "origin is not a GitHub remote in this repo"
+    end
+  end
+
+  def test_find_github_remote_auto_detect
+    name, url = RuVim::Gh::Link.find_github_remote(Dir.pwd)
+    if url
+      assert_kind_of String, name
+      assert_match(%r{\Ahttps://github\.com/}, url)
+    else
+      skip "No GitHub remote in this repo"
+    end
+  end
+
+  def test_find_github_remote_nonexistent_returns_nil
+    name, url = RuVim::Gh::Link.find_github_remote(Dir.pwd, "nonexistent_remote_xyz")
+    assert_nil name
+    assert_nil url
+  end
+
+  # --- Resolve warning ---
+
+  def test_resolve_returns_warning_when_file_differs
+    # file_differs_from_remote? returns true for non-existent remote ref
+    assert RuVim::Gh::Link.file_differs_from_remote?(Dir.pwd, "nonexistent_remote_xyz", "main", __FILE__)
+  end
+
+  # --- Ex command integration ---
+
+  # --- PR URL ---
+
+  def test_pr_search_url
+    url = RuVim::Gh::Link.pr_search_url("https://github.com/user/repo", "feature-branch")
+    assert_equal "https://github.com/user/repo/pulls?q=head:feature-branch", url
+  end
+
+  # --- Ex command integration ---
+
+  def test_gh_browse_listed_in_subcommands
+    @dispatcher.dispatch_ex(@editor, "gh")
+    assert_match(/browse/, @editor.message)
+  end
+
+  def test_gh_pr_listed_in_subcommands
+    @dispatcher.dispatch_ex(@editor, "gh")
+    assert_match(/pr/, @editor.message)
+  end
+
+  def test_gh_no_subcommand_shows_help
+    @dispatcher.dispatch_ex(@editor, "gh")
+    assert_match(/link/, @editor.message)
+  end
+
+  def test_gh_unknown_subcommand_runs_shell
+    executed = nil
+    fake_status = Struct.new(:exitstatus).new(0)
+    @editor.shell_executor = ->(cmd) { executed = cmd; fake_status }
+
+    @dispatcher.dispatch_ex(@editor, "gh issue list")
+
+    assert_equal "gh issue list", executed
+  end
+end