ruvim 0.3.0 → 0.6.0

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

data/test/follow_test.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "tempfile"
+
+class FollowTest < Minitest::Test
+  def create_follow_app
+    @tmpfile = Tempfile.new(["follow_test", ".txt"])
+    @tmpfile.write("line1\nline2\n")
+    @tmpfile.flush
+    @path = @tmpfile.path
+
+    @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
+
+    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")
+    buf = @editor.current_buffer
+
+    assert !@editor.message_error?, "Unexpected error: #{@editor.message}"
+    assert_equal :live, buf.stream.state
+    assert buf.stream.watcher
+    assert_includes @editor.message.to_s, "[follow]"
+  ensure
+    cleanup_follow_app
+  end
+
+  def test_follow_stops_on_ctrl_c
+    create_follow_app
+    @dispatcher.dispatch_ex(@editor, "follow")
+    buf = @editor.current_buffer
+    assert_equal :live, buf.stream.state
+
+    @key_handler.handle(:ctrl_c)
+    assert_nil buf.stream
+    assert_includes @editor.message.to_s, "stopped"
+  ensure
+    cleanup_follow_app
+  end
+
+  def test_follow_toggle_stops
+    create_follow_app
+    @dispatcher.dispatch_ex(@editor, "follow")
+    buf = @editor.current_buffer
+    assert_equal :live, buf.stream.state
+
+    @dispatcher.dispatch_ex(@editor, "follow")
+    assert_nil buf.stream
+    assert_includes @editor.message.to_s, "stopped"
+  ensure
+    cleanup_follow_app
+  end
+
+  def test_follow_stop_removes_sentinel_empty_line
+    create_follow_app
+    buf = @editor.current_buffer
+    lines_before = buf.line_count
+
+    @dispatcher.dispatch_ex(@editor, "follow")
+    @dispatcher.dispatch_ex(@editor, "follow")
+
+    assert_equal lines_before, buf.line_count, "Sentinel empty line should be removed on stop"
+    refute_equal "", buf.lines.last, "Last line should not be empty sentinel"
+  ensure
+    cleanup_follow_app
+  end
+
+  def test_follow_makes_buffer_not_modifiable
+    create_follow_app
+    buf = @editor.current_buffer
+    assert buf.modifiable?
+
+    @dispatcher.dispatch_ex(@editor, "follow")
+    refute buf.modifiable?, "Buffer should not be modifiable during follow"
+
+    @dispatcher.dispatch_ex(@editor, "follow")
+    assert buf.modifiable?, "Buffer should be modifiable after follow stops"
+  ensure
+    cleanup_follow_app
+  end
+
+  def test_follow_error_on_modified_buffer
+    create_follow_app
+    buf = @editor.current_buffer
+    buf.modified = true
+
+    @dispatcher.dispatch_ex(@editor, "follow")
+    assert_includes @editor.message.to_s, "unsaved changes"
+    assert_nil buf.stream
+  ensure
+    cleanup_follow_app
+  end
+
+  def test_follow_error_on_no_path_buffer
+    @app = RuVim::App.new(clean: true)
+    @editor = @app.instance_variable_get(:@editor)
+    @dispatcher = @app.instance_variable_get(:@dispatcher)
+    @editor.materialize_intro_buffer!
+    buf = @editor.current_buffer
+    buf.instance_variable_set(:@path, nil)
+
+    @dispatcher.dispatch_ex(@editor, "follow")
+    assert_includes @editor.message.to_s, "No file"
+  end
+
+  def test_follow_appends_data_from_file
+    create_follow_app
+    win = @editor.current_window
+    buf = @editor.current_buffer
+    win.cursor_y = buf.line_count - 1
+
+    @dispatcher.dispatch_ex(@editor, "follow")
+
+    File.open(@path, "a") { |f| f.write("line3\nline4\n") }
+
+    assert_eventually(timeout: 3) do
+      @stream_mixer.drain_events!
+      buf.line_count > 3
+    end
+
+    # line2 should NOT be joined with line3
+    assert_includes buf.lines, "line2"
+    assert_includes buf.lines, "line3"
+    assert_includes buf.lines, "line4"
+    assert_equal buf.line_count - 1, win.cursor_y
+  ensure
+    cleanup_follow_app
+  end
+
+  def test_follow_no_scroll_when_cursor_not_at_end
+    create_follow_app
+    buf = @editor.current_buffer
+    win = @editor.current_window
+    win.cursor_y = 0
+
+    @dispatcher.dispatch_ex(@editor, "follow")
+
+    File.open(@path, "a") { |f| f.write("line3\n") }
+
+    assert_eventually(timeout: 3) do
+      @stream_mixer.drain_events!
+      buf.line_count > 2
+    end
+
+    assert_equal 0, win.cursor_y
+  ensure
+    cleanup_follow_app
+  end
+
+  def test_startup_follow_applies_to_all_buffers
+    tmp1 = Tempfile.new(["follow_multi1", ".txt"])
+    tmp1.write("aaa\n"); tmp1.flush
+    tmp2 = Tempfile.new(["follow_multi2", ".txt"])
+    tmp2.write("bbb\n"); tmp2.flush
+
+    app = RuVim::App.new(paths: [tmp1.path, tmp2.path], follow: true, clean: true)
+    editor = app.instance_variable_get(:@editor)
+    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 buf.stream.watcher, "#{buf.display_name} should have a watcher"
+    end
+  ensure
+    bufs&.each { |b| b.stream&.stop! rescue nil }
+    tmp1&.close!
+    tmp2&.close!
+  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

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