ruvim 0.3.0 → 0.6.0

data/test/app_scenario_test.rb

@@ -8,11 +8,12 @@ class AppScenarioTest < Minitest::Test
     @app = RuVim::App.new(clean: true)
     @editor = @app.instance_variable_get(:@editor)
     @dispatcher = @app.instance_variable_get(:@dispatcher)
+    @key_handler = @app.instance_variable_get(:@key_handler)
     @editor.materialize_intro_buffer!
   end
 
   def feed(*keys)
-    keys.each { |k| @app.send(:handle_key, k) }
+    keys.each { |k| @key_handler.handle(k) }
   end
 
   def test_insert_edit_search_and_delete_scenario
@@ -353,7 +354,7 @@ class AppScenarioTest < Minitest::Test
     @editor.current_buffer.modifiable = false
     @editor.current_buffer.readonly = true
 
-    @app.send(:handle_key, "x")
+    @key_handler.handle("x")
 
     assert_equal ["hello"], @editor.current_buffer.lines
     assert_match(/not modifiable/i, @editor.message)
@@ -364,7 +365,7 @@ class AppScenarioTest < Minitest::Test
     @editor.current_buffer.modifiable = false
     @editor.current_buffer.readonly = true
 
-    @app.send(:handle_key, "i")
+    @key_handler.handle("i")
 
     assert_equal :normal, @editor.mode
     assert_equal ["hello"], @editor.current_buffer.lines
@@ -373,15 +374,16 @@ class AppScenarioTest < Minitest::Test
 
   def test_normal_ctrl_c_stops_stdin_stream_via_default_binding
     stream = StringIO.new("hello\n")
-    @app.instance_variable_set(:@stdin_stream_source, stream)
-    @app.send(:prepare_stdin_stream_buffer!)
+    sh = @app.instance_variable_get(:@stream_mixer)
+    sh.prepare_stdin_stream_buffer!(stream)
+    sh.start_pending_stdin!
 
-    @app.send(:handle_key, :ctrl_c)
+    @key_handler.handle(:ctrl_c)
 
-    assert_equal :closed, @editor.current_buffer.stream_state
+    assert_equal :closed, @editor.current_buffer.stream.state
     assert_equal :normal, @editor.mode
     assert_equal true, stream.closed?
-    assert_match(/\[stdin\] closed/, @editor.message)
+    assert_match(/stopped/, @editor.message)
   end
 
   def test_ctrl_z_calls_terminal_suspend
@@ -392,6 +394,7 @@ class AppScenarioTest < Minitest::Test
     end
     terminal_stub.define_singleton_method(:suspend_calls) { @suspend_calls }
     @app.instance_variable_set(:@terminal, terminal_stub)
+    @app.instance_variable_get(:@key_handler).instance_variable_set(:@terminal, terminal_stub)
 
     feed("i", "a", :ctrl_z)
 
@@ -404,6 +407,7 @@ class AppScenarioTest < Minitest::Test
     terminal_stub = Object.new
     terminal_stub.define_singleton_method(:suspend_for_tstp) {}
     @app.instance_variable_set(:@terminal, terminal_stub)
+    @app.instance_variable_get(:@key_handler).instance_variable_set(:@terminal, terminal_stub)
 
     screen_stub = Object.new
     screen_stub.instance_variable_set(:@invalidated, false)
@@ -412,6 +416,7 @@ class AppScenarioTest < Minitest::Test
     end
     screen_stub.define_singleton_method(:invalidated?) { @invalidated }
     @app.instance_variable_set(:@screen, screen_stub)
+    @app.instance_variable_get(:@key_handler).instance_variable_set(:@screen, screen_stub)
 
     feed(:ctrl_z)
 
@@ -695,6 +700,28 @@ class AppScenarioTest < Minitest::Test
     assert_equal :normal, @editor.mode
   end
 
+  def test_paste_batch_suppresses_autoindent
+    @editor.current_buffer.replace_all_lines!(["  hello"])
+    @editor.current_window.cursor_y = 0
+    @editor.current_window.cursor_x = 0
+
+    # Normal enter in insert mode should autoindent
+    feed("A", :enter, :escape)
+    assert_equal ["  hello", "  "], @editor.current_buffer.lines
+
+    # Simulate paste batch: autoindent should be suppressed
+    @editor.current_buffer.replace_all_lines!(["  hello"])
+    @editor.current_window.cursor_y = 0
+    @editor.current_window.cursor_x = 0
+    feed("A")
+    @app.instance_variable_get(:@key_handler).paste_batch = true
+    feed(:enter, *"world".chars)
+    @app.instance_variable_get(:@key_handler).paste_batch = false
+    feed(:escape)
+
+    assert_equal ["  hello", "world"], @editor.current_buffer.lines
+  end
+
   def test_batch_insert_stops_on_escape
     @editor.current_buffer.replace_all_lines!([""])
     # Escape exits insert mode; subsequent keys are normal-mode commands
@@ -1072,4 +1099,151 @@ class AppScenarioTest < Minitest::Test
     assert_equal :hsplit, tree[:type]
     assert_equal 3, tree[:children].length
   end
+
+  # --- search filter (g/) ---
+
+  def test_filter_creates_buffer_with_matching_lines
+    @editor.current_buffer.replace_all_lines!(["apple", "banana", "apricot", "cherry"])
+    feed("/", "a", "p", :enter)  # search for "ap"
+    feed("g", "/")
+
+    buf = @editor.current_buffer
+    assert_equal :filter, buf.kind
+    assert_equal ["apple", "apricot"], buf.lines
+  end
+
+  def test_filter_enter_jumps_to_original_line_and_closes_filter
+    @editor.current_buffer.replace_all_lines!(["apple", "banana", "apricot", "cherry"])
+    original_buf_id = @editor.current_buffer.id
+    feed("/", "a", "p", :enter)
+    feed("g", "/")
+
+    # Move to second match line ("apricot", originally line 2)
+    feed("j")
+    feed(:enter)
+
+    assert_equal original_buf_id, @editor.current_buffer.id
+    assert_equal 2, @editor.current_window.cursor_y
+  end
+
+  def test_filter_quit_returns_to_previous_buffer
+    @editor.current_buffer.replace_all_lines!(["apple", "banana", "apricot"])
+    original_buf_id = @editor.current_buffer.id
+    feed("/", "a", "p", :enter)
+    feed("g", "/")
+
+    assert_equal :filter, @editor.current_buffer.kind
+    feed(":", "q", :enter)
+
+    assert_equal original_buf_id, @editor.current_buffer.id
+  end
+
+  def test_filter_recursive_filtering
+    @editor.current_buffer.replace_all_lines!(["apple pie", "apricot jam", "apple sauce", "cherry"])
+    feed("/", "a", "p", :enter)
+    feed("g", "/")
+
+    assert_equal ["apple pie", "apricot jam", "apple sauce"], @editor.current_buffer.lines
+
+    # Search within filter and filter again
+    feed("/", "p", "l", "e", :enter)
+    feed("g", "/")
+
+    assert_equal ["apple pie", "apple sauce"], @editor.current_buffer.lines
+
+    # Enter jumps to original buffer
+    feed("j")  # "apple sauce" - originally line 2 of buffer
+    feed(:enter)
+
+    assert_equal 2, @editor.current_window.cursor_y
+  end
+
+  def test_filter_inherits_filetype
+    @editor.current_buffer.replace_all_lines!(["a\tb", "c\td", "a\te"])
+    @editor.current_buffer.options["filetype"] = "tsv"
+    feed("/", "a", :enter)
+    feed("g", "/")
+
+    assert_equal "tsv", @editor.current_buffer.options["filetype"]
+  end
+
+  def test_filter_without_search_pattern_shows_error
+    @editor.current_buffer.replace_all_lines!(["apple", "banana"])
+    feed("g", "/")
+
+    assert @editor.message_error?
+  end
+
+  def test_filter_quit_restores_cursor_position
+    @editor.current_buffer.replace_all_lines!(["aaa", "bbb", "aab", "ccc", "aac"])
+    original_buf_id = @editor.current_buffer.id
+    feed("/", "a", "a", :enter)
+    # Search moves cursor to line 0 (first match)
+    feed("n")
+    # Now on line 2 ("aab")
+    assert_equal 2, @editor.current_window.cursor_y
+    feed("g", "/")
+
+    assert_equal :filter, @editor.current_buffer.kind
+    feed(":", "q", :enter)
+
+    assert_equal original_buf_id, @editor.current_buffer.id
+    assert_equal 2, @editor.current_window.cursor_y
+  end
+
+  def test_filter_ex_command
+    @editor.current_buffer.replace_all_lines!(["apple", "banana", "apricot"])
+    feed("/", "a", "p", :enter)
+    feed(":", "f", "i", "l", "t", "e", "r", :enter)
+
+    assert_equal :filter, @editor.current_buffer.kind
+    assert_equal ["apple", "apricot"], @editor.current_buffer.lines
+  end
+
+  # --- dG / dgg / yG / ygg / cG / cgg ---
+
+  def test_dG_deletes_from_cursor_to_end
+    @editor.current_buffer.replace_all_lines!(["aa", "bb", "cc", "dd", "ee"])
+    @editor.current_window.cursor_y = 2
+    feed("d", "G")
+
+    assert_equal ["aa", "bb"], @editor.current_buffer.lines
+  end
+
+  def test_dgg_deletes_from_cursor_to_start
+    @editor.current_buffer.replace_all_lines!(["aa", "bb", "cc", "dd", "ee"])
+    @editor.current_window.cursor_y = 2
+    feed("d", "g", "g")
+
+    assert_equal ["dd", "ee"], @editor.current_buffer.lines
+  end
+
+  def test_yG_yanks_from_cursor_to_end
+    @editor.current_buffer.replace_all_lines!(["aa", "bb", "cc", "dd"])
+    @editor.current_window.cursor_y = 1
+    feed("y", "G")
+
+    reg = @editor.get_register('"')&.fetch(:text, "")
+    assert_includes reg, "bb"
+    assert_includes reg, "dd"
+  end
+
+  def test_ygg_yanks_from_cursor_to_start
+    @editor.current_buffer.replace_all_lines!(["aa", "bb", "cc", "dd"])
+    @editor.current_window.cursor_y = 2
+    feed("y", "g", "g")
+
+    reg = @editor.get_register('"')&.fetch(:text, "")
+    assert_includes reg, "aa"
+    assert_includes reg, "cc"
+  end
+
+  def test_cG_changes_from_cursor_to_end
+    @editor.current_buffer.replace_all_lines!(["aa", "bb", "cc", "dd"])
+    @editor.current_window.cursor_y = 2
+    feed("c", "G")
+
+    assert_equal ["aa", "bb", ""], @editor.current_buffer.lines
+    assert_equal :insert, @editor.mode
+  end
 end

data/test/app_startup_test.rb

@@ -185,6 +185,46 @@ class AppStartupTest < Minitest::Test
     assert_match(/Restricted mode/, editor.message)
   end
 
+  def test_restricted_mode_disables_ex_grep
+    app = RuVim::App.new(clean: true, restricted: true)
+    editor = app.instance_variable_get(:@editor)
+    dispatcher = app.instance_variable_get(:@dispatcher)
+
+    dispatcher.dispatch_ex(editor, "grep pattern file.txt")
+
+    assert_match(/Restricted mode/, editor.message)
+  end
+
+  def test_restricted_mode_disables_ex_lgrep
+    app = RuVim::App.new(clean: true, restricted: true)
+    editor = app.instance_variable_get(:@editor)
+    dispatcher = app.instance_variable_get(:@dispatcher)
+
+    dispatcher.dispatch_ex(editor, "lgrep pattern file.txt")
+
+    assert_match(/Restricted mode/, editor.message)
+  end
+
+  def test_restricted_mode_disables_ex_git
+    app = RuVim::App.new(clean: true, restricted: true)
+    editor = app.instance_variable_get(:@editor)
+    dispatcher = app.instance_variable_get(:@dispatcher)
+
+    dispatcher.dispatch_ex(editor, "git status")
+
+    assert_match(/Restricted mode/, editor.message)
+  end
+
+  def test_restricted_mode_disables_ex_gh
+    app = RuVim::App.new(clean: true, restricted: true)
+    editor = app.instance_variable_get(:@editor)
+    dispatcher = app.instance_variable_get(:@dispatcher)
+
+    dispatcher.dispatch_ex(editor, "gh link")
+
+    assert_match(/Restricted mode/, editor.message)
+  end
+
   def test_verbose_logs_startup_and_startup_ex_actions
     log = StringIO.new
     app = RuVim::App.new(
@@ -260,10 +300,11 @@ class AppStartupTest < Minitest::Test
     )
     editor = app.instance_variable_get(:@editor)
 
+    sh = app.instance_variable_get(:@stream_mixer)
+    buf = editor.current_buffer
     20.times do
-      app.send(:drain_stream_events!)
-      thread = app.instance_variable_get(:@stream_reader_thread)
-      break unless thread&.alive?
+      sh.drain_events!
+      break unless buf.stream.thread&.alive?
       sleep 0.005
     end
 
@@ -272,11 +313,11 @@ class AppStartupTest < Minitest::Test
     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_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!)
+    app&.instance_variable_get(:@stream_mixer)&.shutdown!
   end
 
   def test_large_file_threshold_uses_async_loader
@@ -290,28 +331,28 @@ class AppStartupTest < Minitest::Test
         ENV["RUVIM_ASYNC_FILE_THRESHOLD_BYTES"] = "1"
         app = RuVim::App.new(clean: true)
         editor = app.instance_variable_get(:@editor)
+        sh = app.instance_variable_get(:@stream_mixer)
 
         buf = editor.open_path(f.path)
         assert_match(/loading/i, editor.message)
-        assert_includes [:live, :closed], buf.loading_state
+        assert_includes [:live, :closed], buf.stream&.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?
+          sh.drain_events!
+          break if buf.stream&.state != :live
+          break unless buf.stream.is_a?(RuVim::Stream::FileLoad) && buf.stream.thread&.alive?
           sleep 0.005
         end
-        app.send(:drain_stream_events!)
+        sh.drain_events!
 
-        assert_equal :closed, buf.loading_state
+        assert_equal :closed, buf.stream&.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!)
+        app&.instance_variable_get(:@stream_mixer)&.shutdown!
       end
     end
   end
@@ -329,25 +370,26 @@ class AppStartupTest < Minitest::Test
         ENV["RUVIM_ASYNC_FILE_PREFIX_BYTES"] = "4"
         app = RuVim::App.new(clean: true)
         editor = app.instance_variable_get(:@editor)
+        sh = app.instance_variable_get(:@stream_mixer)
 
         buf = editor.open_path(f.path)
-        assert_equal :live, buf.loading_state
-        assert_equal ["ab", "c"], buf.lines
+        assert_equal :live, buf.stream&.state
+        assert_equal ["ab", ""], buf.lines
         assert_match(/showing first/i, editor.message)
 
         100.times do
-          app.send(:drain_stream_events!)
-          break if buf.loading_state != :live
+          sh.drain_events!
+          break if buf.stream&.state != :live
           sleep 0.005
         end
-        app.send(:drain_stream_events!)
+        sh.drain_events!
 
-        assert_equal :closed, buf.loading_state
+        assert_equal :closed, buf.stream&.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!)
+        app&.instance_variable_get(:@stream_mixer)&.shutdown!
       end
     end
   end
@@ -360,16 +402,17 @@ class AppStartupTest < Minitest::Test
       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!)
+      completion1 = app1.instance_variable_get(:@completion)
+      completion1.push_history(":", "set number")
+      completion1.push_history("/", "foo")
+      completion1.push_history("?", "bar")
+      completion1.save_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)
+      hist = app2.instance_variable_get(:@completion).instance_variable_get(:@cmdline_history)
       assert_equal ["set number"], hist[":"]
       assert_equal ["foo"], hist["/"]
       assert_equal ["bar"], hist["?"]
@@ -387,7 +430,7 @@ class AppStartupTest < Minitest::Test
       ENV["HOME"] = dir
 
       app = RuVim::App.new(clean: true)
-      assert_equal File.join(dir, ".ruvim", "history.json"), app.send(:command_line_history_file_path)
+      assert_equal File.join(dir, ".ruvim", "history.json"), app.instance_variable_get(:@completion).send(:history_file_path)
     ensure
       ENV["XDG_STATE_HOME"] = prev_xdg
       ENV["HOME"] = prev_home

data/test/app_text_object_test.rb

@@ -4,13 +4,14 @@ class AppTextObjectTest < Minitest::Test
   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!
     @buffer = @editor.current_buffer
     @win = @editor.current_window
   end
 
   def press(*keys)
-    keys.each { |k| @app.send(:handle_normal_key, k) }
+    keys.each { |k| @key_handler.send(:handle_normal_key, k) }
   end
 
   def test_delete_inside_square_brackets

data/test/app_unicode_behavior_test.rb

@@ -4,17 +4,18 @@ class AppUnicodeBehaviorTest < Minitest::Test
   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!
     @buffer = @editor.current_buffer
     @win = @editor.current_window
   end
 
   def press_normal(*keys)
-    keys.each { |k| @app.send(:handle_normal_key, k) }
+    keys.each { |k| @key_handler.send(:handle_normal_key, k) }
   end
 
   def press(*keys)
-    keys.each { |k| @app.send(:handle_key, k) }
+    keys.each { |k| @key_handler.handle(k) }
   end
 
   def test_word_motions_on_japanese_text_do_not_break_character_boundaries

data/test/browser_test.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class BrowserTest < Minitest::Test
+  def test_wsl_mount_point_default
+    assert_equal "/mnt/", RuVim::Browser.wsl_mount_point(config: nil)
+  end
+
+  def test_wsl_mount_point_from_config
+    config = <<~CONF
+      [automount]
+      root = /win/
+    CONF
+    assert_equal "/win/", RuVim::Browser.wsl_mount_point(config: config)
+  end
+
+  def test_wsl_mount_point_with_missing_trailing_slash
+    config = <<~CONF
+      [automount]
+      root = /win
+    CONF
+    assert_equal "/win/", RuVim::Browser.wsl_mount_point(config: config)
+  end
+
+  def test_wsl_mount_point_ignores_commented_line
+    config = <<~CONF
+      [automount]
+      # root = /old/
+      root = /new/
+    CONF
+    assert_equal "/new/", RuVim::Browser.wsl_mount_point(config: config)
+  end
+
+  def test_detect_backend_returns_a_hash_or_nil
+    result = RuVim::Browser.detect_backend
+    if result
+      assert_kind_of Symbol, result[:type]
+    end
+  end
+
+  def test_powershell_path_uses_mount_point
+    path = RuVim::Browser.powershell_path("/mnt/")
+    assert_equal "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe", path
+  end
+
+  # --- URL validation ---
+
+  def test_valid_url_https
+    assert RuVim::Browser.valid_url?("https://github.com/user/repo")
+  end
+
+  def test_valid_url_http
+    assert RuVim::Browser.valid_url?("http://example.com")
+  end
+
+  def test_invalid_url_file
+    refute RuVim::Browser.valid_url?("file:///etc/passwd")
+  end
+
+  def test_invalid_url_javascript
+    refute RuVim::Browser.valid_url?("javascript:alert(1)")
+  end
+
+  def test_invalid_url_empty
+    refute RuVim::Browser.valid_url?("")
+  end
+
+  def test_invalid_url_nil
+    refute RuVim::Browser.valid_url?(nil)
+  end
+
+  # --- PowerShell encoded command ---
+
+  def test_powershell_encoded_command_uses_encoded_flag
+    cmd = RuVim::Browser.powershell_encoded_command("/ps.exe", "https://github.com/user/repo")
+    assert_equal "/ps.exe", cmd[0]
+    assert_includes cmd, "-EncodedCommand"
+    refute_includes cmd, "-Command"
+  end
+
+  def test_powershell_encoded_command_escapes_single_quotes
+    cmd = RuVim::Browser.powershell_encoded_command("/ps.exe", "https://example.com/it's")
+    encoded = cmd.last
+    decoded = encoded.unpack1("m0").force_encoding("UTF-16LE").encode("UTF-8")
+    assert_includes decoded, "it''s"
+  end
+end

data/test/buffer_test.rb

@@ -41,6 +41,30 @@ class BufferTest < Minitest::Test
     end
   end
 
+  def test_from_file_rejects_non_regular_file
+    Dir.mktmpdir do |dir|
+      fifo_path = File.join(dir, "test_fifo")
+      system("mkfifo", fifo_path)
+      assert File.exist?(fifo_path), "FIFO should exist"
+
+      err = assert_raises(RuVim::CommandError) do
+        RuVim::Buffer.from_file(id: 1, path: fifo_path)
+      end
+      assert_match(/Not a regular file/, err.message)
+    end
+  end
+
+  def test_reload_rejects_non_regular_file
+    b = RuVim::Buffer.new(id: 1, path: "/dev/null")
+    # /dev/null exists but is not a regular file on Linux
+    if !File.file?("/dev/null") && File.exist?("/dev/null")
+      err = assert_raises(RuVim::CommandError) do
+        b.reload_from_file!("/dev/null")
+      end
+      assert_match(/Not a regular file/, err.message)
+    end
+  end
+
   def test_utf8_file_is_loaded_as_utf8_text_not_binary_bytes
     Dir.mktmpdir do |dir|
       path = File.join(dir, "ruvim_utf8_test.txt")

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
@@ -162,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