ruvim 0.4.0 → 0.6.0

data/lib/ruvim/stream.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuVim
+  class Stream
+    attr_accessor :state
+    attr_reader :stop_handler
+
+    def initialize(stop_handler: nil)
+      @state = nil
+      @stop_handler = stop_handler
+    end
+
+    def live?
+      @state == :live
+    end
+
+    def status
+      nil
+    end
+
+    def command
+      nil
+    end
+
+    def stop!
+      # subclasses override
+    end
+  end
+end
+
+require_relative "stream/stdin"
+require_relative "stream/run"
+require_relative "stream/follow"
+require_relative "stream/file_load"
+require_relative "stream/git"

data/lib/ruvim/stream_mixer.rb

@@ -0,0 +1,394 @@
+# frozen_string_literal: true
+
+module RuVim
+  class StreamMixer
+      LARGE_FILE_ASYNC_THRESHOLD_BYTES = 64 * 1024 * 1024
+      LARGE_FILE_STAGED_PREFIX_BYTES = 8 * 1024 * 1024
+
+      def initialize(editor:, signal_w:)
+        @editor = editor
+        @signal_w = signal_w
+        @stream_event_queue = nil
+      end
+
+      def prepare_stdin_stream_buffer!(io)
+        buf = @editor.current_buffer
+        if buf.intro_buffer?
+          @editor.materialize_intro_buffer!
+          buf = @editor.current_buffer
+        end
+
+        buf.replace_all_lines!([""])
+        buf.configure_special!(kind: :stream, name: "[stdin]", readonly: true, modifiable: false)
+        buf.modified = false
+        buf.options["filetype"] = "text"
+        ensure_event_queue!
+        move_window_to_stream_end!(@editor.current_window, buf)
+        @editor.echo("[stdin] follow")
+        @pending_stdin = { buf: buf, io: io }
+        buf
+      end
+
+      def start_pending_stdin!
+        return unless @pending_stdin
+
+        ps = @pending_stdin
+        @pending_stdin = nil
+        buf = ps[:buf]
+        ensure_event_queue!
+        buf.stream = Stream::Stdin.new(
+          io: ps[:io], buffer_id: buf.id, queue: @stream_event_queue,
+          stop_handler: -> { stop_buffer_stream!(buf) }, &method(:notify_signal_wakeup)
+        )
+      end
+
+      def start_command_stream!(buf, command)
+        ensure_event_queue!
+        buf.stream = Stream::Run.new(
+          command: command, buffer_id: buf.id, queue: @stream_event_queue,
+          stop_handler: -> { stop_buffer_stream!(buf) }, &method(:notify_signal_wakeup)
+        )
+      end
+
+      def start_git_stream_command(buffer_id, cmd, root)
+        ensure_event_queue!
+        buf = @editor.buffers[buffer_id]
+        return unless buf
+
+        buf.stream = Stream::Git.new(cmd: cmd, root: root, buffer_id: buffer_id, queue: @stream_event_queue, &method(:notify_signal_wakeup))
+      end
+
+      def stop_buffer_stream!(buf)
+        return false unless buf&.stream&.live?
+
+        buf.stream.stop!
+        @editor.echo("#{buf.display_name} stopped")
+        notify_signal_wakeup
+        true
+      end
+
+      def stop_git_stream!(buffer_id)
+        buf = @editor.buffers[buffer_id]
+        buf&.stream&.stop!
+      end
+
+      def drain_events!
+        return false unless @stream_event_queue
+
+        changed = false
+        loop do
+          event = @stream_event_queue.pop(true)
+          case event[:type]
+          when :stream_data
+            changed = apply_stream_chunk!(event[:buffer_id], event[:data]) || changed
+          when :stream_eof
+            changed = finish_stream!(event[:buffer_id], status: event[:status]) || changed
+          when :stream_error
+            changed = fail_stream!(event[:buffer_id], event[:error]) || changed
+          when :follow_data
+            changed = apply_stream_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_lines
+            changed = apply_async_file_lines!(event[:buffer_id], event[:head], event[:lines], loaded_bytes: event[:loaded_bytes], file_size: event[:file_size]) || 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
+          end
+        end
+      rescue ThreadError
+        changed
+      end
+
+      def ex_follow_toggle
+        buf = @editor.current_buffer
+        raise RuVim::CommandError, "No file associated with buffer" unless buf.path
+
+        if buf.stream.is_a?(Stream::Follow)
+          stop_follow!(buf)
+        else
+          raise RuVim::CommandError, "Buffer has unsaved changes" if buf.modified?
+          start_follow!(buf)
+        end
+      end
+
+      def start_follow!(buf)
+        ensure_event_queue!
+        Buffer.ensure_regular_file!(buf.path) if buf.path
+
+        if buf.path && File.file?(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
+
+        buf.stream = Stream::Follow.new(
+          path: buf.path, buffer_id: buf.id, queue: @stream_event_queue,
+          stop_handler: -> { stop_follow!(buf) }, &method(:notify_signal_wakeup)
+        )
+        @editor.echo("[follow] #{buf.display_name}")
+      end
+
+      def stop_follow!(buf)
+        buf.stream&.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 = nil
+        @editor.echo("[follow] stopped")
+        true
+      end
+
+      def follow_active?(buf)
+        buf.stream.is_a?(Stream::Follow)
+      end
+
+      def open_path_with_large_file_support(path)
+        return @editor.open_path_sync(path) unless should_open_path_async?(path)
+        return @editor.open_path_sync(path) unless can_start_async_file_load?
+
+        open_path_asynchronously!(path)
+      end
+
+      def shutdown!
+        @editor.buffers.each_value do |buf|
+          buf.stream&.stop!
+        rescue StandardError
+          nil
+        end
+      end
+
+      def ensure_event_queue!
+        @stream_event_queue ||= Queue.new
+      end
+
+      private
+
+      def apply_stream_chunk!(buffer_id, text)
+        return false if text.to_s.empty?
+
+        buf = @editor.buffers[buffer_id]
+        return false unless buf
+
+        following_win_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)
+
+        following_win_ids.each do |win_id|
+          win = @editor.windows[win_id]
+          move_window_to_stream_end!(win, buf) if win
+        end
+
+        true
+      end
+
+      def finish_stream!(buffer_id, status: nil)
+        buf = @editor.buffers[buffer_id]
+        return false unless buf&.stream
+
+        stream = buf.stream
+        stream.thread = nil if stream.respond_to?(:thread=)
+        stream.io = nil if stream.respond_to?(:io=)
+
+        # Remove trailing empty line if present
+        if buf.lines.length > 1 && buf.lines[-1] == ""
+          buf.lines.pop
+        end
+        stream.state = :closed
+        stream.exit_status = status if stream.respond_to?(:exit_status=)
+
+        if status
+          @editor.echo("#{buf.display_name} exit #{status.exitstatus}")
+        elsif buf.kind == :stream
+          @editor.echo("[stdin] EOF")
+        else
+          @editor.echo("#{buf.display_name} #{buf.line_count} lines")
+        end
+        true
+      end
+
+      def fail_stream!(buffer_id, error)
+        buf = @editor.buffers[buffer_id]
+        return false unless buf&.stream
+
+        # Ignore errors from intentionally closed streams
+        if buf.stream.state == :closed
+          msg = error.to_s.downcase
+          return false if msg.include?("stream closed") || msg.include?("closed in another thread")
+        end
+
+        stream = buf.stream
+        stream.thread = nil if stream.respond_to?(:thread=)
+        stream.io = nil if stream.respond_to?(:io=)
+        stream.state = :error
+        @editor.echo_error("#{buf.display_name} stream error: #{error}")
+        true
+      end
+
+      def apply_async_file_lines!(buffer_id, head, lines, loaded_bytes: nil, file_size: nil)
+        buf = @editor.buffers[buffer_id]
+        return false unless buf
+
+        following_win_ids = if buf.stream.is_a?(Stream::Follow)
+          @editor.windows.values.filter_map do |win|
+            next unless win.buffer_id == buffer_id
+            next unless stream_window_following_end?(win, buf)
+            win.id
+          end
+        end
+
+        buf.append_stream_lines!(head, lines)
+
+        following_win_ids&.each do |win_id|
+          win = @editor.windows[win_id]
+          move_window_to_stream_end!(win, buf) if win
+        end
+
+        if loaded_bytes && file_size && file_size > 0
+          pct = (loaded_bytes * 100.0 / file_size).clamp(0, 100)
+          @editor.echo(format("\"%s\" loading... %d%%", buf.display_name, pct))
+        end
+
+        true
+      end
+
+      def finish_async_file_load!(buffer_id, ended_with_newline:)
+        buf = @editor.buffers[buffer_id]
+        return false unless buf
+
+        buf.finalize_async_file_load!(ended_with_newline: !!ended_with_newline)
+        buf.stream.state = :closed if buf.stream
+        @editor.echo(format("\"%s\" %dL", buf.display_name, buf.line_count))
+        true
+      end
+
+      def fail_async_file_load!(buffer_id, error)
+        buf = @editor.buffers[buffer_id]
+        if buf&.stream
+          buf.stream.state = :error
+        end
+        @editor.echo_error("\"#{(buf && buf.display_name) || buffer_id}\" load error: #{error}")
+        true
+      end
+
+      def stream_window_following_end?(win, buf)
+        return false unless win
+
+        last_row = buf.line_count - 1
+        win.cursor_y >= last_row
+      end
+
+      def move_window_to_stream_end!(win, buf)
+        return unless win && buf
+
+        last_row = buf.line_count - 1
+        win.cursor_y = last_row
+        win.cursor_x = buf.line_length(last_row)
+        win.clamp_to_buffer(buf)
+      end
+
+      def should_open_path_async?(path)
+        p = path.to_s
+        return false if p.empty?
+        return false unless File.file?(p)
+
+        File.size(p) >= large_file_async_threshold_bytes
+      rescue StandardError
+        false
+      end
+
+      def can_start_async_file_load?
+        @editor.buffers.none? { |_, buf| buf.stream.is_a?(Stream::FileLoad) && buf.stream.live? }
+      end
+
+      def large_file_async_threshold_bytes
+        raw = ENV["RUVIM_ASYNC_FILE_THRESHOLD_BYTES"]
+        n = raw.to_i if raw
+        return n if n && n.positive?
+
+        LARGE_FILE_ASYNC_THRESHOLD_BYTES
+      end
+
+      def open_path_asynchronously!(path)
+        file_size = File.size(path)
+        buf = @editor.add_empty_buffer(path: path)
+        @editor.switch_to_buffer(buf.id)
+        buf.modified = false
+
+        ensure_event_queue!
+        io = File.open(path, "rb")
+        staged_prefix_bytes = async_file_staged_prefix_bytes
+        staged_mode = file_size > staged_prefix_bytes
+        if staged_mode
+          prefix = io.read(staged_prefix_bytes) || "".b
+          unless prefix.empty?
+            last_nl = prefix.rindex("\n".b)
+            if last_nl && last_nl < prefix.bytesize - 1
+              remainder = prefix.bytesize - last_nl - 1
+              prefix = prefix[0..last_nl]
+              io.seek(-remainder, IO::SEEK_CUR)
+            end
+            buf.append_stream_text!(Buffer.decode_text(prefix))
+          end
+        end
+
+        if io.eof?
+          buf.finalize_async_file_load!(ended_with_newline: prefix&.end_with?("\n") || false)
+          io.close unless io.closed?
+          return buf
+        end
+
+        # Create FileLoad stream after prefix reading; starts background thread immediately
+        buf.stream = Stream::FileLoad.new(io: io, file_size: file_size, buffer_id: buf.id, queue: @stream_event_queue, &method(:notify_signal_wakeup))
+
+        size_mb = file_size.fdiv(1024 * 1024)
+        if staged_mode
+          @editor.echo(format("\"%s\" loading... (showing first %.0fMB of %.1fMB)", path, staged_prefix_bytes.fdiv(1024 * 1024), size_mb))
+        else
+          @editor.echo(format("\"%s\" loading... (%.1fMB)", path, size_mb))
+        end
+        buf
+      rescue StandardError
+        buf.stream = nil if buf
+        raise
+      end
+
+      def async_file_staged_prefix_bytes
+        raw = ENV["RUVIM_ASYNC_FILE_PREFIX_BYTES"]
+        n = raw.to_i if raw
+        return n if n && n.positive?
+
+        LARGE_FILE_STAGED_PREFIX_BYTES
+      end
+
+      def notify_signal_wakeup
+        @signal_w.write_nonblock(".")
+      rescue IO::WaitWritable, Errno::EPIPE
+        nil
+      end
+  end
+end

data/lib/ruvim/terminal.rb

@@ -22,17 +22,31 @@ module RuVim
 
     def with_ui
       @stdin.raw do
-        write("\e]112\a\e[?1049h\e[?25l")
+        write("\e]112\a\e[2 q\e[?1049h\e[?25l")
         yield
       ensure
-        write("\e[?25h\e[?1049l")
+        write("\e[0 q\e[?25h\e[?1049l")
+      end
+    end
+
+    def suspend_for_shell(command)
+      shell = ENV["SHELL"].to_s
+      shell = "/bin/sh" if shell.empty?
+      @stdin.cooked do
+        write("\e[0 q\e[?25h\e[?1049l")
+        system(shell, "-c", command)
+        status = $?
+        write("\r\nPress ENTER or type command to continue")
+        @stdin.raw { @stdin.getc }
+        write("\e[2 q\e[?1049h\e[?25l")
+        status
       end
     end
 
     def suspend_for_tstp
       prev_tstp = Signal.trap("TSTP", "DEFAULT")
       @stdin.cooked do
-        write("\e[?25h\e[?1049l")
+        write("\e[0 q\e[?25h\e[?1049l")
         Process.kill("TSTP", 0)
       end
     ensure
@@ -41,7 +55,7 @@ module RuVim
       rescue StandardError
         nil
       end
-      write("\e[?1049h\e[?25l")
+      write("\e[2 q\e[?1049h\e[?25l")
     end
   end
 end

data/lib/ruvim/text_metrics.rb

@@ -4,15 +4,21 @@ module RuVim
   module TextMetrics
     module_function
 
-    Cell = Struct.new(:glyph, :source_col, :display_width, keyword_init: true)
+    class Cell
+      attr_reader :glyph, :source_col, :display_width
+
+      def initialize(glyph, source_col, display_width)
+        @glyph = glyph
+        @source_col = source_col
+        @display_width = display_width
+      end
+    end
 
-    # Cursor positions in RuVim are currently "character index" (Ruby String#[] index on UTF-8),
-    # not byte offsets. Grapheme-aware movement is layered on top of that.
     def previous_grapheme_char_index(line, char_index)
-      idx = [char_index.to_i, 0].max
+      idx = [char_index, 0].max
       return 0 if idx <= 0
 
-      left = line.to_s[0...idx].to_s
+      left = line[0...idx].to_s
       clusters = left.scan(/\X/)
       return 0 if clusters.empty?
 
@@ -21,7 +27,7 @@ module RuVim
 
     def next_grapheme_char_index(line, char_index)
       s = line.to_s
-      idx = [[char_index.to_i, 0].max, s.length].min
+      idx = [[char_index, 0].max, s.length].min
       return s.length if idx >= s.length
 
       rest = s[idx..].to_s
@@ -32,93 +38,106 @@ module RuVim
     end
 
     def screen_col_for_char_index(line, char_index, tabstop: 2)
-      idx = [char_index.to_i, 0].max
-      prefix = line.to_s[0...idx].to_s
+      idx = [char_index, 0].max
+      prefix = line[0...idx].to_s
       RuVim::DisplayWidth.display_width(prefix, tabstop:)
     end
 
-    # Returns a character index whose screen column is <= target_screen_col,
-    # aligned to a grapheme-cluster boundary.
-    def char_index_for_screen_col(line, target_screen_col, tabstop: 2, align: :floor)
-      s = line.to_s
-      target = [target_screen_col.to_i, 0].max
-      screen_col = 0
-      char_index = 0
-
-      s.scan(/\X/).each do |cluster|
-        width = RuVim::DisplayWidth.display_width(cluster, tabstop:, start_col: screen_col)
-        if screen_col + width > target
-          return align == :ceil ? (char_index + cluster.length) : char_index
-        end
+    if defined?(RuVim::TextMetricsExt)
+      # ---- C extension paths ----
 
-        screen_col += width
-        char_index += cluster.length
+      def clip_cells_for_width(text, width, source_col_start: 0, tabstop: 2)
+        TextMetricsExt.clip_cells_for_width(text, width, source_col_start:, tabstop:)
       end
 
-      char_index
-    end
+      def char_index_for_screen_col(line, target_screen_col, tabstop: 2, align: :floor)
+        TextMetricsExt.char_index_for_screen_col(line, target_screen_col, tabstop:, align:)
+      end
+    else
+      # ---- Pure Ruby fallback ----
+
+      def char_index_for_screen_col(line, target_screen_col, tabstop: 2, align: :floor)
+        s = line.to_s
+        target = [target_screen_col, 0].max
+        screen_col = 0
+        char_index = 0
+
+        s.scan(/\X/).each do |cluster|
+          width = RuVim::DisplayWidth.display_width(cluster, tabstop:, start_col: screen_col)
+          if screen_col + width > target
+            return align == :ceil ? (char_index + cluster.length) : char_index
+          end
 
-    def clip_cells_for_width(text, width, source_col_start: 0, tabstop: 2)
-      max_width = [width.to_i, 0].max
-      cells = []
-      display_col = 0
-      source_col = source_col_start.to_i
+          screen_col += width
+          char_index += cluster.length
+        end
 
-      text.to_s.each_char do |ch|
-        if ch == "\t"
-          w = RuVim::DisplayWidth.cell_width(ch, col: display_col, tabstop:)
-          break if display_col + w > max_width
+        char_index
+      end
 
-          w.times do
-            cells << Cell.new(glyph: " ", source_col:, display_width: 1)
+      def clip_cells_for_width(text, width, source_col_start: 0, tabstop: 2)
+        max_width = [width, 0].max
+        cells = []
+        display_col = 0
+        source_col = source_col_start
+
+        text.to_s.each_char do |ch|
+          code = ch.ord
+          # Fast path: printable ASCII (0x20..0x7E) — width 1, no special handling
+          if code >= 0x20 && code <= 0x7E
+            break if display_col >= max_width
+            cells << Cell.new(ch, source_col, 1)
+            display_col += 1
+            source_col += 1
+            next
+          end
+
+          if ch == "\t"
+            w = tabstop - (display_col % tabstop)
+            w = tabstop if w.zero?
+            break if display_col + w > max_width
+
+            w.times do
+              cells << Cell.new(" ", source_col, 1)
+            end
+            display_col += w
+            source_col += 1
+            next
           end
-          display_col += w
-          source_col += 1
-          next
-        end
 
-        w = RuVim::DisplayWidth.cell_width(ch, col: display_col, tabstop:)
-        if terminal_unsafe_control_char?(ch)
-          w = [w, 1].max
+          # Control chars (0x00..0x1F, 0x7F, 0x80..0x9F)
+          if code < 0x20 || code == 0x7F || (code >= 0x80 && code <= 0x9F)
+            break if display_col >= max_width
+            cells << Cell.new("?", source_col, 1)
+            display_col += 1
+            source_col += 1
+            next
+          end
+
+          w = RuVim::DisplayWidth.cell_width(ch, col: display_col, tabstop:)
           break if display_col + w > max_width
 
-          cells << Cell.new(glyph: terminal_safe_placeholder(ch), source_col:, display_width: w)
+          cells << Cell.new(ch, source_col, w)
           display_col += w
           source_col += 1
-          next
         end
-        break if display_col + w > max_width
 
-        cells << Cell.new(glyph: ch, source_col:, display_width: w)
-        display_col += w
-        source_col += 1
+        [cells, display_col]
       end
-
-      [cells, display_col]
     end
 
     def pad_plain_to_screen_width(text, width, tabstop: 2)
       cells, used = clip_cells_for_width(text, width, tabstop:)
       out = cells.map(&:glyph).join
-      out << (" " * [width.to_i - used, 0].max)
+      out << (" " * [width - used, 0].max)
       out
     end
 
-    def terminal_safe_text(text)
-      text.to_s.each_char.map { |ch| terminal_unsafe_control_char?(ch) ? terminal_safe_placeholder(ch) : ch }.join
-    end
-
-    def terminal_unsafe_control_char?(ch)
-      return false if ch.nil? || ch.empty? || ch == "\t"
+    UNSAFE_CONTROL_CHAR_RE = /[\u0000-\u0008\u000a-\u001f\u007f\u0080-\u009f]/
 
-      code = ch.ord
-      (code >= 0x00 && code < 0x20) || code == 0x7F || (0x80..0x9F).cover?(code)
-    rescue StandardError
-      false
+    def terminal_safe_text(text)
+      text.to_s.gsub(UNSAFE_CONTROL_CHAR_RE, "?")
     end
 
-    def terminal_safe_placeholder(_ch)
-      "?"
-    end
   end
 end

data/lib/ruvim/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RuVim
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end