ruvim 0.1.0 → 0.2.0

data/lib/ruvim/screen.rb

@@ -19,17 +19,23 @@ module RuVim
       text_cols = [text_cols, 1].max
 
       rects = window_rects(editor, text_rows:, text_cols:)
+      if (current_rect = rects[editor.current_window_id])
+        editor.current_window_view_height_hint = [current_rect[:height].to_i, 1].max
+      end
       editor.window_order.each do |win_id|
         win = editor.windows.fetch(win_id)
         buf = editor.buffers.fetch(win.buffer_id)
         rect = rects[win_id]
         next unless rect
         content_width = [rect[:width] - number_column_width(editor, win, buf), 1].max
+        win.col_offset = 0 if wrap_enabled?(editor, win, buf)
         win.ensure_visible(
           buf,
           height: [rect[:height], 1].max,
           width: content_width,
-          tabstop: tabstop_for(editor, win, buf)
+          tabstop: tabstop_for(editor, win, buf),
+          scrolloff: editor.effective_option("scrolloff", window: win, buffer: buf),
+          sidescrolloff: editor.effective_option("sidescrolloff", window: win, buffer: buf)
         )
       end
 
@@ -52,7 +58,9 @@ module RuVim
       text_rows = [text_rows, 1].max
       text_cols = [text_cols, 1].max
       rect = window_rects(editor, text_rows:, text_cols:)[editor.current_window_id]
-      [rect ? rect[:height].to_i : text_rows, 1].max
+      height = [rect ? rect[:height].to_i : text_rows, 1].max
+      editor.current_window_view_height_hint = height if editor.respond_to?(:current_window_view_height_hint=)
+      height
     rescue StandardError
       1
     end
@@ -65,6 +73,7 @@ module RuVim
 
       status_row = text_rows + 1
       lines[status_row] = "\e[7m#{truncate(status_line(editor, cols), cols)}\e[m"
+      lines[status_row + 1] = ""
 
       if editor.command_line_active?
         cmd = editor.command_line
@@ -96,21 +105,15 @@ module RuVim
         rect = rects[win_id]
         next unless rect
 
-          window = editor.windows.fetch(win_id)
-          buffer = editor.buffers.fetch(window.buffer_id)
-          gutter_w = number_column_width(editor, window, buffer)
-          content_w = [rect[:width] - gutter_w, 1].max
-          rect[:height].times do |dy|
-            row_no = rect[:top] + dy
-            buffer_row = window.row_offset + dy
-            text =
-              if buffer_row < buffer.line_count
-                render_window_row(editor, window, buffer, buffer_row, gutter_w:, content_w:)
-              else
-                line_number_prefix(editor, window, buffer, nil, gutter_w) + pad_plain_display("~", content_w)
-              end
-            lines[row_no] = text
-          end
+        window = editor.windows.fetch(win_id)
+        buffer = editor.buffers.fetch(window.buffer_id)
+        gutter_w = number_column_width(editor, window, buffer)
+        content_w = [rect[:width] - gutter_w, 1].max
+        rows = window_render_rows(editor, window, buffer, height: rect[:height], gutter_w:, content_w:)
+        rect[:height].times do |dy|
+          row_no = rect[:top] + dy
+          lines[row_no] = rows[dy] || (" " * rect[:width])
+        end
       end
 
       rects.each_value do |rect|
@@ -132,12 +135,12 @@ module RuVim
           dy = row_no - rect[:top]
           text =
             if dy >= 0 && dy < rect[:height]
-              buffer_row = window.row_offset + dy
-              if buffer_row < buffer.line_count
-                render_window_row(editor, window, buffer, buffer_row, gutter_w:, content_w:)
-              else
-                line_number_prefix(editor, window, buffer, nil, gutter_w) + pad_plain_display("~", content_w)
-              end
+              @__window_rows_cache ||= {}
+              key = [window.id, rect[:height], gutter_w, content_w, window.row_offset, window.col_offset, window.cursor_y, window.cursor_x,
+                     editor.effective_option("wrap", window:, buffer:), editor.effective_option("linebreak", window:, buffer:),
+                     editor.effective_option("breakindent", window:, buffer:), editor.effective_option("showbreak", window:, buffer:)]
+              @__window_rows_cache[key] ||= window_render_rows(editor, window, buffer, height: rect[:height], gutter_w:, content_w:)
+              @__window_rows_cache[key][dy] || (" " * rect[:width])
             else
               " " * rect[:width]
             end
@@ -146,6 +149,7 @@ module RuVim
         end
         lines[row_no] = pieces
       end
+      @__window_rows_cache = nil
     end
 
     def can_diff_render?(frame)
@@ -184,39 +188,268 @@ module RuVim
     def render_text_line(text, editor, buffer_row:, window:, buffer:, width:)
       tabstop = tabstop_for(editor, window, buffer)
       cells, display_col = RuVim::TextMetrics.clip_cells_for_width(text, width, source_col_start: window.col_offset, tabstop:)
+      render_cells(cells, display_col, editor, buffer_row:, window:, buffer:, width:, source_line: buffer.line_at(buffer_row),
+                   source_col_offset: window.col_offset, leading_display_prefix: "")
+    end
+
+    def render_text_segment(source_line, editor, buffer_row:, window:, buffer:, width:, source_col_start:, display_prefix: "")
+      tabstop = tabstop_for(editor, window, buffer)
+      prefix = display_prefix.to_s
+      prefix_w = RuVim::DisplayWidth.display_width(prefix, tabstop:)
+      avail = [width - prefix_w, 0].max
+      cells, display_col = RuVim::TextMetrics.clip_cells_for_width(source_line[source_col_start..].to_s, avail, source_col_start:, tabstop:)
+      body = render_cells(cells, display_col, editor, buffer_row:, window:, buffer:, width: avail, source_line: source_line,
+                          source_col_offset: source_col_start, leading_display_prefix: prefix)
+      if width <= 0
+        ""
+      elsif prefix_w <= 0
+        body
+      else
+        prefix_render = RuVim::TextMetrics.pad_plain_to_screen_width(prefix, [width, 0].max, tabstop:)[0...prefix.length].to_s
+        # body already includes padding for avail; prepend the visible prefix and trim to width.
+        out = prefix_render + body
+        out
+      end
+    end
+
+    def render_cells(cells, display_col, editor, buffer_row:, window:, buffer:, width:, source_line:, source_col_offset:, leading_display_prefix:)
       highlighted = +""
+      tabstop = tabstop_for(editor, window, buffer)
       visual = (editor.current_window_id == window.id && editor.visual_active?) ? editor.visual_selection(window) : nil
-      search_cols = search_highlight_source_cols(editor, text, source_col_offset: window.col_offset)
-      syntax_cols = syntax_highlight_source_cols(editor, window, buffer, text, source_col_offset: window.col_offset)
-
-      cells.each_with_index do |cell, idx|
-        ch = cell.glyph
+      text_for_highlight = source_line[source_col_offset..].to_s
+      search_cols = search_highlight_source_cols(editor, text_for_highlight, source_col_offset: source_col_offset)
+      syntax_cols = syntax_highlight_source_cols(editor, window, buffer, text_for_highlight, source_col_offset: source_col_offset)
+      list_enabled = !!editor.effective_option("list", window:, buffer:)
+      listchars = parse_listchars(editor.effective_option("listchars", window:, buffer:))
+      tab_seen = {}
+      trail_from = source_line.rstrip.length
+      cursorline = !!editor.effective_option("cursorline", window:, buffer:)
+      current_line = (editor.current_window_id == window.id && window.cursor_y == buffer_row)
+      cursorline_enabled = cursorline && current_line
+      colorcolumns = colorcolumn_display_cols(editor, window, buffer)
+      leading_prefix_width = RuVim::DisplayWidth.display_width(leading_display_prefix.to_s, tabstop:)
+      display_pos = leading_prefix_width
+
+      cells.each do |cell|
+        ch = display_glyph_for_cell(cell, source_line, list_enabled:, listchars:, tab_seen:, trail_from:)
         buffer_col = cell.source_col
         selected = selected_in_visual?(visual, buffer_row, buffer_col)
         cursor_here = (editor.current_window_id == window.id && window.cursor_y == buffer_row && window.cursor_x == buffer_col)
-        if selected || cursor_here
+        colorcolumn_here = colorcolumns[display_pos]
+        if cursor_here
+          highlighted << cursor_cell_render(editor, ch)
+        elsif selected
           highlighted << "\e[7m#{ch}\e[m"
         elsif search_cols[buffer_col]
-          highlighted << "\e[43m#{ch}\e[m"
+          highlighted << "#{search_bg_seq(editor)}#{ch}\e[m"
+        elsif colorcolumn_here
+          highlighted << "#{colorcolumn_bg_seq(editor)}#{ch}\e[m"
+        elsif cursorline_enabled
+          highlighted << "#{cursorline_bg_seq(editor)}#{ch}\e[m"
         elsif (syntax_color = syntax_cols[buffer_col])
           highlighted << "#{syntax_color}#{ch}\e[m"
         else
           highlighted << ch
         end
+        display_pos += [cell.display_width.to_i, 1].max
       end
 
       if editor.current_window_id == window.id && window.cursor_y == buffer_row
-        col = window.cursor_x - window.col_offset
-        if col >= cells.length && col >= 0 && display_col < width
-          highlighted << "\e[7m \e[m"
+        cursor_target = virtual_cursor_display_pos(source_line, window.cursor_x, source_col_offset:, tabstop:, leading_prefix_width:)
+        if cursor_target && cursor_target >= display_pos && cursor_target < width
+          gap = cursor_target - display_pos
+          if gap.positive?
+            highlighted << (" " * gap)
+            display_col += gap
+            display_pos += gap
+          end
+          highlighted << cursor_cell_render(editor, " ")
           display_col += 1
+          display_pos += 1
         end
       end
 
-      highlighted << (" " * [width - display_col, 0].max)
+      trailing = [width - display_col, 0].max
+      if trailing.positive? && cursorline_enabled
+        trailing.times do
+          if colorcolumns[display_pos]
+            highlighted << "#{colorcolumn_bg_seq(editor)} \e[m"
+          else
+            highlighted << "#{cursorline_bg_seq(editor)} \e[m"
+          end
+          display_pos += 1
+        end
+      else
+        highlighted << (" " * trailing)
+      end
       highlighted
     end
 
+    def virtual_cursor_display_pos(source_line, cursor_x, source_col_offset:, tabstop:, leading_prefix_width:)
+      return nil if cursor_x < source_col_offset
+
+      base = RuVim::TextMetrics.screen_col_for_char_index(source_line, cursor_x, tabstop:) -
+             RuVim::TextMetrics.screen_col_for_char_index(source_line, source_col_offset, tabstop:)
+      extra = [cursor_x.to_i - source_line.to_s.length, 0].max
+      leading_prefix_width + [base, 0].max + extra
+    end
+
+    def window_render_rows(editor, window, buffer, height:, gutter_w:, content_w:)
+      return plain_window_render_rows(editor, window, buffer, height:, gutter_w:, content_w:) unless wrap_enabled?(editor, window, buffer)
+
+      wrapped_window_render_rows(editor, window, buffer, height:, gutter_w:, content_w:)
+    end
+
+    def plain_window_render_rows(editor, window, buffer, height:, gutter_w:, content_w:)
+      Array.new(height) do |dy|
+        buffer_row = window.row_offset + dy
+        if buffer_row < buffer.line_count
+          render_window_row(editor, window, buffer, buffer_row, gutter_w:, content_w:)
+        else
+          line_number_prefix(editor, window, buffer, nil, gutter_w) + pad_plain_display("~", content_w)
+        end
+      end
+    end
+
+    def wrapped_window_render_rows(editor, window, buffer, height:, gutter_w:, content_w:)
+      rows = []
+      row_idx = window.row_offset
+      while rows.length < height
+        if row_idx >= buffer.line_count
+          rows << (line_number_prefix(editor, window, buffer, nil, gutter_w) + pad_plain_display("~", content_w))
+          next
+        end
+
+        line = buffer.line_at(row_idx)
+        segments = wrapped_segments_for_line(editor, window, buffer, line, width: content_w)
+        segments.each_with_index do |seg, seg_i|
+          break if rows.length >= height
+
+          gutter = line_number_prefix(editor, window, buffer, seg_i.zero? ? row_idx : nil, gutter_w)
+          rows << gutter + render_text_segment(line, editor, buffer_row: row_idx, window:, buffer:, width: content_w,
+                                               source_col_start: seg[:source_col_start], display_prefix: seg[:display_prefix])
+        end
+        row_idx += 1
+      end
+      rows
+    end
+
+    def wrap_enabled?(editor, window, buffer)
+      !!editor.effective_option("wrap", window:, buffer:)
+    end
+
+    def wrapped_segments_for_line(editor, window, buffer, line, width:)
+      return [{ source_col_start: 0, display_prefix: "" }] if width <= 0
+
+      tabstop = tabstop_for(editor, window, buffer)
+      linebreak = !!editor.effective_option("linebreak", window:, buffer:)
+      showbreak = editor.effective_option("showbreak", window:, buffer:).to_s
+      breakindent = !!editor.effective_option("breakindent", window:, buffer:)
+      indent_prefix = breakindent ? wrapped_indent_prefix(line, tabstop:, max_width: [width - RuVim::DisplayWidth.display_width(showbreak, tabstop:), 0].max) : ""
+
+      segs = []
+      start_col = 0
+      first = true
+      line = line.to_s
+      if line.empty?
+        return [{ source_col_start: 0, display_prefix: "" }]
+      end
+
+      while start_col < line.length
+        display_prefix = first ? "" : "#{showbreak}#{indent_prefix}"
+        prefix_w = RuVim::DisplayWidth.display_width(display_prefix, tabstop:)
+        avail = [width - prefix_w, 1].max
+        cells, = RuVim::TextMetrics.clip_cells_for_width(line[start_col..].to_s, avail, source_col_start: start_col, tabstop:)
+        if cells.empty?
+          segs << { source_col_start: start_col, display_prefix: display_prefix }
+          break
+        end
+
+        if linebreak && cells.length > 1
+          break_idx = linebreak_break_index(cells, line)
+          if break_idx && break_idx < cells.length - 1
+            cells = cells[0..break_idx]
+          end
+        end
+
+        segs << { source_col_start: start_col, display_prefix: display_prefix }
+        next_start = cells.last.source_col.to_i + 1
+        if linebreak
+          next_start += 1 while next_start < line.length && line[next_start] == " "
+        end
+        break if next_start <= start_col
+
+        start_col = next_start
+        first = false
+      end
+
+      segs
+    end
+
+    def linebreak_break_index(cells, line)
+      idx = nil
+      cells.each_with_index do |cell, i|
+        ch = line[cell.source_col]
+        idx = i if ch =~ /\s/
+      end
+      idx
+    end
+
+    def wrapped_indent_prefix(line, tabstop:, max_width:)
+      indent = line.to_s[/\A[ \t]*/].to_s
+      return "" if indent.empty? || max_width <= 0
+
+      RuVim::TextMetrics.pad_plain_to_screen_width(indent, max_width, tabstop:)[0...indent.length].to_s
+    rescue StandardError
+      ""
+    end
+
+    def display_glyph_for_cell(cell, source_line, list_enabled:, listchars:, tab_seen:, trail_from:)
+      return cell.glyph unless list_enabled
+
+      src = source_line[cell.source_col]
+      case src
+      when "\t"
+        first = !tab_seen[cell.source_col]
+        tab_seen[cell.source_col] = true
+        first ? listchars[:tab_head] : listchars[:tab_fill]
+      when " "
+        cell.source_col >= trail_from ? listchars[:trail] : cell.glyph
+      when "\u00A0"
+        listchars[:nbsp]
+      else
+        cell.glyph
+      end
+    end
+
+    def parse_listchars(raw)
+      raw_key = raw.to_s
+      @listchars_cache ||= {}
+      return @listchars_cache[raw_key] if @listchars_cache.key?(raw_key)
+
+      cfg = { tab_head: ">", tab_fill: "-", trail: "-", nbsp: "+" }
+      raw_key.split(",").each do |entry|
+        entry_key, val = entry.split(":", 2)
+        next unless entry_key && val
+
+        case entry_key.strip
+        when "tab"
+          chars = val.to_s.each_char.to_a
+          cfg[:tab_head] = chars[0] if chars[0]
+          cfg[:tab_fill] = chars[1] if chars[1]
+        when "trail"
+          ch = val.to_s.each_char.first
+          cfg[:trail] = ch if ch
+        when "nbsp"
+          ch = val.to_s.each_char.first
+          cfg[:nbsp] = ch if ch
+        end
+      end
+      @listchars_cache[raw_key] = cfg.freeze
+    rescue StandardError
+      { tab_head: ">", tab_fill: "-", trail: "-", nbsp: "+" }
+    end
+
     def render_window_row(editor, window, buffer, buffer_row, gutter_w:, content_w:)
       line = buffer.line_at(buffer_row)
       line = line[window.col_offset..] || ""
@@ -234,18 +467,24 @@ module RuVim
     end
 
     def number_column_width(editor, window, buffer)
+      sign_w = sign_column_width(editor, window, buffer)
       enabled = editor.effective_option("number", window:, buffer:) || editor.effective_option("relativenumber", window:, buffer:)
-      return 0 unless enabled
+      return sign_w unless enabled
 
-      [buffer.line_count.to_s.length, 1].max + 1
+      base = [buffer.line_count.to_s.length, 1].max
+      minw = editor.effective_option("numberwidth", window:, buffer:).to_i
+      sign_w + ([[base, minw].max, 1].max + 1)
     end
 
     def line_number_prefix(editor, window, buffer, buffer_row, width)
       return "" if width <= 0
+      sign_w = sign_column_width(editor, window, buffer)
+      sign = " " * sign_w
+      num_width = [width - sign_w, 0].max
       show_abs = editor.effective_option("number", window:, buffer:)
       show_rel = editor.effective_option("relativenumber", window:, buffer:)
-      return " " * width unless show_abs || show_rel
-      return " " * (width - 1) + " " if buffer_row.nil?
+      return sign + (" " * num_width) unless show_abs || show_rel
+      return sign + (" " * num_width) if buffer_row.nil?
 
       num =
         if show_rel && buffer_row != window.cursor_y
@@ -255,13 +494,72 @@ module RuVim
         else
           "0"
         end
-      num.rjust(width - 1) + " "
+      sign + num.rjust([num_width - 1, 0].max) + (num_width.positive? ? " " : "")
+    end
+
+    def sign_column_width(editor, window, buffer)
+      raw = editor.effective_option("signcolumn", window:, buffer:).to_s
+      case raw
+      when "", "auto", "number"
+        0
+      when "no"
+        0
+      else
+        if (m = /\Ayes(?::(\d+))?\z/.match(raw))
+          n = m[1].to_i
+          n = 1 if n <= 0
+          n
+        else
+          1
+        end
+      end
+    rescue StandardError
+      0
+    end
+
+    def colorcolumn_display_cols(editor, window, buffer)
+      raw = editor.effective_option("colorcolumn", window:, buffer:).to_s
+      return {} if raw.empty?
+
+      @colorcolumn_cache ||= {}
+      return @colorcolumn_cache[raw] if @colorcolumn_cache.key?(raw)
+
+      cols = {}
+      raw.split(",").each do |tok|
+        t = tok.strip
+        next if t.empty?
+        next unless t.match?(/\A\d+\z/)
+        n = t.to_i
+        next if n <= 0
+        cols[n - 1] = true
+      end
+      @colorcolumn_cache[raw] = cols.freeze
+    rescue StandardError
+      {}
     end
 
     def pad_plain_display(text, width)
       RuVim::TextMetrics.pad_plain_to_screen_width(text, width, tabstop: DEFAULT_TABSTOP)
     end
 
+    def search_bg_seq(editor)
+      truecolor_enabled?(editor) ? "\e[48;2;255;215;0m" : "\e[43m"
+    end
+
+    def colorcolumn_bg_seq(editor)
+      truecolor_enabled?(editor) ? "\e[48;2;72;72;72m" : "\e[48;5;238m"
+    end
+
+    def cursorline_bg_seq(editor)
+      truecolor_enabled?(editor) ? "\e[48;2;58;58;58m" : "\e[48;5;236m"
+    end
+
+    def truecolor_enabled?(editor)
+      !!editor.effective_option("termguicolors")
+    rescue StandardError
+      false
+    end
+
     def status_line(editor, width)
       buffer = editor.current_buffer
       window = editor.current_window
@@ -275,14 +573,9 @@ module RuVim
              end
 
       path = buffer.display_name
-      ft = editor.effective_option("filetype", buffer:, window:) || File.extname(buffer.path.to_s).delete_prefix(".")
-      ft = "-" if ft.empty?
       mod = buffer.modified? ? " [+]" : ""
       msg = editor.message_error? ? "" : editor.message.to_s
-      win_idx = (editor.window_order.index(editor.current_window_id) || 0) + 1
-      win_total = editor.window_order.length
-      tab_info = "t#{editor.current_tabpage_number}/#{editor.tabpage_count}"
-      left = "#{mode} #{tab_info} w#{win_idx}/#{win_total} b#{buffer.id} #{path} [ft=#{ft}]#{mod}"
+      left = "#{mode} #{path}#{mod}"
       right = " #{window.cursor_y + 1}:#{window.cursor_x + 1} "
       body_width = [width - right.length, 0].max
       "#{compose_status_body(left, msg, body_width)}#{right}"
@@ -303,13 +596,21 @@ module RuVim
     end
 
     def truncate(str, width)
-      str.to_s.ljust(width)[0, width]
+      RuVim::TextMetrics.terminal_safe_text(str).ljust(width)[0, width]
     end
 
     def error_message_line(msg, cols)
       "\e[97;41m#{truncate(msg, cols)}\e[m"
     end
 
+    def cursor_cell_render(editor, ch)
+      "#{cursor_cell_seq(editor)}#{ch}\e[m"
+    end
+
+    def cursor_cell_seq(editor)
+      "\e[7m"
+    end
+
     def cursor_screen_position(editor, text_rows, rects)
       window = editor.current_window
 
@@ -320,13 +621,47 @@ module RuVim
       end
 
       rect = rects[window.id] || { top: 1, left: 1 }
-      row = rect[:top] + (window.cursor_y - window.row_offset)
-      line = editor.current_buffer.line_at(window.cursor_y)
-      gutter_w = number_column_width(editor, window, editor.current_buffer)
-      tabstop = tabstop_for(editor, window, editor.current_buffer)
-      prefix_screen_col = RuVim::TextMetrics.screen_col_for_char_index(line, window.cursor_x, tabstop:) -
-                          RuVim::TextMetrics.screen_col_for_char_index(line, window.col_offset, tabstop:)
-      col = rect[:left] + gutter_w + [prefix_screen_col, 0].max
+      buffer = editor.current_buffer
+      line = buffer.line_at(window.cursor_y)
+      gutter_w = number_column_width(editor, window, buffer)
+      content_w = [rect[:width] - gutter_w, 1].max
+      tabstop = tabstop_for(editor, window, buffer)
+      if wrap_enabled?(editor, window, buffer)
+        visual_rows_before = 0
+        row = window.row_offset
+        while row < window.cursor_y
+          visual_rows_before += wrapped_segments_for_line(editor, window, buffer, buffer.line_at(row), width: content_w).length
+          row += 1
+        end
+        segs = wrapped_segments_for_line(editor, window, buffer, line, width: content_w)
+        seg_index = 0
+        segs.each_with_index do |seg, i|
+          nxt = segs[i + 1]
+          if nxt.nil? || window.cursor_x < nxt[:source_col_start]
+            seg_index = i
+            break
+          end
+        end
+        seg = segs[seg_index] || { source_col_start: 0, display_prefix: "" }
+        row = rect[:top] + visual_rows_before + seg_index
+        seg_prefix_w = RuVim::DisplayWidth.display_width(seg[:display_prefix].to_s, tabstop:)
+        extra_virtual = [window.cursor_x - line.length, 0].max
+        cursor_sc = RuVim::TextMetrics.screen_col_for_char_index(line, window.cursor_x, tabstop:) + extra_virtual
+        seg_sc = RuVim::TextMetrics.screen_col_for_char_index(line, seg[:source_col_start], tabstop:)
+        col = rect[:left] + gutter_w + seg_prefix_w + [cursor_sc - seg_sc, 0].max
+      else
+        row = rect[:top] + (window.cursor_y - window.row_offset)
+        extra_virtual = [window.cursor_x - line.length, 0].max
+        prefix_screen_col = RuVim::TextMetrics.screen_col_for_char_index(line, window.cursor_x, tabstop:) -
+                            RuVim::TextMetrics.screen_col_for_char_index(line, window.col_offset, tabstop:)
+        col = rect[:left] + gutter_w + [prefix_screen_col, 0].max + extra_virtual
+      end
+      min_row = [rect[:top].to_i, 1].max
+      max_row = [rect[:top].to_i + [rect[:height].to_i, 1].max - 1, min_row].max
+      min_col = [rect[:left].to_i, 1].max
+      max_col = [rect[:left].to_i + [rect[:width].to_i, 1].max - 1, min_col].max
+      row = [[row.to_i, min_row].max, max_row].min
+      col = [[col.to_i, min_col].max, max_col].min
       [row, col]
     end
 

data/lib/ruvim/text_metrics.rb

@@ -76,6 +76,15 @@ module RuVim
         end
 
         w = RuVim::DisplayWidth.cell_width(ch, col: display_col, tabstop:)
+        if terminal_unsafe_control_char?(ch)
+          w = [w, 1].max
+          break if display_col + w > max_width
+
+          cells << Cell.new(glyph: terminal_safe_placeholder(ch), source_col:, display_width: 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)
@@ -92,5 +101,22 @@ module RuVim
       out << (" " * [width.to_i - 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"
+
+      code = ch.ord
+      (code >= 0x00 && code < 0x20) || code == 0x7F || (0x80..0x9F).cover?(code)
+    rescue StandardError
+      false
+    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.1.0"
-end
+  VERSION = "0.2.0"
+end