ruvim 0.2.0 → 0.4.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,199 @@
+# 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)
+  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
+    @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_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
+
+    @app.send(:handle_key, :ctrl_c)
+    assert_nil buf.stream_state
+    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")
+    watchers = @app.instance_variable_get(:@follow_watchers)
+    assert_nil buf.stream_state
+    refute watchers.key?(buf.id)
+    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_state
+  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
+      @app.send(:drain_stream_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
+      @app.send(:drain_stream_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)
+    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"
+    end
+  ensure
+    watchers&.each_value { |w| w.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