Implement character topology

1 files changed, 287 insertions, 1 deletions

diff --git a/tests/run.lua b/tests/run.lua
index 2eb49b3..1cf9053 100644
--- a/tests/run.lua
+++ b/tests/run.lua
@@ -11,6 +11,7 @@ local capabilities = require("clever_f.capabilities")
 local policy = require("clever_f.policy")
 local sequence_state = require("clever_f.sequence_state")
 local state_transitions = require("clever_f.state_transitions")
+local text_topology = require("clever_f.text_topology")
 local MemoryHost = require("clever_f.testing.memory_host")
 
 local tests = {}
@@ -1197,6 +1198,291 @@ test("ClearAllLandingsAndDirection retains movement initialization", function()
   same(domain.Descriptor.TILL_FORWARD, state:get_previous_descriptor("v"))
 end)
 
+local function collect_iteration(iterator)
+  local positions = {}
+  local characters = {}
+  local spans = {}
+  while true do
+    local position, character, span = iterator()
+    if position == nil then
+      break
+    end
+    positions[#positions + 1] = position
+    characters[#characters + 1] = character
+    spans[#spans + 1] = span
+  end
+  return positions, characters, spans
+end
+
+local function position_strings(positions)
+  local result = {}
+  for index, position in ipairs(positions) do
+    result[index] = tostring(position)
+  end
+  return result
+end
+
+local MIXED_JAPANESE = "A\227\129\130\239\189\178\230\188\162B"
+local MIXED_CHARACTERS = {
+  "A",
+  "\227\129\130",
+  "\239\189\178",
+  "\230\188\162",
+  "B",
+}
+
+test("TextView indexes editor characters in each required encoding", function()
+  local cases = {
+    {
+      encoding = "utf-8",
+      starts = { 1, 2, 5, 8, 11 },
+      lengths = { 1, 3, 3, 3, 1 },
+      line_length = 11,
+    },
+    {
+      encoding = "cp932",
+      starts = { 1, 2, 4, 5, 7 },
+      lengths = { 1, 2, 1, 2, 1 },
+      line_length = 7,
+    },
+    {
+      encoding = "euc-jp",
+      starts = { 1, 2, 4, 6, 8 },
+      lengths = { 1, 2, 2, 2, 1 },
+      line_length = 8,
+    },
+  }
+
+  for _, case in ipairs(cases) do
+    local view = text_topology.new({ MIXED_JAPANESE }, case.encoding)
+    same(case.encoding, view.encoding)
+    same(1, view.line_count)
+    same(5, view:line_character_count(1))
+    same(case.line_length, view:line_byte_length(1))
+    same(case.line_length, #view:line_encoded_text(1))
+
+    for character_index = 1, #MIXED_CHARACTERS do
+      local column = view:byte_column_for_character_index(1, character_index)
+      same(case.starts[character_index], column)
+      same(
+        character_index,
+        view:character_index_for_byte_column(1, column)
+      )
+      same(MIXED_CHARACTERS[character_index], view:character_at(1, column))
+      local span = view:byte_span_for_character_index(1, character_index)
+      same(case.lengths[character_index], span.byte_length)
+      same(column, span.byte_start)
+      same(column + span.byte_length - 1, span.byte_end)
+      truthy(view:is_character_start(span.position))
+    end
+  end
+
+  local ascii = text_topology.new({ "plain" }, "utf8")
+  same("utf-8", ascii.encoding)
+  same(5, ascii:line_byte_length(1))
+  same(5, ascii:line_character_count(1))
+  for index = 1, 5 do
+    same(index, ascii:character_index_to_byte_column(1, index))
+    same(index, ascii:byte_column_to_character_index(1, index))
+  end
+end)
+
+test("TextView rejects interior and boundary bytes as character starts", function()
+  local view = text_topology.new({ MIXED_JAPANESE }, "utf-8")
+  local valid = {
+    [1] = true,
+    [2] = true,
+    [5] = true,
+    [8] = true,
+    [11] = true,
+  }
+
+  for column = 1, view:line_byte_length(1) do
+    same(valid[column] == true, view:is_character_start(1, column))
+    if not valid[column] then
+      same(nil, view:try_character_index_for_byte_column(1, column))
+      fails(function()
+        view:character_index_for_byte_column(1, column)
+      end, "inside an editor character")
+    end
+  end
+
+  falsy(view:is_character_start(1, 12))
+  fails(function()
+    view:character_index_for_byte_column(1, 12)
+  end, "does not identify")
+  fails(function()
+    view:byte_column_for_character_index(1, 0)
+  end, "character_index")
+end)
+
+test("TextView treats Nvim grapheme clusters as editor characters", function()
+  local combining = "e\204\129x"
+  local view = text_topology.new({ combining }, "utf-8")
+
+  same(2, view:line_character_count(1))
+  same(4, view:line_byte_length(1))
+  same(1, view:byte_column_for_character_index(1, 1))
+  same(4, view:byte_column_for_character_index(1, 2))
+  same("e\204\129", view:character_at_index(1, 1))
+  falsy(view:is_character_start(1, 2))
+  falsy(view:is_character_start(1, 3))
+end)
+
+test("Forward and backward iteration enumerate reverse character starts", function()
+  local view = text_topology.new({
+    "a\227\129\130",
+    "",
+    "\239\189\178z",
+  }, "utf-8")
+
+  local forward, characters, spans = collect_iteration(view:iter_buffer_forward())
+  list_same({ "(1,1)", "(1,2)", "(3,1)", "(3,4)" }, position_strings(forward))
+  list_same({ "a", "\227\129\130", "\239\189\178", "z" }, characters)
+  for index, position in ipairs(forward) do
+    truthy(view:is_character_start(position))
+    same(position, spans[index].position)
+  end
+
+  local backward = collect_iteration(view:iter_buffer_backward())
+  list_same({ "(3,4)", "(3,1)", "(1,2)", "(1,1)" }, position_strings(backward))
+
+  local line_forward = collect_iteration(view:iter_line_forward(1))
+  local line_backward = collect_iteration(view:iter_line_backward(1))
+  list_same({ "(1,1)", "(1,2)" }, position_strings(line_forward))
+  list_same({ "(1,2)", "(1,1)" }, position_strings(line_backward))
+end)
+
+test("Bounded iterators include and stop at their selected boundaries", function()
+  local view = text_topology.new({ "ab", "cd", "ef" }, "utf-8")
+  local first = domain.Position.new(1, 2)
+  local last = domain.Position.new(3, 1)
+
+  local forward = collect_iteration(view:iter_forward(first, last))
+  list_same({ "(1,2)", "(2,1)", "(2,2)", "(3,1)" }, position_strings(forward))
+  local backward = collect_iteration(view:iter_backward(last, first))
+  list_same({ "(3,1)", "(2,2)", "(2,1)", "(1,2)" }, position_strings(backward))
+
+  fails(function()
+    view:iter_forward(last, first)
+  end, "must not follow")
+  fails(function()
+    view:iter_backward(first, last)
+  end, "must not precede")
+  fails(function()
+    view:iter_forward(domain.Position.new(1, 3), last)
+  end, "must start an editor character")
+end)
+
+test("Strict-side iteration obeys line and buffer match-start bounds", function()
+  local view = text_topology.new({ "abc", "", "def" }, "utf-8")
+  local origin = domain.Position.new(1, 2)
+
+  local line_forward = collect_iteration(view:iter_strict_forward(
+    origin,
+    domain.SearchScope.CURRENT_LINE
+  ))
+  list_same({ "(1,3)" }, position_strings(line_forward))
+
+  local buffer_forward = collect_iteration(view:iter_strict_forward(
+    origin,
+    domain.SearchScope.BUFFER
+  ))
+  list_same({ "(1,3)", "(3,1)", "(3,2)", "(3,3)" }, position_strings(buffer_forward))
+
+  local line_backward = collect_iteration(view:iter_strict_backward(
+    origin,
+    "current_line"
+  ))
+  list_same({ "(1,1)" }, position_strings(line_backward))
+
+  local buffer_backward = collect_iteration(view:iter_strict_backward(
+    domain.Position.new(3, 2),
+    "buffer"
+  ))
+  list_same({ "(3,1)", "(1,3)", "(1,2)", "(1,1)" }, position_strings(buffer_backward))
+
+  local empty_line_bounds = view:line_match_start_bounds(2)
+  truthy(empty_line_bounds.empty)
+  same(nil, empty_line_bounds.first)
+  same(nil, empty_line_bounds.last)
+  same(0, #position_strings(collect_iteration(view:iter_line_forward(2))))
+  same(0, #position_strings(collect_iteration(view:iter_strict_forward(
+    domain.Position.new(2, 1),
+    "current_line"
+  ))))
+
+  local buffer_bounds = view:match_start_bounds("buffer")
+  falsy(buffer_bounds.empty)
+  same(domain.Position.new(1, 1), buffer_bounds.first)
+  same(domain.Position.new(3, 3), buffer_bounds.last)
+  truthy(buffer_bounds:contains(domain.Position.new(2, 1)))
+end)
+
+test("Endpoint adjacency crosses lines and normalizes cursor boundaries", function()
+  local view = text_topology.new({
+    "a\227\129\130",
+    "",
+    "\239\189\178z",
+  }, "utf-8")
+
+  same(nil, view:predecessor(domain.Position.new(1, 1)))
+  same(domain.Position.new(1, 1), view:predecessor(domain.Position.new(1, 2)))
+  same(domain.Position.new(2, 1), view:successor(domain.Position.new(1, 2)))
+  same(domain.Position.new(1, 2), view:predecessor(domain.Position.new(2, 1)))
+  same(domain.Position.new(3, 1), view:successor(domain.Position.new(2, 1)))
+  same(domain.Position.new(2, 1), view:predecessor(domain.Position.new(3, 1)))
+  same(domain.Position.new(3, 4), view:successor(domain.Position.new(3, 1)))
+  same(nil, view:successor(domain.Position.new(3, 4)))
+
+  same(domain.Position.new(1, 2), view:normalize_endpoint(1, 3))
+  same(domain.Position.new(1, 2), view:normalize_endpoint(1, 5))
+  same(domain.Position.new(2, 1), view:normalize_endpoint(2, 7))
+  truthy(view:is_valid_cursor_position(view:normalize_endpoint(1, 3)))
+  truthy(view:is_valid_cursor_position(view:normalize_endpoint(2, 7)))
+
+  fails(function()
+    view:successor(domain.Position.new(1, 3))
+  end, "inside an editor character")
+  fails(function()
+    view:predecessor(domain.Position.new(2, 2))
+  end, "empty line")
+end)
+
+test("TextView creation reads one operation-local snapshot", function()
+  local host = MemoryHost.new({
+    buffer_lines = { "ab" },
+    effective_encoding = "utf-8",
+  })
+  host:clear_operations()
+  local first = text_topology.from_host(host)
+  local operations = host:operations()
+  same(2, #operations)
+  same("read_text", operations[1].operation)
+  same("read_encoding", operations[2].operation)
+
+  host:set_text({ "xyz" })
+  local second = text_topology.from_host(host)
+  same("ab", first:line_text(1))
+  same(2, first:line_character_count(1))
+  same("xyz", second:line_text(1))
+  same(3, second:line_character_count(1))
+  falsy(first == second)
+  fails(function()
+    first.encoding = "cp932"
+  end, "immutable")
+end)
+
+test("All-empty buffers expose empty full-buffer iteration", function()
+  local view = text_topology.new({ "", "", "" }, "utf-8")
+  local bounds = view:buffer_match_start_bounds()
+  truthy(bounds:is_empty())
+  same(nil, bounds.first)
+  same(nil, bounds.last)
+  same(0, #position_strings(collect_iteration(view:iter_buffer_forward())))
+  same(0, #position_strings(collect_iteration(view:iter_buffer_backward())))
+end)
+
 for _, item in ipairs(tests) do
   local ok, failure = xpcall(item.body, debug.traceback)
   if not ok then
@@ -1206,4 +1492,4 @@ for _, item in ipairs(tests) do
   passed = passed + 1
 end
 
-io.stdout:write(string.format("Phase 4: %d tests passed\n", passed))
+io.stdout:write(string.format("Phase 5: %d tests passed\n", passed))