ruvim 0.3.0 → 0.6.0

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.3.0"
+  VERSION = "0.6.0"
 end

data/lib/ruvim/window.rb

@@ -19,17 +19,17 @@ module RuVim
     end
 
     def cursor_x=(value)
-      @cursor_x = value.to_i
+      @cursor_x = value
       @preferred_x = nil
     end
 
     def cursor_y=(value)
-      @cursor_y = value.to_i
+      @cursor_y = value
     end
 
     def clamp_to_buffer(buffer, max_extra_col: 0)
       @cursor_y = [[@cursor_y, 0].max, buffer.line_count - 1].min
-      max_col = buffer.line_length(@cursor_y) + [max_extra_col.to_i, 0].max
+      max_col = buffer.line_length(@cursor_y) + [max_extra_col, 0].max
       @cursor_x = [[@cursor_x, 0].max, max_col].min
       self
     end
@@ -71,7 +71,7 @@ module RuVim
 
     def ensure_visible(buffer, height:, width:, tabstop: 2, scrolloff: 0, sidescrolloff: 0)
       clamp_to_buffer(buffer)
-      so = [[scrolloff.to_i, 0].max, [height.to_i - 1, 0].max].min
+      so = [[scrolloff, 0].max, [height - 1, 0].max].min
 
       top_target = @cursor_y - so
       bottom_target = @cursor_y + so
@@ -82,7 +82,7 @@ module RuVim
       line = buffer.line_at(@cursor_y)
       cursor_screen_col = RuVim::TextMetrics.screen_col_for_char_index(line, @cursor_x, tabstop:)
       offset_screen_col = RuVim::TextMetrics.screen_col_for_char_index(line, @col_offset, tabstop:)
-      sso = [[sidescrolloff.to_i, 0].max, [width.to_i - 1, 0].max].min
+      sso = [[sidescrolloff, 0].max, [width - 1, 0].max].min
 
       if cursor_screen_col < offset_screen_col + sso
         target_left = [cursor_screen_col - sso, 0].max

data/lib/ruvim.rb

@@ -13,11 +13,33 @@ require_relative "ruvim/display_width"
 require_relative "ruvim/keyword_chars"
 require_relative "ruvim/text_metrics"
 require_relative "ruvim/clipboard"
+require_relative "ruvim/browser"
+require_relative "ruvim/lang/registry"
 require_relative "ruvim/lang/base"
 require_relative "ruvim/lang/markdown"
 require_relative "ruvim/lang/ruby"
 require_relative "ruvim/lang/json"
 require_relative "ruvim/lang/scheme"
+require_relative "ruvim/lang/c"
+require_relative "ruvim/lang/cpp"
+require_relative "ruvim/lang/diff"
+require_relative "ruvim/lang/yaml"
+require_relative "ruvim/lang/sh"
+require_relative "ruvim/lang/python"
+require_relative "ruvim/lang/javascript"
+require_relative "ruvim/lang/typescript"
+require_relative "ruvim/lang/html"
+require_relative "ruvim/lang/toml"
+require_relative "ruvim/lang/go"
+require_relative "ruvim/lang/rust"
+require_relative "ruvim/lang/makefile"
+require_relative "ruvim/lang/dockerfile"
+require_relative "ruvim/lang/sql"
+require_relative "ruvim/lang/elixir"
+require_relative "ruvim/lang/perl"
+require_relative "ruvim/lang/lua"
+require_relative "ruvim/lang/ocaml"
+require_relative "ruvim/lang/erb"
 require_relative "ruvim/highlighter"
 require_relative "ruvim/context"
 require_relative "ruvim/buffer"
@@ -25,6 +47,15 @@ require_relative "ruvim/window"
 require_relative "ruvim/editor"
 require_relative "ruvim/command_registry"
 require_relative "ruvim/ex_command_registry"
+require_relative "ruvim/git/blame"
+require_relative "ruvim/git/status"
+require_relative "ruvim/git/diff"
+require_relative "ruvim/git/log"
+require_relative "ruvim/git/branch"
+require_relative "ruvim/git/commit"
+require_relative "ruvim/git/grep"
+require_relative "ruvim/gh/link"
+require_relative "ruvim/git/handler"
 require_relative "ruvim/global_commands"
 require_relative "ruvim/dispatcher"
 require_relative "ruvim/keymap_manager"
@@ -32,10 +63,6 @@ require_relative "ruvim/command_line"
 require_relative "ruvim/input"
 require_relative "ruvim/terminal"
 require_relative "ruvim/rich_view"
-
-# Register renderers after RichView is defined
-RuVim::RichView.register("markdown", RuVim::RichView::MarkdownRenderer)
-
 require_relative "ruvim/lang/tsv"
 require_relative "ruvim/lang/csv"
 require_relative "ruvim/screen"

data/test/app_command_test.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class AppCommandTest < Minitest::Test
+  def setup
+    @app = RuVim::App.new(clean: true)
+    @editor = @app.instance_variable_get(:@editor)
+    @key_handler = @app.instance_variable_get(:@key_handler)
+    @editor.materialize_intro_buffer!
+  end
+
+  def feed(*keys)
+    keys.each { |k| @key_handler.handle(k) }
+  end
+
+  def buf
+    @editor.current_buffer
+  end
+
+  def win
+    @editor.current_window
+  end
+
+  # --- cursor commands ---
+
+  def test_cursor_line_end
+    buf.replace_all_lines!(["hello world"])
+    win.cursor_x = 0
+    feed("$")
+    assert_equal buf.line_length(0), win.cursor_x
+  end
+
+  def test_cursor_buffer_start_gg
+    buf.replace_all_lines!(["line1", "line2", "line3"])
+    win.cursor_y = 2
+    feed("g", "g")
+    assert_equal 0, win.cursor_y
+  end
+
+  # --- insert mode variants ---
+
+  def test_append_mode_a
+    buf.replace_all_lines!(["abc"])
+    win.cursor_x = 1
+    feed("a", "X", :escape)
+    assert_equal ["abXc"], buf.lines
+  end
+
+  def test_insert_line_start_nonblank_I
+    buf.replace_all_lines!(["  hello"])
+    win.cursor_x = 4
+    feed("I", "X", :escape)
+    assert_equal ["  Xhello"], buf.lines
+  end
+
+  def test_open_line_below_o
+    buf.replace_all_lines!(["hello", "world"])
+    win.cursor_y = 0
+    feed("o", "new", :escape)
+    assert_equal ["hello", "new", "world"], buf.lines
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_open_line_above_O
+    buf.replace_all_lines!(["hello", "world"])
+    win.cursor_y = 1
+    feed("O", "new", :escape)
+    assert_equal ["hello", "new", "world"], buf.lines
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- undo / redo ---
+
+  def test_undo_and_redo
+    buf.replace_all_lines!(["hello"])
+    feed("x")
+    assert_equal ["ello"], buf.lines
+
+    feed("u")
+    assert_equal ["hello"], buf.lines
+    assert_match(/Undo/, @editor.message)
+
+    feed(:ctrl_r)
+    assert_equal ["ello"], buf.lines
+    assert_match(/Redo/, @editor.message)
+  end
+
+  def test_undo_at_oldest
+    buf.replace_all_lines!(["hello"])
+    buf.instance_variable_get(:@undo_stack)&.clear
+    feed("u")
+    assert_match(/oldest/, @editor.message)
+  end
+
+  # --- search ---
+
+  def test_search_backward_mode
+    buf.replace_all_lines!(["hello world"])
+    feed("?")
+    assert_equal :command_line, @editor.mode
+  end
+
+  def test_search_prev_N
+    buf.replace_all_lines!(["aaa", "bbb", "aaa"])
+    win.cursor_y = 0
+    feed("/", "b", "b", "b", :enter)
+    assert_equal 1, win.cursor_y
+
+    feed("N")
+    assert_operator win.cursor_y, :>=, 0
+  end
+
+  def test_search_word_backward
+    buf.replace_all_lines!(["foo bar foo"])
+    win.cursor_x = 8
+    feed("#")
+    assert_equal 0, win.cursor_x
+  end
+
+  def test_search_word_forward_partial
+    buf.replace_all_lines!(["foobar foo foobar"])
+    win.cursor_x = 0
+    feed("g", "*")
+    assert_operator win.cursor_x, :>, 0
+  end
+
+  def test_search_word_backward_partial
+    buf.replace_all_lines!(["foobar foo foobar"])
+    win.cursor_x = 11
+    feed("g", "#")
+    assert_operator win.cursor_x, :<, 11
+  end
+
+  # --- marks ---
+
+  def test_mark_set_and_jump
+    buf.replace_all_lines!(["line1", "line2", "line3"])
+    win.cursor_y = 1
+    feed("m", "a")
+
+    win.cursor_y = 0
+    feed("'", "a")
+    assert_equal 1, win.cursor_y
+  end
+
+  def test_mark_jump_unset
+    buf.replace_all_lines!(["line1"])
+    feed("`", "z")
+    assert_match(/Mark not set/, @editor.message)
+  end
+
+  def test_mark_pending_escape_cancels
+    buf.replace_all_lines!(["hello"])
+    feed("m", "\e")
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_mark_pending_invalid_char
+    buf.replace_all_lines!(["hello"])
+    feed("m", " ")
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- jump list ---
+
+  def test_jump_older_and_newer
+    buf.replace_all_lines!((1..20).map { |i| "line#{i}" })
+    win.cursor_y = 0
+
+    feed("G")
+    last_line = buf.line_count - 1
+    assert_equal last_line, win.cursor_y
+
+    feed(:ctrl_o)
+    old_y = win.cursor_y
+
+    feed(:ctrl_i)
+    new_y = win.cursor_y
+    assert_operator new_y, :>=, old_y
+  end
+
+  def test_jump_older_empty
+    buf.replace_all_lines!(["line1"])
+    @editor.instance_variable_get(:@jump_list)&.clear rescue nil
+    feed(:ctrl_o)
+    assert_match(/Jump list/, @editor.message.to_s) if @editor.message
+  end
+
+  def test_backtick_backtick_jumps_older
+    buf.replace_all_lines!((1..10).map { |i| "line#{i}" })
+    win.cursor_y = 0
+    feed("G")
+    feed("`", "`")
+    assert_equal 0, win.cursor_y
+  end
+
+  def test_jump_pending_escape_cancels
+    buf.replace_all_lines!(["hello"])
+    feed("'", "\e")
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_jump_pending_invalid_mark
+    buf.replace_all_lines!(["hello"])
+    feed("'", " ")
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- visual mode ---
+
+  def test_visual_line_yank
+    buf.replace_all_lines!(["aaa", "bbb", "ccc"])
+    win.cursor_y = 0
+    feed("V", "j", "y")
+
+    reg = @editor.get_register("\"")
+    assert_equal :normal, @editor.mode
+    assert_includes reg[:text], "aaa"
+    assert_includes reg[:text], "bbb"
+  end
+
+  def test_visual_line_delete
+    buf.replace_all_lines!(["aaa", "bbb", "ccc"])
+    win.cursor_y = 0
+    feed("V", "j", "d")
+
+    assert_equal ["ccc"], buf.lines
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_visual_char_delete
+    buf.replace_all_lines!(["abcdef"])
+    win.cursor_x = 1
+    feed("v", "l", "l", "d")
+
+    assert_equal ["aef"], buf.lines
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_visual_select_text_object_iw
+    buf.replace_all_lines!(["hello world"])
+    win.cursor_x = 0
+    feed("v", "i", "w")
+    assert_equal :visual_char, @editor.mode
+  end
+
+  # --- delete operator ---
+
+  def test_delete_gg_motion
+    buf.replace_all_lines!(["aaa", "bbb", "ccc"])
+    win.cursor_y = 2
+    feed("d", "g", "g")
+    assert_equal [""], buf.lines
+  end
+
+  def test_delete_j_motion
+    buf.replace_all_lines!(["aaa", "bbb", "ccc"])
+    win.cursor_y = 0
+    feed("d", "j")
+    assert_equal ["ccc"], buf.lines
+  end
+
+  def test_delete_k_motion
+    buf.replace_all_lines!(["aaa", "bbb", "ccc"])
+    win.cursor_y = 1
+    feed("d", "k")
+    assert_equal ["ccc"], buf.lines
+  end
+
+  def test_delete_word_dw
+    buf.replace_all_lines!(["hello world"])
+    win.cursor_x = 0
+    feed("d", "w")
+    assert_equal ["world"], buf.lines
+  end
+
+  def test_delete_aw
+    buf.replace_all_lines!(["hello world"])
+    win.cursor_x = 0
+    feed("d", "a", "w")
+    assert_equal ["world"], buf.lines
+  end
+
+  # --- yank operator ---
+
+  def test_yank_word_yw
+    buf.replace_all_lines!(["hello world"])
+    win.cursor_x = 0
+    feed("y", "w")
+    reg = @editor.get_register("\"")
+    assert_equal "hello ", reg[:text]
+  end
+
+  def test_yank_gg_motion
+    buf.replace_all_lines!(["aaa", "bbb", "ccc"])
+    win.cursor_y = 2
+    feed("y", "g", "g")
+    reg = @editor.get_register("\"")
+    assert_includes reg[:text], "aaa"
+    assert_includes reg[:text], "ccc"
+  end
+
+  def test_yank_iw
+    buf.replace_all_lines!(["hello world"])
+    win.cursor_x = 0
+    feed("y", "i", "w")
+    reg = @editor.get_register("\"")
+    assert_equal "hello", reg[:text]
+  end
+
+  def test_yank_aw
+    buf.replace_all_lines!(["hello world"])
+    win.cursor_x = 0
+    feed("y", "a", "w")
+    reg = @editor.get_register("\"")
+    assert_equal "hello ", reg[:text]
+  end
+
+  # --- indent operator ---
+
+  def test_indent_j_motion
+    buf.replace_all_lines!(["  aaa", "  bbb", "ccc"])
+    win.cursor_y = 0
+    feed("=", "j")
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_indent_gg_motion
+    buf.replace_all_lines!(["  aaa", "  bbb"])
+    win.cursor_y = 1
+    feed("=", "g", "g")
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_indent_k_motion
+    buf.replace_all_lines!(["aaa", "  bbb", "ccc"])
+    win.cursor_y = 1
+    feed("=", "k")
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_indent_G_motion
+    buf.replace_all_lines!(["  aaa", "  bbb"])
+    win.cursor_y = 0
+    feed("=", "G")
+    assert_equal :normal, @editor.mode
+  end
+
+  # --- arrow and page keys ---
+
+  def test_arrow_keys_in_normal_mode
+    buf.replace_all_lines!(["abc", "def"])
+    win.cursor_y = 0
+    win.cursor_x = 0
+    feed(:right)
+    assert_equal 1, win.cursor_x
+    feed(:down)
+    assert_equal 1, win.cursor_y
+    feed(:left)
+    assert_equal 0, win.cursor_x
+    feed(:up)
+    assert_equal 0, win.cursor_y
+  end
+
+  def test_page_keys_in_normal_mode
+    buf.replace_all_lines!((1..30).map { |i| "line#{i}" })
+    @editor.current_window_view_height_hint = 10
+    win.cursor_y = 0
+    feed(:pagedown)
+    assert_operator win.cursor_y, :>, 0
+    feed(:pageup)
+    assert_equal 0, win.cursor_y
+  end
+
+  # --- escape clears message ---
+
+  def test_escape_clears_message
+    @editor.echo("test message")
+    feed("\e")
+  end
+end