ruvim 0.1.0

data/lib/ruvim/text_metrics.rb

@@ -0,0 +1,96 @@
+module RuVim
+  module TextMetrics
+    module_function
+
+    Cell = Struct.new(:glyph, :source_col, :display_width, keyword_init: true)
+
+    # 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
+      return 0 if idx <= 0
+
+      left = line.to_s[0...idx].to_s
+      clusters = left.scan(/\X/)
+      return 0 if clusters.empty?
+
+      idx - clusters.last.length
+    end
+
+    def next_grapheme_char_index(line, char_index)
+      s = line.to_s
+      idx = [[char_index.to_i, 0].max, s.length].min
+      return s.length if idx >= s.length
+
+      rest = s[idx..].to_s
+      m = /\A\X/.match(rest)
+      return idx + 1 unless m
+
+      idx + m[0].length
+    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
+      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
+
+        screen_col += width
+        char_index += cluster.length
+      end
+
+      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
+
+      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
+
+          w.times do
+            cells << Cell.new(glyph: " ", source_col:, display_width: 1)
+          end
+          display_col += w
+          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: ch, source_col:, display_width: w)
+        display_col += w
+        source_col += 1
+      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
+    end
+  end
+end

data/lib/ruvim/version.rb

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

data/lib/ruvim/window.rb

@@ -0,0 +1,71 @@
+module RuVim
+  class Window
+    attr_reader :id
+    attr_accessor :buffer_id, :cursor_x, :cursor_y, :row_offset, :col_offset
+    attr_reader :options
+
+    def initialize(id:, buffer_id:)
+      @id = id
+      @buffer_id = buffer_id
+      @cursor_x = 0
+      @cursor_y = 0
+      @row_offset = 0
+      @col_offset = 0
+      @options = {}
+    end
+
+    def clamp_to_buffer(buffer)
+      @cursor_y = [[@cursor_y, 0].max, buffer.line_count - 1].min
+      @cursor_x = [[@cursor_x, 0].max, buffer.line_length(@cursor_y)].min
+      self
+    end
+
+    def move_left(buffer, count = 1)
+      count.times do
+        break if @cursor_x <= 0
+        @cursor_x = RuVim::TextMetrics.previous_grapheme_char_index(buffer.line_at(@cursor_y), @cursor_x)
+      end
+      clamp_to_buffer(buffer)
+    end
+
+    def move_right(buffer, count = 1)
+      count.times do
+        line = buffer.line_at(@cursor_y)
+        break if @cursor_x >= line.length
+        @cursor_x = RuVim::TextMetrics.next_grapheme_char_index(line, @cursor_x)
+      end
+      clamp_to_buffer(buffer)
+    end
+
+    def move_up(buffer, count = 1)
+      @cursor_y -= count
+      clamp_to_buffer(buffer)
+    end
+
+    def move_down(buffer, count = 1)
+      @cursor_y += count
+      clamp_to_buffer(buffer)
+    end
+
+    def ensure_visible(buffer, height:, width:, tabstop: 2)
+      clamp_to_buffer(buffer)
+
+      @row_offset = @cursor_y if @cursor_y < @row_offset
+      @row_offset = @cursor_y - height + 1 if @cursor_y >= @row_offset + height
+      @row_offset = 0 if @row_offset.negative?
+
+      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:)
+
+      if cursor_screen_col < offset_screen_col
+        @col_offset = RuVim::TextMetrics.char_index_for_screen_col(line, cursor_screen_col, tabstop:)
+      elsif cursor_screen_col >= offset_screen_col + width
+        target_left = cursor_screen_col - width + 1
+        @col_offset = RuVim::TextMetrics.char_index_for_screen_col(line, target_left, tabstop:, align: :ceil)
+      end
+      @col_offset = 0 if @col_offset.negative?
+    end
+
+  end
+end

data/lib/ruvim.rb

@@ -0,0 +1,30 @@
+require "singleton"
+
+module RuVim
+  class Error < StandardError; end
+  class CommandError < Error; end
+end
+
+require_relative "ruvim/version"
+require_relative "ruvim/command_invocation"
+require_relative "ruvim/display_width"
+require_relative "ruvim/text_metrics"
+require_relative "ruvim/clipboard"
+require_relative "ruvim/highlighter"
+require_relative "ruvim/context"
+require_relative "ruvim/buffer"
+require_relative "ruvim/window"
+require_relative "ruvim/editor"
+require_relative "ruvim/command_registry"
+require_relative "ruvim/ex_command_registry"
+require_relative "ruvim/global_commands"
+require_relative "ruvim/dispatcher"
+require_relative "ruvim/keymap_manager"
+require_relative "ruvim/command_line"
+require_relative "ruvim/input"
+require_relative "ruvim/terminal"
+require_relative "ruvim/screen"
+require_relative "ruvim/config_dsl"
+require_relative "ruvim/config_loader"
+require_relative "ruvim/app"
+require_relative "ruvim/cli"

data/sig/ruvim.rbs

@@ -0,0 +1,4 @@
+module Ruvim
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/test/app_completion_test.rb

@@ -0,0 +1,39 @@
+require_relative "test_helper"
+
+class AppCompletionTest < Minitest::Test
+  def setup
+    @app = RuVim::App.new
+    @editor = @app.instance_variable_get(:@editor)
+  end
+
+  def test_app_starts_with_intro_buffer_without_path
+    assert_equal :intro, @editor.current_buffer.kind
+    assert @editor.current_buffer.readonly?
+    refute @editor.current_buffer.modifiable?
+  end
+
+  def test_command_line_completion_for_set_option
+    @editor.materialize_intro_buffer!
+    @editor.enter_command_line_mode(":")
+    cmd = @editor.command_line
+    cmd.replace_text("set nu")
+
+    @app.send(:command_line_complete)
+
+    assert_equal "set number", cmd.text
+  end
+
+  def test_insert_buffer_word_completion_ctrl_n
+    @editor.materialize_intro_buffer!
+    b = @editor.current_buffer
+    b.replace_all_lines!(["fo", "foobar", "fizz"])
+    @editor.current_window.cursor_y = 0
+    @editor.current_window.cursor_x = 2
+    @editor.enter_insert_mode
+
+    @app.send(:handle_insert_key, :ctrl_n)
+
+    assert_equal "foobar", b.line_at(0)
+    assert_equal 6, @editor.current_window.cursor_x
+  end
+end

data/test/app_dot_repeat_test.rb

@@ -0,0 +1,54 @@
+require_relative "test_helper"
+
+class AppDotRepeatTest < Minitest::Test
+  def setup
+    @app = RuVim::App.new(clean: true)
+    @editor = @app.instance_variable_get(:@editor)
+    @editor.materialize_intro_buffer!
+    @buffer = @editor.current_buffer
+    @win = @editor.current_window
+  end
+
+  def press(*keys)
+    keys.each { |k| @app.send(:handle_normal_key, k) }
+  end
+
+  def test_dot_repeats_x
+    @buffer.replace_all_lines!(["abcd"])
+    @win.cursor_x = 0
+
+    press("x")
+    press(".")
+
+    assert_equal "cd", @buffer.line_at(0)
+  end
+
+  def test_dot_repeats_dd
+    @buffer.replace_all_lines!(["one", "two", "three"])
+
+    press("d", "d")
+    press(".")
+
+    assert_equal ["three"], @buffer.lines
+  end
+
+  def test_dot_repeats_paste
+    @buffer.replace_all_lines!(["one", "two"])
+    press("y", "y")
+    press("p")
+    press(".")
+
+    assert_equal ["one", "one", "one", "two"], @buffer.lines
+  end
+
+  def test_dot_repeats_replace_char
+    @buffer.replace_all_lines!(["abcd"])
+    @win.cursor_x = 0
+
+    press("r", "x")
+    press("l")
+    press(".")
+
+    assert_equal "xxcd", @buffer.line_at(0)
+  end
+end

data/test/app_motion_test.rb

@@ -0,0 +1,73 @@
+require_relative "test_helper"
+
+class AppMotionTest < Minitest::Test
+  def setup
+    @app = RuVim::App.new(clean: true)
+    @editor = @app.instance_variable_get(:@editor)
+    @editor.materialize_intro_buffer!
+  end
+
+  def press(*keys)
+    keys.each { |k| @app.send(:handle_normal_key, k) }
+  end
+
+  def test_find_char_and_repeat
+    b = @editor.current_buffer
+    b.replace_all_lines!(["abcabc"])
+    @editor.current_window.cursor_y = 0
+    @editor.current_window.cursor_x = 0
+
+    press("f", "c")
+    assert_equal 2, @editor.current_window.cursor_x
+
+    press(";")
+    assert_equal 5, @editor.current_window.cursor_x
+
+    press(",")
+    assert_equal 2, @editor.current_window.cursor_x
+  end
+
+  def test_till_char_moves_before_match
+    b = @editor.current_buffer
+    b.replace_all_lines!(["abcabc"])
+    @editor.current_window.cursor_y = 0
+    @editor.current_window.cursor_x = 0
+
+    press("t", "c")
+
+    assert_equal 1, @editor.current_window.cursor_x
+  end
+
+  def test_match_bracket_with_percent
+    b = @editor.current_buffer
+    b.replace_all_lines!(["x(a[b]c)d"])
+    @editor.current_window.cursor_y = 0
+    @editor.current_window.cursor_x = 1 # (
+
+    press("%")
+    assert_equal 7, @editor.current_window.cursor_x
+
+    press("%")
+    assert_equal 1, @editor.current_window.cursor_x
+  end
+
+  def test_pageup_and_pagedown_move_by_visible_page_height
+    b = @editor.current_buffer
+    b.replace_all_lines!((1..20).map { |i| "line#{i}" })
+    @editor.current_window.cursor_y = 0
+    @editor.current_window.cursor_x = 0
+
+    screen = @app.instance_variable_get(:@screen)
+    screen.define_singleton_method(:current_window_view_height) { |_editor| 5 }
+
+    @app.send(:handle_normal_key, :pagedown)
+    assert_equal 4, @editor.current_window.cursor_y
+
+    @editor.pending_count = 2
+    @app.send(:handle_normal_key, :pagedown)
+    assert_equal 12, @editor.current_window.cursor_y
+
+    @app.send(:handle_normal_key, :pageup)
+    assert_equal 8, @editor.current_window.cursor_y
+  end
+end

data/test/app_register_test.rb

@@ -0,0 +1,47 @@
+require_relative "test_helper"
+
+class AppRegisterTest < Minitest::Test
+  def setup
+    @app = RuVim::App.new(clean: true)
+    @editor = @app.instance_variable_get(:@editor)
+    @editor.materialize_intro_buffer!
+    @buffer = @editor.current_buffer
+  end
+
+  def press(*keys)
+    keys.each { |k| @app.send(:handle_normal_key, k) }
+  end
+
+  def test_yy_updates_register_zero
+    @buffer.replace_all_lines!(["alpha", "beta"])
+
+    press("y", "y")
+
+    assert_equal({ text: "alpha\n", type: :linewise }, @editor.get_register("0"))
+    assert_equal({ text: "alpha\n", type: :linewise }, @editor.get_register("\""))
+  end
+
+  def test_dd_rotates_numbered_registers
+    @buffer.replace_all_lines!(["one", "two", "three"])
+
+    press("d", "d")
+    assert_equal({ text: "one\n", type: :linewise }, @editor.get_register("1"))
+
+    press("d", "d")
+    assert_equal({ text: "two\n", type: :linewise }, @editor.get_register("1"))
+    assert_equal({ text: "one\n", type: :linewise }, @editor.get_register("2"))
+  end
+
+  def test_black_hole_register_does_not_change_unnamed_or_numbered
+    @buffer.replace_all_lines!(["one", "two"])
+
+    press("y", "y")
+    seed = @editor.get_register("\"")
+
+    press("\"", "_", "d", "d")
+
+    assert_equal seed, @editor.get_register("\"")
+    assert_equal({ text: "one\n", type: :linewise }, @editor.get_register("0"))
+    assert_nil @editor.get_register("1")
+  end
+end

data/test/app_scenario_test.rb

@@ -0,0 +1,77 @@
+require_relative "test_helper"
+
+class AppScenarioTest < Minitest::Test
+  def setup
+    @app = RuVim::App.new(clean: true)
+    @editor = @app.instance_variable_get(:@editor)
+    @editor.materialize_intro_buffer!
+  end
+
+  def feed(*keys)
+    keys.each { |k| @app.send(:handle_key, k) }
+  end
+
+  def test_insert_edit_search_and_delete_scenario
+    feed("i", "h", "e", "l", "l", "o", :enter, "w", "o", "r", "l", "d", :escape)
+    feed("k", "0", "x")
+    feed("/", "o", :enter)
+    feed("n")
+
+    assert_equal ["ello", "world"], @editor.current_buffer.lines
+    assert_equal :normal, @editor.mode
+    assert_equal "Search wrapped", @editor.message if @editor.message == "Search wrapped"
+    assert_operator @editor.current_window.cursor_y, :>=, 0
+  end
+
+  def test_visual_block_yank
+    @editor.current_buffer.replace_all_lines!(["abcde", "ABCDE", "xyz"])
+    @editor.current_window.cursor_x = 1
+    @editor.current_window.cursor_y = 0
+
+    feed(:ctrl_v, "j", "l", "l", "y")
+
+    reg = @editor.get_register("\"")
+    assert_equal :normal, @editor.mode
+    assert_equal "bcd\nBCD", reg[:text]
+  end
+
+  def test_visual_block_delete
+    @editor.current_buffer.replace_all_lines!(["abcde", "ABCDE", "xyz"])
+    @editor.current_window.cursor_x = 1
+    @editor.current_window.cursor_y = 0
+
+    feed(:ctrl_v, "j", "l", "l", "d")
+
+    assert_equal ["ae", "AE", "xyz"], @editor.current_buffer.lines
+    assert_equal 0, @editor.current_window.cursor_y
+    assert_equal 1, @editor.current_window.cursor_x
+    assert_equal :normal, @editor.mode
+  end
+
+  def test_dot_repeats_insert_change
+    @editor.current_buffer.replace_all_lines!([""])
+    feed("i", "a", "b", :escape)
+    feed(".")
+
+    assert_equal ["abab"], @editor.current_buffer.lines
+  end
+
+  def test_dot_repeats_change_with_text_object
+    @editor.current_buffer.replace_all_lines!(["foo bar"])
+    feed("c", "i", "w", "X", :escape)
+    feed("w")
+    feed(".")
+
+    assert_equal ["X X"], @editor.current_buffer.lines
+  end
+
+  def test_dot_repeat_works_inside_macro
+    @editor.current_buffer.replace_all_lines!(["abc", "abc", "abc"])
+
+    feed("x")
+    feed("j", "0", "q", "a", ".", "j", "q")
+    feed("@", "a")
+
+    assert_equal ["bc", "bc", "bc"], @editor.current_buffer.lines
+  end
+end