ruvim 0.3.0 → 0.4.0

data/lib/ruvim/app.rb

@@ -2,6 +2,7 @@
 
 require "json"
 require "fileutils"
+require_relative "file_watcher"
 
 module RuVim
   class App
@@ -10,7 +11,7 @@ module RuVim
     ASYNC_FILE_READ_CHUNK_BYTES = 1 * 1024 * 1024
     ASYNC_FILE_EVENT_FLUSH_BYTES = 4 * 1024 * 1024
 
-    def initialize(path: nil, paths: nil, stdin: STDIN, ui_stdin: nil, stdin_stream_mode: false, stdout: STDOUT, pre_config_actions: [], startup_actions: [], clean: false, skip_user_config: false, config_path: nil, readonly: false, diff_mode: false, quickfix_errorfile: nil, session_file: nil, nomodifiable: false, restricted: false, verbose_level: 0, verbose_io: STDERR, startup_time_path: nil, startup_open_layout: nil, startup_open_count: nil)
+    def initialize(path: nil, paths: nil, stdin: STDIN, ui_stdin: nil, stdin_stream_mode: false, stdout: STDOUT, pre_config_actions: [], startup_actions: [], clean: false, skip_user_config: false, config_path: nil, readonly: false, diff_mode: false, quickfix_errorfile: nil, session_file: nil, nomodifiable: false, follow: false, restricted: false, verbose_level: 0, verbose_io: STDERR, startup_time_path: nil, startup_open_layout: nil, startup_open_count: nil)
       startup_paths = Array(paths || path).compact
       @ui_stdin = ui_stdin || stdin
       @stdin_stream_mode = !!stdin_stream_mode
@@ -27,6 +28,7 @@ module RuVim
       @stream_buffer_id = nil
       @stream_stop_requested = false
       @async_file_loads = {}
+      @follow_watchers = {}
       @cmdline_history = Hash.new { |h, k| h[k] = [] }
       @cmdline_history_index = nil
       @cmdline_completion = nil
@@ -43,6 +45,7 @@ module RuVim
       @startup_quickfix_errorfile = quickfix_errorfile
       @startup_session_file = session_file
       @startup_nomodifiable = nomodifiable
+      @startup_follow = follow
       @restricted_mode = restricted
       @verbose_level = verbose_level.to_i
       @verbose_io = verbose_io
@@ -56,6 +59,8 @@ module RuVim
       @editor.open_path_handler = method(:open_path_with_large_file_support)
       @editor.keymap_manager = @keymaps
       @editor.app_action_handler = method(:handle_editor_app_action)
+      @editor.git_stream_handler = method(:start_git_stream_command)
+      @editor.git_stream_stop_handler = method(:stop_git_stream!)
       load_command_line_history!
 
       startup_mark("init.start")
@@ -119,10 +124,17 @@ module RuVim
           @needs_redraw = true
 
           # Batch insert-mode keystrokes to avoid per-char rendering during paste
-          while @editor.mode == :insert && @input.has_pending_input?
-            batch_key = @input.read_key(timeout: 0, esc_timeout: 0)
-            break unless batch_key
-            handle_key(batch_key)
+          if @editor.mode == :insert && @input.has_pending_input?
+            @paste_batch = true
+            begin
+              while @editor.mode == :insert && @input.has_pending_input?
+                batch_key = @input.read_key(timeout: 0, esc_timeout: 0)
+                break unless batch_key
+                handle_key(batch_key)
+              end
+            ensure
+              @paste_batch = false
+            end
           end
         end
       end
@@ -352,10 +364,27 @@ module RuVim
       register_ex_unless(ex, "d", call: :ex_delete_lines, aliases: %w[delete], desc: "Delete lines", nargs: :any)
       register_ex_unless(ex, "y", call: :ex_yank_lines, aliases: %w[yank], desc: "Yank lines", nargs: :any)
       register_ex_unless(ex, "rich", call: :ex_rich, desc: "Open/close Rich View", nargs: :maybe_one)
+      register_ex_unless(ex, "follow", call: ->(ctx, **) { ctx.editor.invoke_app_action(:follow_toggle) }, desc: "Toggle file follow mode", nargs: 0)
+      register_ex_unless(ex, "nohlsearch", call: ->(ctx, **) { ctx.editor.suppress_hlsearch! }, aliases: %w[noh nohl nohlsearc nohlsear nohlsea nohlse nohls], desc: "Temporarily clear search highlight", nargs: 0)
+      register_ex_unless(ex, "filter", call: :ex_filter, desc: "Filter lines matching search pattern", nargs: :any)
+      register_internal_unless(cmd, "search.filter", call: :search_filter, desc: "Filter lines matching search pattern")
       register_internal_unless(cmd, "rich.toggle", call: :rich_toggle, desc: "Toggle Rich View")
+      register_internal_unless(cmd, "rich.close_buffer", call: :rich_view_close_buffer, desc: "Close rich view buffer")
       register_internal_unless(cmd, "quickfix.next", call: :ex_cnext, desc: "Next quickfix item")
       register_internal_unless(cmd, "quickfix.prev", call: :ex_cprev, desc: "Prev quickfix item")
       register_internal_unless(cmd, "quickfix.open", call: :ex_copen, desc: "Open quickfix list")
+
+      register_internal_unless(cmd, "git.blame", call: :git_blame, desc: "Open git blame buffer")
+      register_internal_unless(cmd, "git.blame.prev", call: :git_blame_prev, desc: "Blame at parent commit")
+      register_internal_unless(cmd, "git.blame.back", call: :git_blame_back, desc: "Restore previous blame")
+      register_internal_unless(cmd, "git.blame.commit", call: :git_blame_commit, desc: "Show commit details")
+      register_internal_unless(cmd, "git.command_mode", call: :enter_git_command_mode, desc: "Enter Git command-line mode")
+      register_internal_unless(cmd, "git.close_buffer", call: :git_close_buffer, desc: "Close git buffer")
+      register_internal_unless(cmd, "git.status.open_file", call: :git_status_open_file, desc: "Open file from git status")
+      register_internal_unless(cmd, "git.diff.open_file", call: :git_diff_open_file, desc: "Open file from git diff")
+      register_internal_unless(cmd, "git.branch.checkout", call: :git_branch_checkout, desc: "Checkout branch under cursor")
+      register_internal_unless(cmd, "git.commit.execute", call: :git_commit_execute, desc: "Execute git commit")
+      register_ex_unless(ex, "git", call: :ex_git, desc: "Git subcommand dispatcher", nargs: :any)
     end
 
     def bind_default_keys!
@@ -448,6 +477,8 @@ module RuVim
       @keymaps.bind(:normal, "g#", "search.word_backward_partial")
       @keymaps.bind(:normal, "gf", "file.goto_under_cursor")
       @keymaps.bind(:normal, "gr", "rich.toggle")
+      @keymaps.bind(:normal, "g/", "search.filter")
+      @keymaps.bind(:normal, ["<C-g>"], "git.command_mode")
       @keymaps.bind(:normal, "Q", "quickfix.open")
       @keymaps.bind(:normal, ["]", "q"], "quickfix.next")
       @keymaps.bind(:normal, ["[", "q"], "quickfix.prev")
@@ -541,6 +572,8 @@ module RuVim
           linewise: !!(kwargs[:linewise] || kwargs["linewise"]),
           repeat_token: (kwargs[:repeat_token] || kwargs["repeat_token"]).to_s
         )
+      when :follow_toggle
+        ex_follow_toggle
       else
         raise RuVim::CommandError, "Unknown app action: #{name}"
       end
@@ -844,6 +877,10 @@ module RuVim
 
     def handle_list_window_enter
       buffer = @editor.current_buffer
+      return handle_filter_buffer_enter if buffer.kind == :filter
+      return handle_git_status_enter if buffer.kind == :git_status
+      return handle_git_diff_enter if buffer.kind == :git_diff || buffer.kind == :git_log
+      return handle_git_branch_enter if buffer.kind == :git_branch
       return false unless buffer.kind == :quickfix || buffer.kind == :location_list
 
       item_index = @editor.current_window.cursor_y - 2
@@ -885,6 +922,47 @@ module RuVim
       true
     end
 
+    def handle_filter_buffer_enter
+      buffer = @editor.current_buffer
+      origins = buffer.options["filter_origins"]
+      return false unless origins
+
+      row = @editor.current_window.cursor_y
+      origin = origins[row]
+      unless origin
+        @editor.echo_error("No filter item on this line")
+        return true
+      end
+
+      target_buffer_id = origin[:buffer_id]
+      target_row = origin[:row]
+      filter_buf_id = buffer.id
+
+      @editor.delete_buffer(filter_buf_id)
+      target_buf = @editor.buffers[target_buffer_id]
+      if target_buf
+        @editor.switch_to_buffer(target_buffer_id) unless @editor.current_buffer.id == target_buffer_id
+        @editor.current_window.cursor_y = [target_row, target_buf.lines.length - 1].min
+        @editor.current_window.cursor_x = 0
+      end
+      true
+    end
+
+    def handle_git_status_enter
+      @dispatcher.dispatch(@editor, CommandInvocation.new(id: "git.status.open_file"))
+      true
+    end
+
+    def handle_git_diff_enter
+      @dispatcher.dispatch(@editor, CommandInvocation.new(id: "git.diff.open_file"))
+      true
+    end
+
+    def handle_git_branch_enter
+      @dispatcher.dispatch(@editor, CommandInvocation.new(id: "git.branch.checkout"))
+      true
+    end
+
     def arrow_key?(key)
       %i[left right up down].include?(key)
     end
@@ -946,6 +1024,7 @@ module RuVim
       when :ctrl_w then "<C-w>"
       when :ctrl_l then "<C-l>"
       when :ctrl_c then "<C-c>"
+      when :ctrl_g then "<C-g>"
       when :left then "<Left>"
       when :right then "<Right>"
       when :up then "<Up>"
@@ -1072,7 +1151,12 @@ module RuVim
       @jump_pending = nil
       @macro_record_pending = false
       @macro_play_pending = false
-      @editor.clear_message
+      buf = @editor.current_buffer
+      if buf && @follow_watchers[buf.id]
+        stop_follow!(buf)
+      else
+        @editor.clear_message
+      end
     end
 
     def suspend_to_shell
@@ -1290,7 +1374,7 @@ module RuVim
 
     def handle_operator_pending_key(token)
       op = @operator_pending
-      if %w[i a].include?(token) && !op[:motion_prefix]
+      if %w[i a g].include?(token) && !op[:motion_prefix]
         @operator_pending[:motion_prefix] = token
         @editor.echo("#{op[:name].to_s[0]}#{token}")
         return
@@ -1846,6 +1930,7 @@ module RuVim
     end
 
     def apply_insert_autoindent(row, x, previous_row:)
+      return x if @paste_batch
       buf = @editor.current_buffer
       win = @editor.current_window
       return x unless @editor.effective_option("autoindent", window: win, buffer: buf)
@@ -2307,6 +2392,10 @@ module RuVim
         return option_completion_candidates(prefix)
       end
 
+      if cmd == "git"
+        return Git::Handler::GIT_SUBCOMMANDS.keys.sort.select { |s| s.start_with?(prefix) }
+      end
+
       []
     end
 
@@ -2492,6 +2581,17 @@ module RuVim
       @editor.echo("readonly: #{buf.display_name}")
     end
 
+    def apply_startup_follow!
+      buf = @editor.current_buffer
+      return unless buf&.file_buffer?
+      return if @follow_watchers[buf.id]
+
+      win = @editor.current_window
+      win.cursor_y = buf.line_count - 1
+      win.clamp_to_buffer(buf)
+      start_follow!(buf)
+    end
+
     def apply_startup_nomodifiable!
       buf = @editor.current_buffer
       return unless buf&.file_buffer?
@@ -2533,6 +2633,7 @@ module RuVim
       @editor.open_path(first)
       apply_startup_readonly! if @startup_readonly
       apply_startup_nomodifiable! if @startup_nomodifiable
+      apply_startup_follow! if @startup_follow
 
       case @startup_open_layout
       when :horizontal
@@ -2548,7 +2649,10 @@ module RuVim
         @editor.tabnext(-(@editor.tabpage_count - 1))
       else
         # Load remaining files as buffers (Vim-like behavior).
-        rest.each { |p| @editor.add_buffer_from_file(p) }
+        rest.each do |p|
+          buf = @editor.add_buffer_from_file(p)
+          start_follow!(buf) if @startup_follow
+        end
       end
     end
 
@@ -2570,12 +2674,14 @@ module RuVim
       @editor.open_path(path)
       apply_startup_readonly! if @startup_readonly
       apply_startup_nomodifiable! if @startup_nomodifiable
+      apply_startup_follow! if @startup_follow
     end
 
     def open_path_in_tab!(path)
       @editor.tabnew(path:)
       apply_startup_readonly! if @startup_readonly
       apply_startup_nomodifiable! if @startup_nomodifiable
+      apply_startup_follow! if @startup_follow
     end
 
     def open_path_with_large_file_support(path)
@@ -2808,12 +2914,30 @@ module RuVim
           end
           @editor.echo_error("[stdin] stream error: #{event[:error]}")
           changed = true
+        when :follow_data
+          changed = apply_follow_chunk!(event[:buffer_id], event[:data]) || changed
+        when :follow_truncated
+          if (buf = @editor.buffers[event[:buffer_id]])
+            @editor.echo("[follow] file truncated: #{buf.display_name}")
+            changed = true
+          end
+        when :follow_deleted
+          if (buf = @editor.buffers[event[:buffer_id]])
+            @editor.echo("[follow] file deleted, waiting for re-creation: #{buf.display_name}")
+            changed = true
+          end
         when :file_data
           changed = apply_async_file_chunk!(event[:buffer_id], event[:data]) || changed
         when :file_eof
           changed = finish_async_file_load!(event[:buffer_id], ended_with_newline: event[:ended_with_newline]) || changed
         when :file_error
           changed = fail_async_file_load!(event[:buffer_id], event[:error]) || changed
+        when :git_cmd_data
+          changed = apply_git_stream_chunk!(event[:buffer_id], event[:data]) || changed
+        when :git_cmd_eof
+          changed = finish_git_stream!(event[:buffer_id]) || changed
+        when :git_cmd_error
+          changed = fail_git_stream!(event[:buffer_id], event[:error]) || changed
         end
       end
     rescue ThreadError
@@ -2902,6 +3026,99 @@ module RuVim
       nil
     end
 
+    def ex_follow_toggle
+      buf = @editor.current_buffer
+      raise RuVim::CommandError, "No file associated with buffer" unless buf.path
+
+      if @follow_watchers[buf.id]
+        stop_follow!(buf)
+      else
+        raise RuVim::CommandError, "Buffer has unsaved changes" if buf.modified?
+        start_follow!(buf)
+      end
+    end
+
+    def start_follow!(buf)
+      ensure_stream_event_queue!
+      if buf.path && File.exist?(buf.path)
+        data = File.binread(buf.path)
+        if data.end_with?("\n") && buf.lines.last.to_s != ""
+          following_wins = @editor.windows.values.select do |w|
+            w.buffer_id == buf.id && stream_window_following_end?(w, buf)
+          end
+          buf.append_stream_text!("\n")
+          following_wins.each { |w| move_window_to_stream_end!(w, buf) }
+        end
+      end
+      buffer_id = buf.id
+      watcher = FileWatcher.create(buf.path) do |type, data|
+        case type
+        when :data
+          @stream_event_queue << { type: :follow_data, buffer_id: buffer_id, data: data }
+        when :truncated
+          @stream_event_queue << { type: :follow_truncated, buffer_id: buffer_id }
+        when :deleted
+          @stream_event_queue << { type: :follow_deleted, buffer_id: buffer_id }
+        end
+        notify_signal_wakeup
+      end
+      watcher.start
+      @follow_watchers[buf.id] = watcher
+      buf.stream_state = :live
+      buf.follow_backend = watcher.backend
+      @editor.echo("[follow] #{buf.display_name}")
+    end
+
+    def stop_follow!(buf)
+      watcher = @follow_watchers.delete(buf.id)
+      watcher&.stop
+      # Remove trailing empty line added as sentinel by start_follow!
+      if buf.line_count > 1 && buf.lines.last.to_s == ""
+        buf.lines.pop
+        last = buf.line_count - 1
+        @editor.windows.each_value do |win|
+          next unless win.buffer_id == buf.id
+          win.cursor_y = last if win.cursor_y > last
+        end
+      end
+      buf.stream_state = nil
+      buf.follow_backend = nil
+      @editor.echo("[follow] stopped")
+    end
+
+    def apply_follow_chunk!(buffer_id, text)
+      return false if text.to_s.empty?
+
+      buf = @editor.buffers[buffer_id]
+      return false unless buf
+
+      follow_window_ids = @editor.windows.values.filter_map do |win|
+        next unless win.buffer_id == buf.id
+        next unless stream_window_following_end?(win, buf)
+
+        win.id
+      end
+
+      buf.append_stream_text!(text)
+
+      follow_window_ids.each do |win_id|
+        win = @editor.windows[win_id]
+        move_window_to_stream_end!(win, buf) if win
+      end
+
+      true
+    end
+
+    def shutdown_follow_watchers!
+      watchers = @follow_watchers
+      @follow_watchers = {}
+      watchers.each_value do |watcher|
+        watcher.stop
+      rescue StandardError
+        nil
+      end
+    end
+
     def shutdown_async_file_loaders!
       loaders = @async_file_loads
       @async_file_loads = {}
@@ -2924,6 +3141,7 @@ module RuVim
 
     def shutdown_background_readers!
       shutdown_stream_reader!
+      shutdown_follow_watchers!
       shutdown_async_file_loaders!
     end
 
@@ -2940,6 +3158,70 @@ module RuVim
       @stream_event_queue ||= Queue.new
     end
 
+    def apply_git_stream_chunk!(buffer_id, text)
+      return false if text.to_s.empty?
+
+      buf = @editor.buffers[buffer_id]
+      return false unless buf
+
+      buf.append_stream_text!(text)
+      true
+    end
+
+    def finish_git_stream!(buffer_id)
+      @git_stream_ios&.delete(buffer_id)
+      @git_stream_threads&.delete(buffer_id)
+      buf = @editor.buffers[buffer_id]
+      return false unless buf
+
+      # Remove trailing empty line if present
+      if buf.lines.length > 1 && buf.lines[-1] == ""
+        buf.lines.pop
+      end
+      line_count = buf.line_count
+      @editor.echo("#{buf.name} #{line_count} lines")
+      true
+    end
+
+    def fail_git_stream!(buffer_id, error)
+      @git_stream_ios&.delete(buffer_id)
+      @git_stream_threads&.delete(buffer_id)
+      buf = @editor.buffers[buffer_id]
+      @editor.echo_error("git stream error: #{error}") if buf
+      true
+    end
+
+    def start_git_stream_command(buffer_id, cmd, root)
+      ensure_stream_event_queue!
+      @git_stream_ios ||= {}
+      @git_stream_threads ||= {}
+      queue = @stream_event_queue
+      ios = @git_stream_ios
+      @git_stream_threads[buffer_id] = Thread.new do
+        IO.popen(cmd, chdir: root, err: [:child, :out]) do |io|
+          ios[buffer_id] = io
+          while (chunk = io.read(4096))
+            queue << { type: :git_cmd_data, buffer_id: buffer_id, data: Buffer.decode_text(chunk) }
+            notify_signal_wakeup
+          end
+        end
+        ios.delete(buffer_id)
+        queue << { type: :git_cmd_eof, buffer_id: buffer_id }
+        notify_signal_wakeup
+      rescue StandardError => e
+        ios.delete(buffer_id)
+        queue << { type: :git_cmd_error, buffer_id: buffer_id, error: e.message.to_s }
+        notify_signal_wakeup
+      end
+    end
+
+    def stop_git_stream!(buffer_id)
+      io = @git_stream_ios&.delete(buffer_id)
+      io&.close
+    rescue IOError
+      # already closed
+    end
+
     def move_cursor_to_line(line_number)
       win = @editor.current_window
       buf = @editor.current_buffer

data/lib/ruvim/buffer.rb

@@ -6,7 +6,19 @@ module RuVim
     attr_accessor :path
     attr_reader :options
     attr_writer :modified
-    attr_accessor :stream_state, :loading_state
+    attr_accessor :stream_state, :loading_state, :follow_backend
+
+    def stream_status
+      return nil unless @stream_state
+
+      if @kind == :stream
+        "stdin/#{@stream_state}"
+      elsif @follow_backend == :inotify
+        "follow/i"
+      else
+        "follow"
+      end
+    end
     attr_accessor :lang_module
 
     def self.from_file(id:, path:)
@@ -87,7 +99,7 @@ module RuVim
     end
 
     def modifiable?
-      @modifiable && @loading_state != :live
+      @modifiable && @loading_state != :live && @stream_state != :live
     end
 
     def modifiable=(value)

data/lib/ruvim/cli.rb

@@ -16,6 +16,7 @@ module RuVim
       :no_swap,
       :nomodifiable,
       :restricted_mode,
+      :follow,
       :verbose_level,
       :startup_time_path,
       :startup_open_layout,
@@ -70,6 +71,7 @@ module RuVim
         quickfix_errorfile: opts.quickfix_errorfile,
         session_file: opts.session_file,
         nomodifiable: opts.nomodifiable,
+        follow: opts.follow,
         restricted: opts.restricted_mode,
         verbose_level: opts.verbose_level,
         verbose_io: stderr,
@@ -101,6 +103,7 @@ module RuVim
         no_swap: false,
         nomodifiable: false,
         restricted_mode: false,
+        follow: false,
         verbose_level: 0,
         startup_time_path: nil,
         startup_open_layout: nil,
@@ -159,6 +162,8 @@ module RuVim
           end
         when "-n"
           opts.no_swap = true
+        when "-f"
+          opts.follow = true
         when "-M"
           opts.nomodifiable = true
         when "-Z"
@@ -240,6 +245,7 @@ module RuVim
           -h, --help        Show this help
           -v, --version     Show version
           --clean           Start without user config and ftplugin
+          -f                Open file in follow mode (tail -f style)
           -R                Open file readonly (disallow :w on current buffer)
           -d                Diff mode requested (compat placeholder; not implemented yet)
           -q {errorfile}    Quickfix startup placeholder (not implemented yet)

data/lib/ruvim/editor.rb

@@ -71,7 +71,7 @@ module RuVim
     ].freeze
 
     attr_reader :buffers, :windows, :layout_tree
-    attr_accessor :current_window_id, :mode, :message, :pending_count, :alternate_buffer_id, :restricted_mode, :current_window_view_height_hint, :stdin_stream_stop_handler, :open_path_handler, :keymap_manager, :app_action_handler
+    attr_accessor :current_window_id, :mode, :message, :pending_count, :alternate_buffer_id, :restricted_mode, :current_window_view_height_hint, :stdin_stream_stop_handler, :open_path_handler, :keymap_manager, :app_action_handler, :git_stream_handler, :git_stream_stop_handler
 
     def initialize
       @buffers = {}
@@ -100,6 +100,7 @@ module RuVim
       @global_options = default_global_options
       @command_line = CommandLine.new
       @last_search = nil
+      @hlsearch_suppressed = false
       @last_find = nil
       @registers = {}
       @active_register_name = nil
@@ -152,6 +153,15 @@ module RuVim
 
     def set_last_search(pattern:, direction:)
       @last_search = { pattern: pattern.to_s, direction: direction.to_sym }
+      @hlsearch_suppressed = false
+    end
+
+    def suppress_hlsearch!
+      @hlsearch_suppressed = true
+    end
+
+    def hlsearch_suppressed?
+      @hlsearch_suppressed
     end
 
     def set_last_find(char:, direction:, till:)
@@ -266,6 +276,7 @@ module RuVim
         ".tsx" => "typescriptreact",
         ".jsx" => "javascriptreact",
         ".json" => "json",
+        ".jsonl" => "jsonl",
         ".yml" => "yaml",
         ".yaml" => "yaml",
         ".md" => "markdown",