Rename plugin to clever-tee

1 files changed, 250 insertions, 0 deletions

diff --git a/lua/clever_tee/direct_preview_planner.lua b/lua/clever_tee/direct_preview_planner.lua
new file mode 100644
index 0000000..699fcf4
--- /dev/null
+++ b/lua/clever_tee/direct_preview_planner.lua
@@ -0,0 +1,250 @@
+local case_policy = require("clever_tee.case_policy")
+local domain = require("clever_tee.domain")
+local text_topology = require("clever_tee.text_topology")
+
+local M = {}
+local DirectPreviewPlanner = {}
+DirectPreviewPlanner.__index = DirectPreviewPlanner
+M.DirectPreviewPlanner = DirectPreviewPlanner
+
+local planner_records = setmetatable({}, { __mode = "k" })
+
+local function fail(message, level)
+  error(message, (level or 1) + 1)
+end
+
+local function require_view(view)
+  if not text_topology.TextView.is(view) then
+    fail("direct preview text must be a TextView", 3)
+  end
+  return view
+end
+
+local function require_case_resolver(options)
+  options = options or {}
+  if type(options) == "function" then
+    options = { lowercase = options }
+  end
+  if type(options) ~= "table" then
+    fail("DirectPreviewPlanner options must be a table", 3)
+  end
+  local resolver = options.case_resolver
+  if resolver == nil then
+    resolver = case_policy.new({ lowercase = options.lowercase })
+  end
+  if type(resolver) ~= "table" or type(resolver.lowercase) ~= "function" then
+    fail("DirectPreviewPlanner case resolver must provide lowercase", 3)
+  end
+  return resolver
+end
+
+function DirectPreviewPlanner.new(options)
+  if DirectPreviewPlanner.is(options) then
+    return options
+  end
+  local planner = setmetatable({}, DirectPreviewPlanner)
+  planner_records[planner] = {
+    case_resolver = require_case_resolver(options),
+  }
+  return planner
+end
+
+function DirectPreviewPlanner.is(value)
+  return type(value) == "table" and planner_records[value] ~= nil
+end
+
+function DirectPreviewPlanner:scan_current_line(view, origin, direction)
+  require_view(view)
+  origin = domain.Position.coerce(origin)
+  direction = domain.Direction.from_string(direction)
+  local records = {}
+  for position, character, span in view:iter_strict(
+    origin,
+    direction,
+    domain.SearchScope.CURRENT_LINE
+  ) do
+    records[#records + 1] = {
+      position = position,
+      character = character,
+      span = span,
+    }
+  end
+  return records
+end
+
+function M.marker_position(descriptor, target_position)
+  domain.Descriptor.from_string(descriptor)
+  return domain.Position.coerce(target_position)
+end
+
+function M.normalize_count(count)
+  return domain.Count.to_number(count)
+end
+
+function DirectPreviewPlanner:normalize_count(count)
+  return M.normalize_count(count)
+end
+
+function M.direction_for_descriptor(descriptor)
+  descriptor = domain.Descriptor.from_string(descriptor)
+  if domain.Descriptor.is_uppercase(descriptor) then
+    return domain.Direction.BACKWARD
+  end
+  return domain.Direction.FORWARD
+end
+
+function DirectPreviewPlanner:scan_for_descriptor(view, origin, descriptor)
+  return self:scan_current_line(
+    view,
+    origin,
+    M.direction_for_descriptor(descriptor)
+  )
+end
+
+local function increment_counter(counters, character)
+  local value = (counters[character] or 0) + 1
+  counters[character] = value
+  return value
+end
+
+local function is_upper_ascii(character)
+  if type(character) ~= "string" or #character ~= 1 then
+    return false
+  end
+  local code = character:byte(1)
+  return code >= string.byte("A") and code <= string.byte("Z")
+end
+
+local function increment_smart_counters(counters, character)
+  local exact_count = increment_counter(counters, character)
+  local lowercase_count
+  if is_upper_ascii(character) then
+    local lowercase = string.char(character:byte(1) + 32)
+    lowercase_count = increment_counter(counters, lowercase)
+  end
+  return exact_count, lowercase_count
+end
+
+M.is_upper_ascii = is_upper_ascii
+
+local function require_case_setting(settings, name)
+  local value = settings[name]
+  if value == nil then
+    return false
+  end
+  if type(value) ~= "boolean" then
+    fail("direct preview " .. name .. " must be a Boolean", 3)
+  end
+  return value
+end
+
+function M.case_grouping_settings(settings)
+  settings = settings or {}
+  if type(settings) ~= "table" then
+    fail("direct preview case settings must be a table", 2)
+  end
+  return {
+    ignore_case = require_case_setting(settings, "ignore_case"),
+    smart_case = require_case_setting(settings, "smart_case"),
+  }
+end
+
+function M.validate_marker_positions(view, positions)
+  require_view(view)
+  if type(positions) ~= "table" then
+    fail("direct preview markers must be a list of positions", 2)
+  end
+
+  local result = {}
+  local seen = {}
+  local item_count = 0
+  for key, position in pairs(positions) do
+    if type(key) ~= "number"
+      or key ~= math.floor(key)
+      or key < 1
+      or key > #positions
+    then
+      fail("direct preview markers must be a list of positions", 2)
+    end
+    position = domain.Position.coerce(position)
+    if not view:is_character_start(position) then
+      fail("direct preview marker must start an editor character", 2)
+    end
+    local identity = tostring(position.line) .. ":" .. tostring(position.byte_column)
+    if seen[identity] then
+      fail("direct preview marker positions must be unique", 2)
+    end
+    seen[identity] = true
+    result[key] = position
+    item_count = item_count + 1
+  end
+  if item_count ~= #positions then
+    fail("direct preview markers must be a list of positions", 2)
+  end
+  return result
+end
+
+function DirectPreviewPlanner:plan(view, origin, descriptor, count, settings)
+  local grouping = M.case_grouping_settings(settings)
+  local ignore_case = grouping.ignore_case
+  local smart_case = grouping.smart_case
+  local selected_occurrence = self:normalize_count(count)
+  local counters = {}
+  local positions = {}
+  local resolver = planner_records[self].case_resolver
+  for _, record in ipairs(self:scan_for_descriptor(view, origin, descriptor)) do
+    local selected
+    if ignore_case then
+      selected = increment_counter(
+        counters,
+        resolver:lowercase(record.character)
+      ) == selected_occurrence
+    elseif smart_case then
+      local exact_count, lowercase_count = increment_smart_counters(
+        counters,
+        record.character
+      )
+      selected = exact_count == selected_occurrence
+        or lowercase_count == selected_occurrence
+    else
+      selected = increment_counter(
+        counters,
+        record.character
+      ) == selected_occurrence
+    end
+    if selected then
+      positions[#positions + 1] = M.marker_position(descriptor, record.position)
+    end
+  end
+  return M.validate_marker_positions(view, positions)
+end
+
+function M.new(options)
+  return DirectPreviewPlanner.new(options)
+end
+
+function M.scan_current_line(view, origin, direction)
+  return DirectPreviewPlanner.new():scan_current_line(view, origin, direction)
+end
+
+function M.scan_for_descriptor(view, origin, descriptor)
+  return DirectPreviewPlanner.new():scan_for_descriptor(view, origin, descriptor)
+end
+
+function M.plan(view, origin, descriptor, count, settings, options)
+  return DirectPreviewPlanner.new(options):plan(
+    view,
+    origin,
+    descriptor,
+    count,
+    settings
+  )
+end
+
+setmetatable(M, {
+  __call = function(_, options)
+    return DirectPreviewPlanner.new(options)
+  end,
+})
+
+return M