ruvim 0.4.0 → 0.6.0

data/test/app_ex_command_test.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class AppExCommandTest < 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!
+  end
+
+  def feed(*keys)
+    keys.each { |k| @key_handler.handle(k) }
+  end
+
+  def buf
+    @editor.current_buffer
+  end
+
+  def win
+    @editor.current_window
+  end
+
+  # --- :set ---
+
+  def test_set_number_on_off
+    feed(":", "s", "e", "t", " ", "n", "u", "m", "b", "e", "r", :enter)
+    assert @editor.get_option("number")
+
+    feed(":", "s", "e", "t", " ", "n", "o", "n", "u", "m", "b", "e", "r", :enter)
+    refute @editor.get_option("number")
+  end
+
+  def test_set_tabstop_value
+    feed(":", "s", "e", "t", " ", "t", "a", "b", "s", "t", "o", "p", "=", "8", :enter)
+    assert_equal 8, @editor.get_option("tabstop")
+  end
+
+  def test_set_option_query
+    feed(":", "s", "e", "t", " ", "n", "u", "m", "b", "e", "r", "?", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- :bindings ---
+
+  def test_bindings_command
+    feed(":", "b", "i", "n", "d", "i", "n", "g", "s", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_bindings_with_mode_filter
+    feed(":", "b", "i", "n", "d", "i", "n", "g", "s", " ", "n", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- :tabnew / :tabnext / :tabprev ---
+
+  def test_tabnext_tabprev_via_ex
+    feed(":", "t", "a", "b", "n", "e", "w", :enter)
+    feed(":", "t", "a", "b", "p", "r", "e", "v", :enter)
+    feed(":", "t", "a", "b", "n", "e", "x", "t", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- :bnext / :bprev ---
+
+  def test_bnext_bprev_via_ex
+    feed(":", "b", "n", "e", "x", "t", :enter)
+    feed(":", "b", "p", "r", "e", "v", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- :copen / :cclose / :cprev / :lclose / :lprev ---
+
+  def test_copen_and_cclose
+    feed(":", "c", "o", "p", "e", "n", :enter)
+    feed(":", "c", "c", "l", "o", "s", "e", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_cprev_with_empty_list
+    feed(":", "c", "p", "r", "e", "v", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_lclose_without_open
+    feed(":", "l", "c", "l", "o", "s", "e", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_lprev_with_empty_list
+    feed(":", "l", "p", "r", "e", "v", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- :args ---
+
+  def test_arglist_operations
+    feed(":", "a", "r", "g", "s", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- :wq ---
+
+  def test_wq_with_no_filename_shows_error
+    feed(":", "w", "q", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- :edit ---
+
+  def test_edit_no_file_reloads_or_errors
+    feed(":", "e", "d", "i", "t", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- :split / :vsplit + window focus ---
+
+  def test_window_focus_after_split
+    feed(":", "s", "p", "l", "i", "t", :enter)
+    original_win_id = @editor.current_window.id
+
+    feed(:ctrl_w, "w")
+    refute_equal original_win_id, @editor.current_window.id
+
+    feed(:ctrl_w, "j")
+    feed(:ctrl_w, "k")
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_window_focus_left_right
+    feed(":", "v", "s", "p", "l", "i", "t", :enter)
+    feed(:ctrl_w, "h")
+    feed(:ctrl_w, "l")
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- :b# (alternate buffer) ---
+
+  def test_buffer_alternate_hash
+    feed(":", "s", "p", "l", "i", "t", :enter)
+    feed(":", "b", "#", :enter)
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- rich view toggle ---
+
+  def test_rich_toggle
+    buf.replace_all_lines!(["hello world"])
+    feed("g", "r")
+    assert_equal :normal, @editor.mode
+  end
+end

data/test/app_motion_test.rb

@@ -4,11 +4,12 @@ class AppMotionTest < 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!
   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_find_char_and_repeat
@@ -59,14 +60,14 @@ class AppMotionTest < Minitest::Test
 
     @editor.current_window_view_height_hint = 5
 
-    @app.send(:handle_normal_key, :pagedown)
+    @key_handler.send(:handle_normal_key, :pagedown)
     assert_equal 4, @editor.current_window.cursor_y
 
     @editor.pending_count = 2
-    @app.send(:handle_normal_key, :pagedown)
+    @key_handler.send(:handle_normal_key, :pagedown)
     assert_equal 12, @editor.current_window.cursor_y
 
-    @app.send(:handle_normal_key, :pageup)
+    @key_handler.send(:handle_normal_key, :pageup)
     assert_equal 8, @editor.current_window.cursor_y
   end
 
@@ -78,16 +79,16 @@ class AppMotionTest < Minitest::Test
 
     @editor.current_window_view_height_hint = 10
 
-    @app.send(:handle_normal_key, :ctrl_d)
+    @key_handler.send(:handle_normal_key, :ctrl_d)
     assert_equal 5, @editor.current_window.cursor_y
 
-    @app.send(:handle_normal_key, :ctrl_u)
+    @key_handler.send(:handle_normal_key, :ctrl_u)
     assert_equal 0, @editor.current_window.cursor_y
 
-    @app.send(:handle_normal_key, :ctrl_f)
+    @key_handler.send(:handle_normal_key, :ctrl_f)
     assert_equal 9, @editor.current_window.cursor_y
 
-    @app.send(:handle_normal_key, :ctrl_b)
+    @key_handler.send(:handle_normal_key, :ctrl_b)
     assert_equal 0, @editor.current_window.cursor_y
   end
 
@@ -100,11 +101,11 @@ class AppMotionTest < Minitest::Test
 
     @editor.current_window_view_height_hint = 10
 
-    @app.send(:handle_normal_key, :ctrl_e)
+    @key_handler.send(:handle_normal_key, :ctrl_e)
     assert_equal 6, @editor.current_window.row_offset
     assert_equal 6, @editor.current_window.cursor_y
 
-    @app.send(:handle_normal_key, :ctrl_y)
+    @key_handler.send(:handle_normal_key, :ctrl_y)
     assert_equal 5, @editor.current_window.row_offset
     assert_equal 6, @editor.current_window.cursor_y
   end
@@ -118,7 +119,7 @@ class AppMotionTest < Minitest::Test
     keymaps = @app.instance_variable_get(:@keymaps)
     keymaps.bind(:normal, ["<C-d>"], "cursor.down")
 
-    @app.send(:handle_normal_key, :ctrl_d)
+    @key_handler.send(:handle_normal_key, :ctrl_d)
     assert_equal 1, @editor.current_window.cursor_y
   end
 
@@ -131,7 +132,7 @@ class AppMotionTest < Minitest::Test
     keymaps = @app.instance_variable_get(:@keymaps)
     keymaps.bind(:normal, ["<PageDown>"], "cursor.down")
 
-    @app.send(:handle_normal_key, :pagedown)
+    @key_handler.send(:handle_normal_key, :pagedown)
     assert_equal 1, @editor.current_window.cursor_y
   end
 

data/test/app_register_test.rb

@@ -4,12 +4,13 @@ class AppRegisterTest < 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
   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_yy_updates_register_zero

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)
 
@@ -709,9 +714,9 @@ class AppScenarioTest < Minitest::Test
     @editor.current_window.cursor_y = 0
     @editor.current_window.cursor_x = 0
     feed("A")
-    @app.instance_variable_set(:@paste_batch, true)
+    @app.instance_variable_get(:@key_handler).paste_batch = true
     feed(:enter, *"world".chars)
-    @app.instance_variable_set(:@paste_batch, false)
+    @app.instance_variable_get(:@key_handler).paste_batch = false
     feed(:escape)
 
     assert_equal ["  hello", "world"], @editor.current_buffer.lines

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")