diff options
Diffstat (limited to 'lua/clever_tee')
22 files changed, 11862 insertions, 0 deletions
diff --git a/lua/clever_tee/acquisition_service.lua b/lua/clever_tee/acquisition_service.lua new file mode 100644 index 0000000..6e91159 --- /dev/null +++ b/lua/clever_tee/acquisition_service.lua @@ -0,0 +1,927 @@ +local domain = require("clever_tee.domain") +local direct_preview_planner = require("clever_tee.direct_preview_planner") +local feedback_service = require("clever_tee.feedback_service") +local motion_plan_factory = require("clever_tee.motion_plan") +local policy = require("clever_tee.policy") +local sequence_state = require("clever_tee.sequence_state") +local state_transitions = require("clever_tee.state_transitions") +local target_plan_factory = require("clever_tee.target_plan") +local text_topology = require("clever_tee.text_topology") + +local M = {} +local AcquisitionRequest = {} +local AcquisitionResult = {} +local AcquisitionService = {} +local TemporaryResourceScope = {} +AcquisitionService.__index = AcquisitionService +M.AcquisitionRequest = AcquisitionRequest +M.AcquisitionResult = AcquisitionResult +M.AcquisitionService = AcquisitionService +M.TemporaryResourceScope = TemporaryResourceScope +M.RepeatedDirection = { + SAME = "same", +} +M.PROMPT = "clever-tee: " +M.PREVIOUS_INPUT_NOT_FOUND = "Previous input not found." + +local request_records = setmetatable({}, { __mode = "k" }) +local result_records = setmetatable({}, { __mode = "k" }) +local service_records = setmetatable({}, { __mode = "k" }) +local scope_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function normalize_macro_state(value) + if type(value) == "table" and not domain.MacroState.is(value) then + value = value.register + end + return domain.MacroState.new(value) +end + +local request_metatable = { + __index = function(request, key) + local method = AcquisitionRequest[key] + if method ~= nil then + return method + end + return request_records[request][key] + end, + __newindex = function() + fail("AcquisitionRequest values are immutable", 2) + end, + __tostring = function(request) + return "acquisition-request:" .. request_records[request].descriptor.value + end, + __metatable = "clever_tee.acquisition_service.AcquisitionRequest", +} + +function AcquisitionRequest.new(descriptor, context, position, count, macro_state) + if AcquisitionRequest.is(descriptor) then + return descriptor + end + if type(descriptor) == "table" and not domain.Descriptor.is(descriptor) then + local options = descriptor + descriptor = options.descriptor + context = options.context + position = options.position or options.origin + count = options.count + macro_state = options.macro_state + end + + local request = setmetatable({}, request_metatable) + request_records[request] = { + descriptor = domain.Descriptor.from_string(descriptor), + context = domain.ModeContext.from_full_mode(context), + position = domain.Position.coerce(position), + count = domain.Count.new(count), + macro_state = normalize_macro_state(macro_state), + repeated_direction = M.RepeatedDirection.SAME, + } + return request +end + +function AcquisitionRequest.is(value) + return type(value) == "table" and request_records[value] ~= nil +end + +function AcquisitionRequest:to_table() + return { + descriptor = self.descriptor.value, + context = self.context.key, + position = self.position:to_table(), + count = self.count.value, + macro_register = self.macro_state.register, + repeated_direction = self.repeated_direction, + } +end + +local result_metatable = { + __index = function(result, key) + local method = AcquisitionResult[key] + if method ~= nil then + return method + end + return result_records[result][key] + end, + __newindex = function() + fail("AcquisitionResult values are immutable", 2) + end, + __tostring = function(result) + local outcome = result_records[result].outcome + return outcome and tostring(outcome) or "acquisition:resolved" + end, + __metatable = "clever_tee.acquisition_service.AcquisitionResult", +} + +function AcquisitionResult.new(request, options) + if AcquisitionResult.is(request) and options == nil then + return request + end + if not AcquisitionRequest.is(request) then + fail("acquisition result requires an AcquisitionRequest", 2) + end + options = options or {} + if type(options) ~= "table" then + fail("acquisition result options must be a table", 2) + end + local outcome = options.outcome + if outcome ~= nil and not domain.ActionOutcome.is(outcome) then + fail("acquisition result outcome must be an ActionOutcome", 2) + end + local target = options.target + if target ~= nil and not domain.TargetValue.is(target) then + fail("acquisition result target must be a TargetValue", 2) + end + local target_plan = options.target_plan + if target_plan ~= nil and not domain.TargetPlan.is(target_plan) then + fail("acquisition result target_plan must be a TargetPlan", 2) + end + local motion_plan = options.motion_plan + if motion_plan ~= nil and not domain.ResolvedMotionPlan.is(motion_plan) then + fail("acquisition result motion_plan must be a ResolvedMotionPlan", 2) + end + local result = setmetatable({}, result_metatable) + result_records[result] = { + request = request, + outcome = outcome, + target = target, + target_plan = target_plan, + motion_plan = motion_plan, + resolved_motion_plan = motion_plan, + previous_input_trigger = options.previous_input_trigger, + previous_target_source = options.previous_target_source, + cached_target = options.cached_target, + missing_previous_input = options.missing_previous_input == true, + acquisition_time_ms = options.acquisition_time_ms, + persistent_feedback_request = options.persistent_feedback_request, + resolved = target ~= nil and target_plan ~= nil and motion_plan ~= nil, + completed = outcome ~= nil + or (target ~= nil and target_plan ~= nil and motion_plan ~= nil), + } + return result +end + +function AcquisitionResult.is(value) + return type(value) == "table" and result_records[value] ~= nil +end + +function AcquisitionResult:has_outcome() + return self.outcome ~= nil +end + +function AcquisitionResult:resolved_values() + return self.target, self.target_plan, self.motion_plan +end + +AcquisitionResult.unpack = AcquisitionResult.resolved_values + +local scope_metatable = { + __index = function(scope, key) + local method = TemporaryResourceScope[key] + if method ~= nil then + return method + end + return scope_records[scope][key] + end, + __newindex = function() + fail("TemporaryResourceScope values are read-only", 2) + end, + __metatable = "clever_tee.acquisition_service.TemporaryResourceScope", +} + +function TemporaryResourceScope.new(request, feedback, host) + if not AcquisitionRequest.is(request) then + fail("temporary resource scope requires an AcquisitionRequest", 2) + end + local scope = setmetatable({}, scope_metatable) + scope_records[scope] = { + request = request, + feedback = feedback, + host = host, + active = true, + interactive = not request.macro_state.executing, + prompt_shown = false, + input_completed = false, + acquisition_completed = false, + cursor_marker = nil, + direct_marker = nil, + cursor_presentation_lease = nil, + input_packet = nil, + acquired_target = nil, + resolved_target = nil, + previous_input_trigger = nil, + previous_target_source = nil, + cached_target = nil, + missing_previous_input = false, + text_view = nil, + target_plan = nil, + motion_plan = nil, + outcome = nil, + } + return scope +end + +function TemporaryResourceScope.is(value) + return type(value) == "table" and scope_records[value] ~= nil +end + +local function set_scope_resource(scope, field, resource) + local record = scope_records[scope] + if record == nil or not record.active then + fail("temporary resource scope must be active", 3) + end + record[field] = resource + return resource +end + +function TemporaryResourceScope:set_cursor_marker(marker) + return set_scope_resource(self, "cursor_marker", marker) +end + +function TemporaryResourceScope:set_direct_marker(marker) + return set_scope_resource(self, "direct_marker", marker) +end + +function TemporaryResourceScope:set_cursor_presentation_lease(lease) + return set_scope_resource(self, "cursor_presentation_lease", lease) +end + +function TemporaryResourceScope:set_input_packet(packet) + return set_scope_resource(self, "input_packet", packet) +end + +function TemporaryResourceScope:request_redraw(kind) + local record = scope_records[self] + if record == nil then + fail("temporary resource scope is invalid", 2) + end + if not record.interactive then + return false + end + record.host:redraw(kind) + return true +end + +function TemporaryResourceScope:mark_prompt_shown() + return set_scope_resource(self, "prompt_shown", true) +end + +function TemporaryResourceScope:mark_input_completed() + return set_scope_resource(self, "input_completed", true) +end + +function TemporaryResourceScope:mark_acquisition_completed() + return set_scope_resource(self, "acquisition_completed", true) +end + +function TemporaryResourceScope:set_acquired_target(target) + return set_scope_resource(self, "acquired_target", target) +end + +function TemporaryResourceScope:set_resolved_target(target) + return set_scope_resource(self, "resolved_target", target) +end + +function TemporaryResourceScope:set_previous_input_trigger(trigger) + return set_scope_resource(self, "previous_input_trigger", trigger) +end + +function TemporaryResourceScope:set_cached_target(context, target) + set_scope_resource(self, "previous_target_source", context) + return set_scope_resource(self, "cached_target", target) +end + +function TemporaryResourceScope:set_missing_previous_input(missing) + if type(missing) ~= "boolean" then + fail("missing previous-input state must be a Boolean", 2) + end + return set_scope_resource(self, "missing_previous_input", missing) +end + +function TemporaryResourceScope:set_text_view(view) + if not text_topology.TextView.is(view) then + fail("temporary resource scope text must be a TextView", 2) + end + return set_scope_resource(self, "text_view", view) +end + +function TemporaryResourceScope:set_target_plan(target_plan) + if not domain.TargetPlan.is(target_plan) then + fail("temporary resource scope target plan must be a TargetPlan", 2) + end + return set_scope_resource(self, "target_plan", target_plan) +end + +function TemporaryResourceScope:set_motion_plan(motion_plan) + if not domain.ResolvedMotionPlan.is(motion_plan) then + fail("temporary resource scope motion plan must be a ResolvedMotionPlan", 2) + end + return set_scope_resource(self, "motion_plan", motion_plan) +end + +function TemporaryResourceScope:set_outcome(outcome) + if not domain.ActionOutcome.is(outcome) then + fail("temporary resource scope outcome must be an ActionOutcome", 2) + end + return set_scope_resource(self, "outcome", outcome) +end + +function TemporaryResourceScope:release() + local record = scope_records[self] + if record == nil then + fail("temporary resource scope is invalid", 2) + end + if not record.active then + return false + end + record.active = false + + local first_error + local function release_operation(operation) + local ok, failure = pcall(operation) + if not ok and first_error == nil then + first_error = failure + end + end + + if record.interactive + and record.prompt_shown + and record.input_completed + and record.acquisition_completed + then + release_operation(function() + self:request_redraw("full") + end) + end + if record.direct_marker ~= nil then + release_operation(function() + record.feedback:remove_temporary_overlay(record.direct_marker) + end) + end + if record.cursor_marker ~= nil then + release_operation(function() + record.feedback:remove_temporary_overlay(record.cursor_marker) + end) + end + if record.cursor_presentation_lease ~= nil then + release_operation(function() + record.cursor_presentation_lease:release() + end) + end + if first_error ~= nil then + error(first_error, 0) + end + return true +end + +local function require_policy(service, host) + service = service or policy.new(host) + if type(service) ~= "table" or type(service.sample_acquisition) ~= "function" then + fail("AcquisitionService policy must sample acquisition settings", 3) + end + return service +end + +local function require_state(state) + state = state or sequence_state.get() + if not sequence_state.is(state) then + fail("AcquisitionService state must be the plugin-global SequenceState", 3) + end + return state +end + +local function require_transitions(transitions, state) + transitions = transitions or state_transitions.new(state) + if type(transitions) ~= "table" + or type(transitions.BeginAcquisition) ~= "function" + or type(transitions.CommitAcquiredTarget) ~= "function" + then + fail("AcquisitionService transitions must commit acquisition state", 3) + end + return transitions +end + +local function require_direct_planner(planner) + planner = planner or direct_preview_planner.new() + if type(planner) ~= "table" or type(planner.plan) ~= "function" then + fail("AcquisitionService direct planner must provide plan", 3) + end + return planner +end + +local function require_target_factory(factory, policy_service) + factory = factory or target_plan_factory.new({ policy = policy_service }) + if type(factory) ~= "table" or type(factory.build) ~= "function" then + fail("AcquisitionService target factory must provide build", 3) + end + return factory +end + +local function require_motion_factory(factory, policy_service) + factory = factory or motion_plan_factory.new({ policy = policy_service }) + if type(factory) ~= "table" or type(factory.build_for_context) ~= "function" then + fail("AcquisitionService motion factory must build contextual plans", 3) + end + return factory +end + +local function require_feedback(feedback, host, policy_service, transitions) + feedback = feedback or feedback_service.new({ + host = host, + policy = policy_service, + transitions = transitions, + }) + if type(feedback) ~= "table" + or type(feedback.create_cursor_marker) ~= "function" + or type(feedback.request_persistent) ~= "function" + then + fail("AcquisitionService feedback must manage acquisition markers", 3) + end + return feedback +end + +local function normalize_options(options, dependencies) + if AcquisitionService.is(options) and dependencies == nil then + return options + end + if type(options) ~= "table" then + fail("AcquisitionService options must be a table", 3) + end + if options.host ~= nil then + if dependencies ~= nil then + fail("AcquisitionService dependencies must be part of its options", 3) + end + return options + end + local result = {} + for key, value in pairs(dependencies or {}) do + result[key] = value + end + result.host = options + return result +end + +function AcquisitionService.new(options, dependencies) + options = normalize_options(options, dependencies) + if AcquisitionService.is(options) then + return options + end + if type(options.host) ~= "table" then + fail("AcquisitionService host must be a table", 2) + end + local state = require_state(options.state) + local transitions = require_transitions( + options.transitions or options.state_transitions, + state + ) + local policy_service = require_policy( + options.policy or options.policy_service, + options.host + ) + local service = setmetatable({}, AcquisitionService) + service_records[service] = { + host = options.host, + policy = policy_service, + state = state, + transitions = transitions, + feedback = require_feedback( + options.feedback or options.feedback_service, + options.host, + policy_service, + transitions + ), + direct_planner = require_direct_planner( + options.direct_planner or options.direct_preview_planner + ), + target_factory = require_target_factory( + options.target_factory or options.target_plan_factory, + policy_service + ), + motion_factory = require_motion_factory( + options.motion_factory or options.motion_plan_factory, + policy_service + ), + window = options.window or options.current_window, + last_scope = nil, + started_scope_count = 0, + } + return service +end + +function AcquisitionService.is(value) + return type(value) == "table" and service_records[value] ~= nil +end + +function AcquisitionService:request(descriptor, context, position, count, macro_state) + return AcquisitionRequest.new(descriptor, context, position, count, macro_state) +end + +local function current_window(record) + local window = record.window + if type(window) == "function" then + window = window() + end + if window == nil and type(record.host.read_window) == "function" then + window = record.host:read_window() + end + if window == nil then + fail("AcquisitionService requires a current window identity", 3) + end + return window +end + +function AcquisitionService:start_temporary_scope(request) + request = AcquisitionRequest.new(request) + local record = service_records[self] + local scope = TemporaryResourceScope.new(request, record.feedback, record.host) + record.last_scope = scope + record.started_scope_count = record.started_scope_count + 1 + return scope +end + +function AcquisitionService:last_temporary_scope() + return service_records[self].last_scope +end + +function AcquisitionService:started_scope_count() + return service_records[self].started_scope_count +end + +local function utf8_first_code(character) + local first = string.byte(character, 1) + if first < 0x80 then + return first + end + local length + local code + if first >= 0xc2 and first <= 0xdf then + length = 2 + code = first - 0xc0 + elseif first >= 0xe0 and first <= 0xef then + length = 3 + code = first - 0xe0 + elseif first >= 0xf0 and first <= 0xf4 then + length = 4 + code = first - 0xf0 + else + fail("ordinary input must start with a valid editor character", 3) + end + for index = 2, length do + local byte = string.byte(character, index) + if byte == nil or byte < 0x80 or byte > 0xbf then + fail("ordinary input must contain a complete editor character", 3) + end + code = code * 0x40 + byte - 0x80 + end + return code +end + +local function first_editor_character(text) + local characters = text_topology.split_editor_characters(text) + if #characters == 0 then + fail("ordinary input must contain an editor character", 3) + end + return characters[1] +end + +function M.editor_character_code(character) + character = first_editor_character(character) + local runtime = rawget(_G, "vim") + if type(runtime) == "table" + and type(runtime.fn) == "table" + and type(runtime.fn.char2nr) == "function" + then + return runtime.fn.char2nr(character) + end + return utf8_first_code(character) +end + +function M.normalize_ordinary_input(packet) + packet = domain.InputPacket.from_table(packet) + local text + if packet.kind == domain.InputPacketKind.TEXT then + text = packet.text + elseif packet.kind == domain.InputPacketKind.RAW_BYTES then + local bytes = packet:bytes() + local characters = {} + for index = 1, #bytes do + characters[index] = string.char(bytes[index]) + end + text = table.concat(characters) + else + fail("ordinary input packet must contain text or raw bytes", 2) + end + local character = first_editor_character(text) + return domain.TargetValue.character( + character, + M.editor_character_code(character) + ) +end + +local function encoded_packet_value(packet) + if packet.encoded ~= nil then + return packet.encoded + end + local bytes = packet:bytes() + if bytes == nil then + return nil + end + local characters = {} + for index = 1, #bytes do + characters[index] = string.char(bytes[index]) + end + return table.concat(characters) +end + +function M.normalize_input_packet(packet) + packet = domain.InputPacket.from_table(packet) + if packet.kind == domain.InputPacketKind.ERROR then + fail(packet.message, 2) + end + if packet.kind == domain.InputPacketKind.TEXT then + return M.normalize_ordinary_input(packet) + end + + local encoded = encoded_packet_value(packet) + if encoded == nil then + return domain.TargetValue.code_fallback(0) + end + if string.byte(encoded, 1) == 0x80 then + return domain.TargetValue.special_key(encoded, 0x80) + end + return M.normalize_ordinary_input(domain.InputPacket.text(encoded)) +end + +function M.read_previous_target(state) + if not sequence_state.is(state) then + fail("previous-input reuse requires SequenceState", 2) + end + local context = state.last_input_context + if context == nil then + return nil, nil + end + return state:get_previous_target(context), context +end + +function M.match_previous_input_trigger(first_code, triggers) + if type(first_code) ~= "number" or first_code < 0 then + fail("acquired first code must be nonnegative", 2) + end + if type(triggers) ~= "table" then + fail("previous-input triggers must be a list", 2) + end + for index, trigger in ipairs(triggers) do + if type(trigger) ~= "string" then + fail("previous-input triggers must contain strings", 2) + end + if trigger ~= "" and M.editor_character_code(trigger) == first_code then + return trigger, index + end + end + return nil +end + +function M.is_escape(packet) + packet = domain.InputPacket.from_table(packet) + if packet.kind == domain.InputPacketKind.SPECIAL_KEY + and (packet.name == "Escape" or packet.name == "Esc") + then + return true + end + if packet.kind == domain.InputPacketKind.TEXT then + return packet.text == string.char(27) + end + local bytes = packet:bytes() + return bytes ~= nil and #bytes == 1 and bytes[1] == 27 +end + +function M.is_terminal_artifact(packet) + packet = domain.InputPacket.from_table(packet) + if packet.kind ~= domain.InputPacketKind.RAW_BYTES then + return false + end + local bytes = packet:bytes() + return #bytes == 3 + and bytes[1] == 0x80 + and bytes[2] == 0xfd + and bytes[3] == 0x60 +end + +local function read_input_packet(host) + while true do + local packet = domain.InputPacket.from_table(host:read_input()) + if not M.is_terminal_artifact(packet) then + return packet + end + end +end + +local function direct_preview_settings(policy_service) + if type(policy_service.sample_direct_preview) == "function" then + return policy_service:sample_direct_preview() + end + if type(policy_service.get_boolean) == "function" then + return { + ignore_case = policy_service:get_boolean("ignore_case"), + smart_case = policy_service:get_boolean("smart_case"), + } + end + fail("AcquisitionService policy must sample direct preview settings", 3) +end + +local function acquire_in_scope(record, request, scope) + local acquisition = record.policy:sample_acquisition() + local interactive = not request.macro_state.executing + scope:set_cursor_presentation_lease( + record.feedback:create_cursor_presentation_lease( + interactive and acquisition.hide_cursor_on_cmdline + ) + ) + if not interactive then + record.host:redraw("suppressed") + end + if acquisition.mark_cursor and interactive then + scope:set_cursor_marker(record.feedback:create_cursor_marker( + request.position, + current_window(record) + )) + scope:request_redraw("screen") + end + if acquisition.mark_direct and interactive then + local view = scope:set_text_view(text_topology.from_host(record.host)) + local positions = record.direct_planner:plan( + view, + request.position, + request.descriptor, + request.count, + direct_preview_settings(record.policy) + ) + local window = scope.cursor_marker + and scope.cursor_marker.window + or current_window(record) + scope:set_direct_marker(record.feedback:create_direct_markers( + positions, + window + )) + scope:request_redraw("screen") + end + if acquisition.show_prompt and interactive then + record.host:show_prompt(M.PROMPT) + scope:mark_prompt_shown() + end + record.transitions:BeginAcquisition(request.context, request.descriptor) + local packet = scope:set_input_packet(read_input_packet(record.host)) + scope:mark_input_completed() + if M.is_escape(packet) then + local outcome = scope:set_outcome(domain.ActionOutcome.escape(request.position)) + return AcquisitionResult.new(request, { outcome = outcome }) + end + local target = scope:set_acquired_target(M.normalize_input_packet(packet)) + local previous_input = record.policy:sample_previous_input() + local trigger = scope:set_previous_input_trigger( + M.match_previous_input_trigger( + target.first_code, + previous_input.repeat_last_char_inputs + ) + ) + if trigger ~= nil then + local cached_target, source = M.read_previous_target(record.state) + scope:set_cached_target(source, cached_target) + if cached_target ~= nil then + target = cached_target + else + target = nil + scope:set_missing_previous_input(true) + record.host:emit_diagnostic("error", M.PREVIOUS_INPUT_NOT_FOUND) + local outcome = scope:set_outcome( + domain.ActionOutcome.empty(request.position) + ) + return AcquisitionResult.new(request, { + outcome = outcome, + previous_input_trigger = trigger, + previous_target_source = scope.previous_target_source, + missing_previous_input = true, + }) + end + end + scope:set_resolved_target(target) + local acquisition_time_ms + if record.policy:sample_timeouts().repeat_timeout_ms > 0 then + acquisition_time_ms = record.host:read_time_ms() + end + record.transitions:CommitAcquiredTarget( + request.context, + target, + acquisition_time_ms + ) + local view = scope.text_view + or scope:set_text_view(text_topology.from_host(record.host)) + local search_scope = record.policy:sample_search().search_scope + local target_plan = scope:set_target_plan(record.target_factory:build( + target, + nil, + { + text_view = view, + origin = request.position, + search_scope = search_scope, + effective_encoding = view.effective_encoding, + } + )) + local selection = request.context.visual and record.host:read_selection() or nil + local motion_plan = scope:set_motion_plan( + record.motion_factory:build_for_context( + target_plan, + request.descriptor, + request.context, + selection, + search_scope + ) + ) + local persistent_feedback_request + if interactive + and record.policy:sample_markers().mark_char + and feedback_service.persistent_context_eligible(request.context) + then + local window = scope.cursor_marker + and scope.cursor_marker.window + or scope.direct_marker + and scope.direct_marker.window + or current_window(record) + persistent_feedback_request = record.feedback:request_persistent({ + context = request.context, + anchor = request.position, + target_plan = target_plan, + motion_plan = motion_plan, + window = window, + }) + end + local result = AcquisitionResult.new(request, { + target = target, + target_plan = target_plan, + motion_plan = motion_plan, + acquisition_time_ms = acquisition_time_ms, + persistent_feedback_request = persistent_feedback_request, + previous_input_trigger = trigger, + previous_target_source = scope.previous_target_source, + cached_target = scope.cached_target, + missing_previous_input = scope.missing_previous_input, + }) + scope:mark_acquisition_completed() + return result +end + +local function error_message(failure) + local message = tostring(failure) + if message == "" then + return "clever-tee: Acquisition failed" + end + return message +end + +function AcquisitionService:acquire(descriptor, context, position, count, macro_state) + local request = self:request(descriptor, context, position, count, macro_state) + local scope = self:start_temporary_scope(request) + local record = service_records[self] + local ok, result = xpcall(function() + return acquire_in_scope(record, request, scope) + end, function(failure) + return failure + end) + + if not ok then + local diagnostic = error_message(result) + result = AcquisitionResult.new(request, { + outcome = domain.ActionOutcome.error(request.position, diagnostic), + }) + end + + local cleanup_ok, cleanup_error = pcall(function() + scope:release() + end) + if not cleanup_ok and ok then + local diagnostic = error_message(cleanup_error) + result = AcquisitionResult.new(request, { + outcome = domain.ActionOutcome.error(request.position, diagnostic), + }) + ok = false + end + + if not ok then + pcall(record.host.emit_diagnostic, record.host, "error", result.outcome.diagnostic) + end + return result +end + +function M.new(options, dependencies) + return AcquisitionService.new(options, dependencies) +end + +setmetatable(M, { + __call = function(_, options, dependencies) + return AcquisitionService.new(options, dependencies) + end, +}) + +return M diff --git a/lua/clever_tee/action_facade.lua b/lua/clever_tee/action_facade.lua new file mode 100644 index 0000000..fe7a035 --- /dev/null +++ b/lua/clever_tee/action_facade.lua @@ -0,0 +1,134 @@ +local domain = require("clever_tee.domain") +local sequence_coordinator = require("clever_tee.sequence_coordinator") + +local M = {} +local ActionFacade = {} +ActionFacade.__index = ActionFacade +M.ActionFacade = ActionFacade + +local facade_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +function ActionFacade.new(options) + if ActionFacade.is(options) then + return options + end + local coordinator + if sequence_coordinator.SequenceCoordinator.is(options) then + coordinator = options + elseif type(options) == "table" then + coordinator = options.coordinator + or options.sequence_coordinator + or sequence_coordinator.new(options) + else + fail("ActionFacade options must be a table", 2) + end + if not sequence_coordinator.SequenceCoordinator.is(coordinator) then + fail("ActionFacade requires a SequenceCoordinator", 2) + end + + local facade = setmetatable({}, ActionFacade) + facade_records[facade] = { coordinator = coordinator } + return facade +end + +function ActionFacade.is(value) + return type(value) == "table" and facade_records[value] ~= nil +end + +function ActionFacade:coordinator() + return facade_records[self].coordinator +end + +function ActionFacade:primary(descriptor) + local outcome = self:coordinator():primary(descriptor) + if not domain.ActionOutcome.is(outcome) then + fail("SequenceCoordinator must return an ActionOutcome", 2) + end + return outcome +end + +function ActionFacade:invoke_descriptor(value) + local descriptor = sequence_coordinator.validate_primary_descriptor(value) + return self:primary(descriptor) +end + +ActionFacade.invoke_primary = ActionFacade.invoke_descriptor +ActionFacade.start = ActionFacade.invoke_descriptor +ActionFacade.FreeForm = ActionFacade.invoke_descriptor + +function ActionFacade:start_find_forward() + return self:primary("f") +end + +function ActionFacade:start_find_backward() + return self:primary("F") +end + +function ActionFacade:start_till_forward() + return self:primary("t") +end + +function ActionFacade:start_till_backward() + return self:primary("T") +end + +ActionFacade.StartFindForward = ActionFacade.start_find_forward +ActionFacade.StartFindBackward = ActionFacade.start_find_backward +ActionFacade.StartTillForward = ActionFacade.start_till_forward +ActionFacade.StartTillBackward = ActionFacade.start_till_backward + +function ActionFacade:reset() + local outcome = self:coordinator():reset() + if not domain.ActionOutcome.is(outcome) then + fail("SequenceCoordinator must return an ActionOutcome", 2) + end + return outcome +end + +ActionFacade.Reset = ActionFacade.reset + +function ActionFacade:diagnostic_full_reset() + local outcome = self:coordinator():diagnostic_full_reset() + if not domain.ActionOutcome.is(outcome) then + fail("SequenceCoordinator must return an ActionOutcome", 2) + end + return outcome +end + +ActionFacade.DiagnosticFullReset = ActionFacade.diagnostic_full_reset + +local function explicit_outcome(facade, method_name) + local coordinator = facade:coordinator() + local outcome = coordinator[method_name](coordinator) + if not domain.ActionOutcome.is(outcome) then + fail("SequenceCoordinator must return an ActionOutcome", 3) + end + return outcome +end + +function ActionFacade:repeat_same_direction() + return explicit_outcome(self, "repeat_same_direction") +end + +function ActionFacade:repeat_opposite_direction() + return explicit_outcome(self, "repeat_opposite_direction") +end + +ActionFacade.RepeatSameDirection = ActionFacade.repeat_same_direction +ActionFacade.RepeatOppositeDirection = ActionFacade.repeat_opposite_direction + +function M.new(options) + return ActionFacade.new(options) +end + +setmetatable(M, { + __call = function(_, options) + return ActionFacade.new(options) + end, +}) + +return M diff --git a/lua/clever_tee/capabilities.lua b/lua/clever_tee/capabilities.lua new file mode 100644 index 0000000..325d015 --- /dev/null +++ b/lua/clever_tee/capabilities.lua @@ -0,0 +1,163 @@ +local M = {} + +M.read_methods = { + text = { "read_text" }, + buffer = { "read_buffer", "read_window" }, + cursor = { "read_cursor" }, + mode = { "read_mode", "read_pending_operator" }, + selection = { "read_selection" }, + count = { "read_count" }, + configuration = { "read_configuration", "configuration_present" }, + encoding = { "read_encoding" }, + case_conversion = { "lowercase" }, + macro_state = { "read_macro_state" }, + fold_state = { "read_fold_state" }, + time = { "read_time_ms" }, + highlight_groups = { "read_highlight_group" }, +} + +M.effect_methods = { + movement = { "apply_cursor", "apply_selection", "set_operator_inclusive" }, + configuration = { "write_configuration" }, + input = { "read_input" }, + folds = { "open_fold" }, + prompt = { "show_prompt" }, + redraw = { "redraw" }, + diagnostics = { "emit_diagnostic" }, + highlights = { + "define_highlight_group", + "create_highlight", + "remove_highlight", + }, + cursor_presentation = { + "supports_cursor_presentation", + "suppress_cursor_presentation", + "restore_cursor_presentation", + }, + timers = { "supports_timers", "start_timer", "stop_timer" }, + events = { + "register_events", + "remove_event_registration", + "deliver_event", + "begin_action_transition", + "commit_action_transition", + }, + mappings = { "register_action", "register_mapping" }, + dot_repeat = { "register_dot_repeat" }, +} + +local function collect_methods(groups) + local result = {} + local group_names = {} + for group_name in pairs(groups) do + group_names[#group_names + 1] = group_name + end + table.sort(group_names) + for _, group_name in ipairs(group_names) do + for _, method_name in ipairs(groups[group_name]) do + result[#result + 1] = method_name + end + end + return result +end + +local all_methods = collect_methods(M.read_methods) +for _, method_name in ipairs(collect_methods(M.effect_methods)) do + all_methods[#all_methods + 1] = method_name +end +table.sort(all_methods) + +function M.required_methods() + local result = {} + for index = 1, #all_methods do + result[index] = all_methods[index] + end + return result +end + +function M.missing_methods(host) + local missing = {} + for _, method_name in ipairs(all_methods) do + if type(host) ~= "table" or type(host[method_name]) ~= "function" then + missing[#missing + 1] = method_name + end + end + return missing +end + +function M.assert_implements(host) + local missing = M.missing_methods(host) + if #missing > 0 then + error("host is missing semantic capabilities: " .. table.concat(missing, ", "), 2) + end + return host +end + +local EventQueue = {} +EventQueue.__index = EventQueue +M.EventQueue = EventQueue + +function EventQueue.new(deliver) + if type(deliver) ~= "function" then + error("event delivery must be a function", 2) + end + return setmetatable({ + _deliver = deliver, + _active_token = nil, + _pending = {}, + _next_token = 1, + }, EventQueue) +end + +function EventQueue:begin_transition() + if self._active_token ~= nil then + error("an action transition is already active", 2) + end + local token = "action-transition-" .. tostring(self._next_token) + self._next_token = self._next_token + 1 + self._active_token = token + self._pending = {} + return token +end + +function EventQueue:is_transition_active() + return self._active_token ~= nil +end + +function EventQueue:pending_count() + return #self._pending +end + +function EventQueue:emit(name, payload) + if type(name) ~= "string" or name == "" then + error("event name must be a nonempty string", 2) + end + if self._active_token ~= nil then + self._pending[#self._pending + 1] = { + name = name, + payload = payload, + } + return false + end + self._deliver(name, payload) + return true +end + +function EventQueue:commit_transition(token) + if self._active_token == nil then + error("no action transition is active", 2) + end + if token ~= self._active_token then + error("action transition token does not match", 2) + end + + local pending = self._pending + self._active_token = nil + self._pending = {} + for index = 1, #pending do + local event = pending[index] + self._deliver(event.name, event.payload) + end +end + +return M diff --git a/lua/clever_tee/case_policy.lua b/lua/clever_tee/case_policy.lua new file mode 100644 index 0000000..07e4fb1 --- /dev/null +++ b/lua/clever_tee/case_policy.lua @@ -0,0 +1,190 @@ +local domain = require("clever_tee.domain") + +local M = {} +local CasePolicyResolver = {} +M.CasePolicyResolver = CasePolicyResolver + +local resolver_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function require_target(target) + if not domain.TargetValue.is(target) then + fail("case policy target must be a TargetValue", 2) + end + return target +end + +local function require_boolean(value, name) + if type(value) ~= "boolean" then + fail((name or "value") .. " must be a Boolean", 2) + end + return value +end + +local function require_string(value, name, allow_empty) + if type(value) ~= "string" or (not allow_empty and value == "") then + fail((name or "value") .. " must be a string", 2) + end + return value +end + +local function default_lowercase(value) + local runtime = rawget(_G, "vim") + if type(runtime) ~= "table" + or type(runtime.fn) ~= "table" + or type(runtime.fn.tolower) ~= "function" + then + fail("editor-compatible case conversion requires Nvim or a lowercase converter", 2) + end + return runtime.fn.tolower(value) +end + +local function lowercase_function(options) + if options == nil then + return default_lowercase + end + if type(options) == "function" then + return options + end + if type(options) ~= "table" then + fail("case policy options must be a table or lowercase function", 3) + end + local lowercase = options.lowercase or options.to_lower + if lowercase == nil then + return default_lowercase + end + if type(lowercase) ~= "function" then + fail("case policy lowercase converter must be a function", 3) + end + return lowercase +end + +local resolver_metatable = { + __index = CasePolicyResolver, + __newindex = function() + fail("CasePolicyResolver values are immutable", 2) + end, + __tostring = function() + return "case-policy-resolver" + end, + __metatable = "clever_tee.case_policy.CasePolicyResolver", +} + +function CasePolicyResolver.new(options) + if CasePolicyResolver.is(options) then + return options + end + local resolver = setmetatable({}, resolver_metatable) + resolver_records[resolver] = { + lowercase = lowercase_function(options), + } + return resolver +end + +function CasePolicyResolver.is(value) + return type(value) == "table" and resolver_records[value] ~= nil +end + +function M.new(options) + return CasePolicyResolver.new(options) +end + +setmetatable(M, { + __call = function(_, options) + return CasePolicyResolver.new(options) + end, +}) + +function M.is_lower_ascii(value) + if domain.TargetValue.is(value) then + value = value.value + end + if type(value) ~= "string" or #value ~= 1 then + return false + end + local byte = value:byte(1) + return byte >= string.byte("a") and byte <= string.byte("z") +end + +function M.resolve_case_mode(target, ignore_case, smart_case) + target = require_target(target) + require_boolean(ignore_case, "ignore_case") + require_boolean(smart_case, "smart_case") + + if ignore_case then + return domain.CaseMode.INSENSITIVE + end + if smart_case and M.is_lower_ascii(target) then + return domain.CaseMode.INSENSITIVE + end + return domain.CaseMode.SENSITIVE +end + +function CasePolicyResolver:resolve(target, ignore_case, smart_case) + if type(ignore_case) == "table" and smart_case == nil then + local match_policy = ignore_case + ignore_case = match_policy.ignore_case + smart_case = match_policy.smart_case + end + return M.resolve_case_mode(target, ignore_case, smart_case) +end + +function CasePolicyResolver:lowercase(value) + require_string(value, "case comparison value", true) + local lowercase = resolver_records[self].lowercase(value) + if type(lowercase) ~= "string" then + fail("case policy lowercase converter must return a string", 2) + end + return lowercase +end + +function CasePolicyResolver:equal(left, right, case_mode) + require_string(left, "left case comparison value", true) + require_string(right, "right case comparison value", true) + case_mode = domain.CaseMode.from_string(case_mode) + + if case_mode == domain.CaseMode.SENSITIVE then + return left == right + end + return self:lowercase(left) == self:lowercase(right) +end + +function CasePolicyResolver:comparator(target_character, case_mode) + require_string(target_character, "target character", true) + case_mode = domain.CaseMode.from_string(case_mode) + + if target_character == "" then + return function() + return false + end + end + + if case_mode == domain.CaseMode.SENSITIVE then + return function(candidate_character) + return type(candidate_character) == "string" + and candidate_character ~= "" + and candidate_character == target_character + end + end + + local folded_target = self:lowercase(target_character) + local lowercase = resolver_records[self].lowercase + return function(candidate_character) + if type(candidate_character) ~= "string" or candidate_character == "" then + return false + end + local folded_candidate = lowercase(candidate_character) + if type(folded_candidate) ~= "string" then + fail("case policy lowercase converter must return a string", 2) + end + return folded_candidate == folded_target + end +end + +M.resolve = M.resolve_case_mode +M.is_lowercase_ascii = M.is_lower_ascii + +return M diff --git a/lua/clever_tee/composition_root.lua b/lua/clever_tee/composition_root.lua new file mode 100644 index 0000000..4741bd4 --- /dev/null +++ b/lua/clever_tee/composition_root.lua @@ -0,0 +1,232 @@ +local action_facade = require("clever_tee.action_facade") +local capabilities = require("clever_tee.capabilities") +local feedback_service = require("clever_tee.feedback_service") +local policy = require("clever_tee.policy") +local sequence_coordinator = require("clever_tee.sequence_coordinator") +local sequence_state = require("clever_tee.sequence_state") +local state_transitions = require("clever_tee.state_transitions") + +local M = {} +local CompositionRoot = {} +CompositionRoot.__index = CompositionRoot +M.CompositionRoot = CompositionRoot +M.ACTION_NAMES = { + "StartFindForward", + "StartFindBackward", + "StartTillForward", + "StartTillBackward", + "Reset", + "RepeatSameDirection", + "RepeatOppositeDirection", +} +M.DEFAULT_MAPPING_MODES = { "n", "x", "o" } +M.DEFAULT_MAPPING_OPTIONS = { + silent = true, + remap = false, + preserve_count = true, +} +M.DEFAULT_MAPPINGS = { + { lhs = "f", action = "StartFindForward" }, + { lhs = "F", action = "StartFindBackward" }, + { lhs = "t", action = "StartTillForward" }, + { lhs = "T", action = "StartTillBackward" }, +} + +local ACTION_INVOCATIONS = { + StartFindForward = function(facade) + return facade:start_find_forward() + end, + StartFindBackward = function(facade) + return facade:start_find_backward() + end, + StartTillForward = function(facade) + return facade:start_till_forward() + end, + StartTillBackward = function(facade) + return facade:start_till_backward() + end, + Reset = function(facade) + return facade:reset() + end, + RepeatSameDirection = function(facade) + return facade:repeat_same_direction() + end, + RepeatOppositeDirection = function(facade) + return facade:repeat_opposite_direction() + end, +} + +local root_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function normalize_options(options) + if type(options) ~= "table" then + fail("CompositionRoot options must be a table", 3) + end + if options.host == nil then + return { host = options } + end + return options +end + +function CompositionRoot.new(options) + if CompositionRoot.is(options) then + return options + end + options = normalize_options(options) + local host = capabilities.assert_implements(options.host) + local state = sequence_state.new() + local transitions = options.transitions + or options.state_transitions + or state_transitions.new(state) + local policy_service = options.policy + or options.policy_service + or policy.new(host) + local feedback = options.feedback + or options.feedback_service + or feedback_service.new({ + host = host, + state = state, + transitions = transitions, + policy = policy_service, + }) + local coordinator = options.coordinator + or options.sequence_coordinator + or sequence_coordinator.new({ + host = host, + state = state, + transitions = transitions, + policy = policy_service, + feedback = feedback, + }) + local facade = options.facade + or options.action_facade + or action_facade.new({ coordinator = coordinator }) + + local root = setmetatable({}, CompositionRoot) + root_records[root] = { + host = host, + state = state, + transitions = transitions, + policy = policy_service, + feedback = feedback, + coordinator = coordinator, + facade = facade, + activation = nil, + last_highlight_refresh = nil, + } + return root +end + +function CompositionRoot.is(value) + return type(value) == "table" and root_records[value] ~= nil +end + +local function register_logical_actions(record) + local registrations = {} + for _, name in ipairs(M.ACTION_NAMES) do + local invoke = ACTION_INVOCATIONS[name] + registrations[name] = record.host:register_action(name, function(...) + return invoke(record.facade, ...) + end) + end + return registrations +end + +local function register_default_mappings(record, setup) + local registrations = {} + if not setup.install_default_mappings then + return registrations + end + for _, mapping in ipairs(M.DEFAULT_MAPPINGS) do + registrations[mapping.lhs] = record.host:register_mapping( + M.DEFAULT_MAPPING_MODES, + mapping.lhs, + mapping.action, + M.DEFAULT_MAPPING_OPTIONS + ) + end + return registrations +end + +function CompositionRoot:activate() + local record = root_records[self] + if record.activation == nil then + local setup = record.policy:capture_activation() + local feedback_activation = record.feedback:activate() + local highlights = record.feedback:evaluate_highlights() + local colorscheme_registration = record.host:register_events( + "ColorScheme", + function() + record.last_highlight_refresh = record.feedback:evaluate_highlights() + end, + { owner = "clever_tee", lifecycle = "colorscheme" } + ) + local actions = register_logical_actions(record) + record.activation = { + state = record.state, + setup = setup, + feedback = feedback_activation, + highlights = highlights, + colorscheme_registration = colorscheme_registration, + actions = actions, + mappings = register_default_mappings(record, setup), + } + end + return record.activation +end + +function CompositionRoot:last_highlight_refresh() + return root_records[self].last_highlight_refresh +end + +function CompositionRoot:host() + return root_records[self].host +end + +function CompositionRoot:state() + return root_records[self].state +end + +function CompositionRoot:transitions() + return root_records[self].transitions +end + +function CompositionRoot:policy() + return root_records[self].policy +end + +function CompositionRoot:feedback() + return root_records[self].feedback +end + +function CompositionRoot:coordinator() + return root_records[self].coordinator +end + +function CompositionRoot:facade() + return root_records[self].facade +end + +function CompositionRoot:invoke_descriptor(value) + return self:facade():invoke_descriptor(value) +end + +function CompositionRoot:diagnostic_full_reset() + return self:facade():diagnostic_full_reset() +end + +function M.new(options) + return CompositionRoot.new(options) +end + +setmetatable(M, { + __call = function(_, options) + return CompositionRoot.new(options) + end, +}) + +return M diff --git a/lua/clever_tee/destination_engine.lua b/lua/clever_tee/destination_engine.lua new file mode 100644 index 0000000..0469bb2 --- /dev/null +++ b/lua/clever_tee/destination_engine.lua @@ -0,0 +1,201 @@ +local domain = require("clever_tee.domain") +local text_topology = require("clever_tee.text_topology") + +local M = {} +local DestinationEngine = {} +M.DestinationEngine = DestinationEngine + +local engines = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local engine_metatable = { + __index = DestinationEngine, + __newindex = function() + fail("DestinationEngine values are immutable", 2) + end, + __tostring = function() + return "destination-engine" + end, + __metatable = "clever_tee.destination_engine.DestinationEngine", +} + +function DestinationEngine.new() + local engine = setmetatable({}, engine_metatable) + engines[engine] = true + return engine +end + +function DestinationEngine.is(value) + return type(value) == "table" and engines[value] == true +end + +local function calculation_inputs(view, origin, plan, count, first_move) + if not text_topology.TextView.is(view) then + fail("destination calculation view must be a TextView", 3) + end + + origin = domain.Position.coerce(origin) + if not view:is_valid_cursor_position(origin) then + fail("destination calculation origin must be a valid cursor position", 3) + end + if not domain.ResolvedMotionPlan.is(plan) then + fail("destination calculation plan must be a ResolvedMotionPlan", 3) + end + count = domain.Count.new(count) + if type(first_move) ~= "boolean" then + fail("destination calculation first_move must be a Boolean", 3) + end + + local bounds = view:match_start_bounds(plan.search_scope, origin) + return { + view = view, + origin = origin, + plan = plan, + count = count, + first_move = first_move, + bounds = bounds, + } +end + +local function candidate_starts(request, origin) + return request.view:iter_strict( + origin, + request.plan.descriptor.direction, + request.bounds + ) +end + +local function regular_destination(request, target_position) + local descriptor = request.plan.descriptor + if descriptor.family == domain.Family.FIND then + return target_position + end + if descriptor.direction == domain.Direction.FORWARD then + return request.view:predecessor(target_position) + end + return request.view:successor(target_position) +end + +local function target_destination(request, target_position) + local descriptor = request.plan.descriptor + if request.plan.endpoint_policy == domain.EndpointPolicy.VISUAL_EXCLUSIVE + and descriptor.direction == domain.Direction.FORWARD + then + if descriptor.family == domain.Family.FIND then + return request.view:successor(target_position) + end + return target_position + end + return regular_destination(request, target_position) +end + +local function strict_destination(descriptor, destination, origin) + local comparison = domain.Position.compare(destination, origin) + if descriptor.direction == domain.Direction.FORWARD then + return comparison > 0 + end + return comparison < 0 +end + +local function acceptable_destination( + request, + destination, + origin, + allow_till_equality +) + local descriptor = request.plan.descriptor + if strict_destination(descriptor, destination, origin) then + return true + end + return descriptor.family == domain.Family.TILL + and allow_till_equality + and domain.Position.equal(destination, origin) +end + +local function next_destination(request, origin, allow_till_equality) + local candidates = candidate_starts(request, origin) + + while true do + local target_position, character = candidates() + if target_position == nil then + return nil + end + if request.plan.target_plan:matches( + character, + target_position, + request.view + ) then + local destination = target_destination(request, target_position) + if destination ~= nil + and acceptable_destination( + request, + destination, + origin, + allow_till_equality + ) + then + return destination + end + end + end +end + +local function till_equality_allowed(request, successful_steps) + return request.first_move and successful_steps == 0 +end + +local function boundary_outcome(request, endpoint, successful_steps) + if successful_steps > 0 then + return domain.SearchOutcome.boundary_after_partial( + endpoint, + successful_steps + ) + end + return domain.SearchOutcome.boundary_before_any(request.origin) +end + +function DestinationEngine:calculate(view, origin, plan, count, first_move) + local request = calculation_inputs(view, origin, plan, count, first_move) + local current_origin = request.origin + local successful_steps = 0 + + while successful_steps < request.count.value do + local destination = next_destination( + request, + current_origin, + till_equality_allowed(request, successful_steps) + ) + if destination == nil then + break + end + current_origin = destination + successful_steps = successful_steps + 1 + end + + if successful_steps == request.count.value then + return domain.SearchOutcome.complete(current_origin, successful_steps) + end + return boundary_outcome(request, current_origin, successful_steps) +end + +function M.new() + return DestinationEngine.new() +end + +function M.calculate(view, origin, plan, count, first_move) + return DestinationEngine.new():calculate(view, origin, plan, count, first_move) +end + +M.resolve = M.calculate +M.search = M.calculate + +setmetatable(M, { + __call = function() + return DestinationEngine.new() + end, +}) + +return M 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 diff --git a/lua/clever_tee/domain.lua b/lua/clever_tee/domain.lua new file mode 100644 index 0000000..ff0e513 --- /dev/null +++ b/lua/clever_tee/domain.lua @@ -0,0 +1,1390 @@ +local M = {} + +local records = setmetatable({}, { __mode = "k" }) +local record_types = setmetatable({}, { __mode = "k" }) +local methods = {} +local formatters = {} +local equalities = {} +local metatables = {} + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function is_integer(value) + return type(value) == "number" + and value > -math.huge + and value < math.huge + and value == math.floor(value) +end + +local function register_type(type_name, type_methods, formatter, equality) + methods[type_name] = type_methods or {} + formatters[type_name] = formatter + equalities[type_name] = equality + + local mt = { + __index = function(value, key) + local field = records[value][key] + if field ~= nil then + return field + end + return methods[type_name][key] + end, + __newindex = function() + fail(type_name .. " values are immutable", 2) + end, + __tostring = function(value) + local format = formatters[type_name] + if format then + return format(records[value]) + end + return type_name + end, + __eq = function(left, right) + if record_types[left] ~= type_name or record_types[right] ~= type_name then + return false + end + local equal = equalities[type_name] + if equal then + return equal(records[left], records[right]) + end + return rawequal(left, right) + end, + __metatable = "clever_tee.domain." .. type_name, + } + metatables[type_name] = mt +end + +local function new_record(type_name, fields) + local value = {} + records[value] = fields + record_types[value] = type_name + return setmetatable(value, metatables[type_name]) +end + +local function is_record(value, type_name) + return record_types[value] == type_name +end + +local function require_record(value, type_name, name) + if not is_record(value, type_name) then + fail((name or "value") .. " must be a " .. type_name, 2) + end + return value +end + +local function require_string(value, name, allow_empty) + if type(value) ~= "string" or (not allow_empty and value == "") then + fail(name .. " must be " .. (allow_empty and "a string" or "a nonempty string"), 2) + end + return value +end + +local function require_boolean(value, name) + if type(value) ~= "boolean" then + fail(name .. " must be a Boolean", 2) + end + return value +end + +local function require_nonnegative_integer(value, name) + if not is_integer(value) or value < 0 then + fail(name .. " must be a nonnegative integer", 2) + end + return value +end + +function M.type_of(value) + return record_types[value] +end + +local function define_enum(type_name, entries) + local enum_methods = {} + local namespace = {} + local by_value = {} + + register_type(type_name, enum_methods, function(data) + return data.value + end) + + for constant, serialized in pairs(entries) do + local value = new_record(type_name, { + name = constant, + value = serialized, + }) + namespace[constant] = value + by_value[serialized] = value + end + + function namespace.from_string(value) + if is_record(value, type_name) then + return value + end + local result = by_value[value] + if result == nil then + fail("value must be a valid " .. type_name, 2) + end + return result + end + + function namespace.is(value) + return is_record(value, type_name) + end + + function enum_methods:to_string() + return records[self].value + end + + return namespace +end + +M.Family = define_enum("Family", { + FIND = "FIND", + TILL = "TILL", +}) + +M.Direction = define_enum("Direction", { + FORWARD = "forward", + BACKWARD = "backward", +}) + +M.SelectionKind = define_enum("SelectionKind", { + NONE = "none", + CHARACTER = "character", + LINE = "line", + BLOCK = "block", +}) + +M.SelectionOption = define_enum("SelectionOption", { + INCLUSIVE = "inclusive", + EXCLUSIVE = "exclusive", +}) + +M.TargetKind = define_enum("TargetKind", { + CHARACTER = "character", + SPECIAL_KEY = "special_key", + CODE_FALLBACK = "code_fallback", +}) + +M.CaseMode = define_enum("CaseMode", { + SENSITIVE = "sensitive", + INSENSITIVE = "insensitive", +}) + +M.TargetPlanKind = define_enum("TargetPlanKind", { + EMPTY = "empty", + LITERAL = "literal", + BACKSLASH = "backslash", + SYMBOL = "symbol", + MIGEMO = "migemo", +}) + +M.SearchScope = define_enum("SearchScope", { + BUFFER = "buffer", + CURRENT_LINE = "current_line", +}) + +M.EndpointPolicy = define_enum("EndpointPolicy", { + REGULAR = "regular", + VISUAL_EXCLUSIVE = "visual_exclusive", +}) + +M.SearchStatus = define_enum("SearchStatus", { + COMPLETE = "complete", + BOUNDARY_AFTER_PARTIAL = "boundary_after_partial", + BOUNDARY_BEFORE_ANY = "boundary_before_any", +}) + +M.ActionKind = define_enum("ActionKind", { + MOVEMENT = "movement", + NEUTRAL = "neutral", + ESCAPE = "escape", + FAILED_SEARCH = "failed_search", + ERROR = "error", + EMPTY = "empty", +}) + +local Position = {} +M.Position = Position + +register_type("Position", Position, function(data) + return string.format("(%d,%d)", data.line, data.byte_column) +end, function(left, right) + return left.line == right.line and left.byte_column == right.byte_column +end) + +function Position.new(line, byte_column) + if not is_integer(line) or line < 1 then + fail("line must be a positive one-based integer", 2) + end + if not is_integer(byte_column) or byte_column < 1 then + fail("byte_column must be a positive one-based integer", 2) + end + return new_record("Position", { + line = line, + byte_column = byte_column, + }) +end + +function Position.coerce(value) + if Position.is(value) then + return value + end + if type(value) ~= "table" then + fail("position must be a Position or position table", 2) + end + return Position.new(value.line, value.byte_column) +end + +function Position.is(value) + return is_record(value, "Position") +end + +function Position.compare(left, right) + require_record(left, "Position", "left") + require_record(right, "Position", "right") + if left.line < right.line then + return -1 + end + if left.line > right.line then + return 1 + end + if left.byte_column < right.byte_column then + return -1 + end + if left.byte_column > right.byte_column then + return 1 + end + return 0 +end + +function Position.equal(left, right) + return Position.compare(left, right) == 0 +end + +function Position.stationary(left, right) + return Position.equal(left, right) +end + +function Position.is_forward(candidate, origin) + return Position.compare(candidate, origin) > 0 +end + +function Position.is_backward(candidate, origin) + return Position.compare(candidate, origin) < 0 +end + +function Position:to_table() + return { + line = self.line, + byte_column = self.byte_column, + } +end + +local Descriptor = {} +M.Descriptor = Descriptor + +register_type("Descriptor", Descriptor, function(data) + return data.value +end) + +local descriptors_by_string = {} +local descriptors_by_parts = {} + +local function descriptor_key(family, direction) + return family.value .. ":" .. direction.value +end + +local function define_descriptor(name, serialized, family, direction) + local descriptor = new_record("Descriptor", { + name = name, + value = serialized, + family = family, + direction = direction, + uppercase = serialized:match("%u") ~= nil, + }) + descriptors_by_string[serialized] = descriptor + descriptors_by_parts[descriptor_key(family, direction)] = descriptor + Descriptor[name] = descriptor + Descriptor[serialized] = descriptor + return descriptor +end + +Descriptor.FIND_FORWARD = define_descriptor( + "FIND_FORWARD", + "f", + M.Family.FIND, + M.Direction.FORWARD +) +Descriptor.FIND_BACKWARD = define_descriptor( + "FIND_BACKWARD", + "F", + M.Family.FIND, + M.Direction.BACKWARD +) +Descriptor.TILL_FORWARD = define_descriptor( + "TILL_FORWARD", + "t", + M.Family.TILL, + M.Direction.FORWARD +) +Descriptor.TILL_BACKWARD = define_descriptor( + "TILL_BACKWARD", + "T", + M.Family.TILL, + M.Direction.BACKWARD +) + +function Descriptor.is(value) + return is_record(value, "Descriptor") +end + +function Descriptor.is_valid(value) + return Descriptor.is(value) or descriptors_by_string[value] ~= nil +end + +function Descriptor.from_string(value) + if Descriptor.is(value) then + return value + end + local descriptor = descriptors_by_string[value] + if descriptor == nil then + fail("descriptor must be one of f, F, t, or T", 2) + end + return descriptor +end + +function Descriptor.try_from_string(value) + if Descriptor.is(value) then + return value + end + return descriptors_by_string[value] +end + +function Descriptor.from_parts(family, direction) + family = M.Family.from_string(family) + direction = M.Direction.from_string(direction) + return descriptors_by_parts[descriptor_key(family, direction)] +end + +function Descriptor.to_string(value) + return Descriptor.from_string(value).value +end + +function Descriptor.is_uppercase(value) + return Descriptor.from_string(value).uppercase +end + +function Descriptor.is_lowercase(value) + return not Descriptor.is_uppercase(value) +end + +function Descriptor.swap(value) + local descriptor = Descriptor.from_string(value) + local direction = descriptor.direction == M.Direction.FORWARD + and M.Direction.BACKWARD + or M.Direction.FORWARD + return Descriptor.from_parts(descriptor.family, direction) +end + +function Descriptor.lowercase(value) + local descriptor = Descriptor.from_string(value) + return Descriptor.from_parts(descriptor.family, M.Direction.FORWARD) +end + +function Descriptor.uppercase(value) + local descriptor = Descriptor.from_string(value) + return Descriptor.from_parts(descriptor.family, M.Direction.BACKWARD) +end + +local Count = {} +M.Count = Count + +register_type("Count", Count, function(data) + return tostring(data.value) +end, function(left, right) + return left.value == right.value +end) + +local count_one + +function Count.new(value) + if Count.is(value) then + return value + end + if value == nil then + value = 1 + end + if not is_integer(value) or value < 1 then + fail("count must be a positive integer", 2) + end + if value == 1 and count_one ~= nil then + return count_one + end + local count = new_record("Count", { value = value }) + if value == 1 then + count_one = count + end + return count +end + +function Count.is(value) + return is_record(value, "Count") +end + +function Count.to_number(value) + return Count.new(value).value +end + +Count.ONE = Count.new(1) + +local ModeContext = {} +M.ModeContext = ModeContext + +register_type("ModeContext", ModeContext, function(data) + return data.key +end) + +local mode_contexts = {} +local CTRL_V = string.char(0x16) +local CTRL_S = string.char(0x13) + +local operator_modes = { + no = true, + nov = true, + noV = true, + ["no" .. CTRL_V] = true, +} + +local function mode_traits(full_mode) + local operator = operator_modes[full_mode] == true + local visual_kind + local select_kind + + if not operator then + local lead = full_mode:sub(1, 1) + if lead == "v" then + visual_kind = M.SelectionKind.CHARACTER + elseif lead == "V" then + visual_kind = M.SelectionKind.LINE + elseif lead == CTRL_V then + visual_kind = M.SelectionKind.BLOCK + elseif lead == "s" then + select_kind = M.SelectionKind.CHARACTER + elseif lead == "S" then + select_kind = M.SelectionKind.LINE + elseif lead == CTRL_S then + select_kind = M.SelectionKind.BLOCK + end + end + + return operator, visual_kind, select_kind +end + +function ModeContext.from_full_mode(full_mode) + if ModeContext.is(full_mode) then + return full_mode + end + require_string(full_mode, "full_mode", false) + + local operator, visual_kind, select_kind = mode_traits(full_mode) + local key = operator and "no" or full_mode + local context = mode_contexts[key] + if context ~= nil then + return context + end + + context = new_record("ModeContext", { + key = key, + full_mode = key, + operator = operator, + visual_kind = visual_kind, + select_kind = select_kind, + visual = visual_kind ~= nil, + select = select_kind ~= nil, + command_path = visual_kind == nil, + }) + mode_contexts[key] = context + return context +end + +function ModeContext.is(value) + return is_record(value, "ModeContext") +end + +function ModeContext.equal(left, right) + require_record(left, "ModeContext", "left") + require_record(right, "ModeContext", "right") + return left.key == right.key +end + +function ModeContext:to_key() + return self.key +end + +local Selection = {} +M.Selection = Selection + +register_type("Selection", Selection, function(data) + return data.active and ("selection:" .. data.kind.value) or "selection:none" +end, function(left, right) + return left.active == right.active + and left.kind == right.kind + and left.anchor == right.anchor + and left.focus == right.focus + and left.option == right.option +end) + +function Selection.new(options) + if Selection.is(options) then + return options + end + if type(options) ~= "table" then + fail("selection options must be a table", 2) + end + + local active = require_boolean(options.active, "selection.active") + local kind = M.SelectionKind.from_string(options.kind) + local option = M.SelectionOption.from_string(options.option or "inclusive") + local anchor = options.anchor + local focus = options.focus + + if active then + if kind == M.SelectionKind.NONE then + fail("an active selection must have a selection kind", 2) + end + anchor = Position.coerce(anchor) + focus = Position.coerce(focus) + else + if kind ~= M.SelectionKind.NONE then + fail("an inactive selection must use the none kind", 2) + end + if anchor ~= nil or focus ~= nil then + fail("an inactive selection must have empty endpoints", 2) + end + end + + return new_record("Selection", { + active = active, + kind = kind, + anchor = anchor, + focus = focus, + option = option, + }) +end + +function Selection.inactive(option) + return Selection.new({ + active = false, + kind = M.SelectionKind.NONE, + option = option or M.SelectionOption.INCLUSIVE, + }) +end + +function Selection.active(kind, anchor, focus, option) + return Selection.new({ + active = true, + kind = kind, + anchor = anchor, + focus = focus, + option = option or M.SelectionOption.INCLUSIVE, + }) +end + +function Selection.is(value) + return is_record(value, "Selection") +end + +function Selection:with_focus(focus, kind) + if not self.active then + fail("selection must be active", 2) + end + return Selection.active(kind or self.kind, self.anchor, focus, self.option) +end + +function Selection:to_table() + return { + active = self.active, + kind = self.kind.value, + anchor = self.anchor and self.anchor:to_table() or nil, + focus = self.focus and self.focus:to_table() or nil, + option = self.option.value, + } +end + +local TextSnapshot = {} +M.TextSnapshot = TextSnapshot +local text_lines = setmetatable({}, { __mode = "k" }) + +register_type("TextSnapshot", TextSnapshot, function(data) + return "text:" .. tostring(data.line_count) .. " lines" +end, function(left, right) + if left.line_count ~= right.line_count then + return false + end + local left_lines = text_lines[left.identity] + local right_lines = text_lines[right.identity] + for index = 1, left.line_count do + if left_lines[index] ~= right_lines[index] then + return false + end + end + return true +end) + +function TextSnapshot.new(lines) + if TextSnapshot.is(lines) then + return lines + end + if type(lines) ~= "table" or #lines < 1 then + fail("text lines must be a nonempty list", 2) + end + local copy = {} + for index = 1, #lines do + if type(lines[index]) ~= "string" then + fail("each text line must be a string", 2) + end + copy[index] = lines[index] + end + local identity = {} + text_lines[identity] = copy + return new_record("TextSnapshot", { + identity = identity, + line_count = #copy, + }) +end + +function TextSnapshot.is(value) + return is_record(value, "TextSnapshot") +end + +function TextSnapshot:line(line_number) + if not is_integer(line_number) or line_number < 1 or line_number > self.line_count then + fail("line_number must identify a line in the text snapshot", 2) + end + return text_lines[self.identity][line_number] +end + +function TextSnapshot:lines() + local result = {} + local source = text_lines[self.identity] + for index = 1, self.line_count do + result[index] = source[index] + end + return result +end + +function TextSnapshot:to_table() + return { lines = self:lines() } +end + +local MacroState = {} +M.MacroState = MacroState + +register_type("MacroState", MacroState, function(data) + return data.executing and ("macro:" .. data.register) or "macro:inactive" +end, function(left, right) + return left.register == right.register +end) + +function MacroState.new(register) + if MacroState.is(register) then + return register + end + if register == "" then + register = nil + end + if register ~= nil then + require_string(register, "macro register", false) + end + return new_record("MacroState", { + register = register, + executing = register ~= nil, + }) +end + +function MacroState.is(value) + return is_record(value, "MacroState") +end + +local FoldState = {} +M.FoldState = FoldState +local fold_policies = setmetatable({}, { __mode = "k" }) + +register_type("FoldState", FoldState, function(data) + return "folds:" .. tostring(data.closed_levels) +end) + +function FoldState.new(open_policy, closed_levels) + if FoldState.is(open_policy) and closed_levels == nil then + return open_policy + end + if type(open_policy) ~= "table" then + fail("fold open policy must be a list", 2) + end + require_nonnegative_integer(closed_levels, "closed fold levels") + + local identity = {} + local policies = {} + local seen = {} + for index = 1, #open_policy do + local policy = require_string(open_policy[index], "fold policy item", false) + if not seen[policy] then + seen[policy] = true + policies[#policies + 1] = policy + end + end + fold_policies[identity] = { + list = policies, + set = seen, + } + return new_record("FoldState", { + identity = identity, + closed_levels = closed_levels, + }) +end + +function FoldState.is(value) + return is_record(value, "FoldState") +end + +function FoldState:opens(policy) + require_string(policy, "fold policy", false) + return fold_policies[self.identity].set[policy] == true +end + +function FoldState:policies() + local result = {} + local source = fold_policies[self.identity].list + for index = 1, #source do + result[index] = source[index] + end + return result +end + +local InputPacket = {} +M.InputPacket = InputPacket +local packet_bytes = setmetatable({}, { __mode = "k" }) + +M.InputPacketKind = define_enum("InputPacketKind", { + TEXT = "text", + RAW_BYTES = "raw_bytes", + SPECIAL_KEY = "special_key", + ERROR = "error", +}) + +register_type("InputPacket", InputPacket, function(data) + return "input:" .. data.kind.value +end) + +function InputPacket.text(text) + require_string(text, "input text", false) + return new_record("InputPacket", { + kind = M.InputPacketKind.TEXT, + text = text, + }) +end + +local function validated_packet_bytes(bytes, kind) + if type(bytes) ~= "table" or #bytes < 1 then + fail(kind .. " bytes must be a nonempty list", 3) + end + local copy = {} + for index = 1, #bytes do + local byte = bytes[index] + if not is_integer(byte) or byte < 0 or byte > 255 then + fail(kind .. " bytes must contain byte values", 3) + end + copy[index] = byte + end + return copy +end + +local function bytes_from_string(value) + local bytes = {} + for index = 1, #value do + bytes[index] = string.byte(value, index) + end + return bytes +end + +local function string_from_bytes(bytes) + local characters = {} + for index = 1, #bytes do + characters[index] = string.char(bytes[index]) + end + return table.concat(characters) +end + +function InputPacket.raw_bytes(bytes) + local identity = {} + packet_bytes[identity] = validated_packet_bytes(bytes, "raw input") + return new_record("InputPacket", { + kind = M.InputPacketKind.RAW_BYTES, + identity = identity, + }) +end + +function InputPacket.special_key(name, encoded) + require_string(name, "special key name", false) + local bytes + if type(encoded) == "table" then + bytes = validated_packet_bytes(encoded, "special key") + encoded = string_from_bytes(bytes) + elseif encoded ~= nil then + require_string(encoded, "encoded special key", false) + bytes = bytes_from_string(encoded) + end + local identity + if bytes ~= nil then + identity = {} + packet_bytes[identity] = bytes + end + return new_record("InputPacket", { + kind = M.InputPacketKind.SPECIAL_KEY, + name = name, + encoded = encoded, + identity = identity, + }) +end + +function InputPacket.error(message) + require_string(message, "input error message", false) + return new_record("InputPacket", { + kind = M.InputPacketKind.ERROR, + message = message, + }) +end + +function InputPacket.from_table(packet) + if InputPacket.is(packet) then + return packet + end + if type(packet) ~= "table" then + fail("input packet must be an InputPacket or packet table", 2) + end + local kind = M.InputPacketKind.from_string(packet.kind) + if kind == M.InputPacketKind.TEXT then + return InputPacket.text(packet.text) + end + if kind == M.InputPacketKind.RAW_BYTES then + return InputPacket.raw_bytes(packet.bytes) + end + if kind == M.InputPacketKind.SPECIAL_KEY then + return InputPacket.special_key(packet.name, packet.bytes or packet.encoded) + end + return InputPacket.error(packet.message) +end + +function InputPacket.is(value) + return is_record(value, "InputPacket") +end + +function InputPacket:bytes() + if self.kind ~= M.InputPacketKind.RAW_BYTES + and self.kind ~= M.InputPacketKind.SPECIAL_KEY + then + return nil + end + local source = self.identity and packet_bytes[self.identity] or nil + if source == nil then + return nil + end + local result = {} + for index = 1, #source do + result[index] = source[index] + end + return result +end + +function InputPacket:to_table() + local result = { kind = self.kind.value } + if self.kind == M.InputPacketKind.TEXT then + result.text = self.text + elseif self.kind == M.InputPacketKind.RAW_BYTES then + result.bytes = self:bytes() + elseif self.kind == M.InputPacketKind.SPECIAL_KEY then + result.name = self.name + result.bytes = self:bytes() + else + result.message = self.message + end + return result +end + +local TargetValue = {} +M.TargetValue = TargetValue + +register_type("TargetValue", TargetValue, function(data) + return "target:" .. data.kind.value .. ":" .. tostring(data.first_code) +end, function(left, right) + return left.kind == right.kind + and left.value == right.value + and left.first_code == right.first_code +end) + +function TargetValue.character(value, first_code) + require_string(value, "target character", false) + require_nonnegative_integer(first_code, "target first code") + return new_record("TargetValue", { + kind = M.TargetKind.CHARACTER, + value = value, + first_code = first_code, + }) +end + +function TargetValue.special_key(value, first_code) + require_string(value, "encoded special key", false) + first_code = first_code or string.byte(value, 1) + require_nonnegative_integer(first_code, "target first code") + if first_code ~= 0x80 then + fail("an encoded special key must start with hexadecimal 80", 2) + end + return new_record("TargetValue", { + kind = M.TargetKind.SPECIAL_KEY, + value = value, + first_code = first_code, + }) +end + +function TargetValue.code_fallback(first_code) + first_code = first_code or 0 + require_nonnegative_integer(first_code, "fallback character code") + return new_record("TargetValue", { + kind = M.TargetKind.CODE_FALLBACK, + value = "", + first_code = first_code, + }) +end + +function TargetValue.from_table(target) + if TargetValue.is(target) then + return target + end + if type(target) ~= "table" then + fail("target must be a TargetValue or target table", 2) + end + local kind = M.TargetKind.from_string(target.kind) + if kind == M.TargetKind.CHARACTER then + return TargetValue.character(target.value, target.first_code) + end + if kind == M.TargetKind.SPECIAL_KEY then + return TargetValue.special_key(target.value, target.first_code) + end + return TargetValue.code_fallback(target.first_code) +end + +function TargetValue.is(value) + return is_record(value, "TargetValue") +end + +function TargetValue:to_table() + return { + kind = self.kind.value, + value = self.value, + first_code = self.first_code, + } +end + +local TargetPlan = {} +M.TargetPlan = TargetPlan + +register_type("TargetPlan", TargetPlan, function(data) + return "target-plan:" .. data.kind.value +end) + +function TargetPlan.new(options) + if TargetPlan.is(options) then + return options + end + if type(options) ~= "table" then + fail("target plan options must be a table", 2) + end + local target = require_record(options.target, "TargetValue", "target plan target") + local kind = M.TargetPlanKind.from_string(options.kind) + local case_mode = M.CaseMode.from_string(options.case_mode) + if type(options.matcher) ~= "function" then + fail("target plan matcher must be a function", 2) + end + return new_record("TargetPlan", { + target = target, + kind = kind, + case_mode = case_mode, + matcher = options.matcher, + }) +end + +function TargetPlan.is(value) + return is_record(value, "TargetPlan") +end + +function TargetPlan:matches(...) + return self.matcher(...) +end + +function TargetPlan:matches_at(text_view, position) + if type(text_view) ~= "table" or type(text_view.character_at) ~= "function" then + fail("target plan match requires a text view", 2) + end + position = Position.coerce(position) + return self.matcher(text_view:character_at(position), position, text_view) +end + +function TargetPlan:to_table() + return { + target = self.target:to_table(), + kind = self.kind.value, + case_mode = self.case_mode.value, + } +end + +local ResolvedMotionPlan = {} +M.ResolvedMotionPlan = ResolvedMotionPlan + +register_type("ResolvedMotionPlan", ResolvedMotionPlan, function(data) + return "motion-plan:" .. data.descriptor.value +end) + +function ResolvedMotionPlan.new(options) + if ResolvedMotionPlan.is(options) then + return options + end + if type(options) ~= "table" then + fail("resolved motion plan options must be a table", 2) + end + return new_record("ResolvedMotionPlan", { + target_plan = require_record(options.target_plan, "TargetPlan", "target plan"), + descriptor = Descriptor.from_string(options.descriptor), + search_scope = M.SearchScope.from_string(options.search_scope), + endpoint_policy = M.EndpointPolicy.from_string(options.endpoint_policy), + }) +end + +function ResolvedMotionPlan.is(value) + return is_record(value, "ResolvedMotionPlan") +end + +function ResolvedMotionPlan:to_table() + return { + target_plan = self.target_plan:to_table(), + descriptor = self.descriptor.value, + search_scope = self.search_scope.value, + endpoint_policy = self.endpoint_policy.value, + } +end + +local MotionRequest = {} +M.MotionRequest = MotionRequest + +register_type("MotionRequest", MotionRequest, function(data) + return "motion-request:" .. data.descriptor.value +end) + +function MotionRequest.new(options) + if MotionRequest.is(options) then + return options + end + if type(options) ~= "table" then + fail("motion request options must be a table", 2) + end + if options.policy == nil then + fail("motion request policy is required", 2) + end + return new_record("MotionRequest", { + context = require_record(options.context, "ModeContext", "motion context"), + origin = Position.coerce(options.origin), + descriptor = Descriptor.from_string(options.descriptor), + target = require_record(options.target, "TargetValue", "motion target"), + count = Count.new(options.count), + policy = options.policy, + first_move = require_boolean(options.first_move, "first_move"), + }) +end + +function MotionRequest.is(value) + return is_record(value, "MotionRequest") +end + +local SearchOutcome = {} +M.SearchOutcome = SearchOutcome + +register_type("SearchOutcome", SearchOutcome, function(data) + return "search:" .. data.status.value +end) + +local function new_search_outcome(status, endpoint, successful_steps) + status = M.SearchStatus.from_string(status) + endpoint = Position.coerce(endpoint) + require_nonnegative_integer(successful_steps, "successful_steps") + + if status == M.SearchStatus.COMPLETE and successful_steps < 1 then + fail("a complete search must contain a successful step", 3) + end + if status == M.SearchStatus.BOUNDARY_AFTER_PARTIAL and successful_steps < 1 then + fail("a partial search must contain a successful step", 3) + end + if status == M.SearchStatus.BOUNDARY_BEFORE_ANY and successful_steps ~= 0 then + fail("a boundary-before-any search must contain zero successful steps", 3) + end + + return new_record("SearchOutcome", { + status = status, + endpoint = endpoint, + successful_steps = successful_steps, + complete = status == M.SearchStatus.COMPLETE, + }) +end + +function SearchOutcome.new(options) + if SearchOutcome.is(options) then + return options + end + if type(options) ~= "table" then + fail("search outcome options must be a table", 2) + end + return new_search_outcome(options.status, options.endpoint, options.successful_steps) +end + +function SearchOutcome.complete(endpoint, successful_steps) + return new_search_outcome(M.SearchStatus.COMPLETE, endpoint, successful_steps) +end + +function SearchOutcome.boundary_after_partial(endpoint, successful_steps) + return new_search_outcome( + M.SearchStatus.BOUNDARY_AFTER_PARTIAL, + endpoint, + successful_steps + ) +end + +function SearchOutcome.boundary_before_any(origin) + return new_search_outcome(M.SearchStatus.BOUNDARY_BEFORE_ANY, origin, 0) +end + +function SearchOutcome.is(value) + return is_record(value, "SearchOutcome") +end + +function SearchOutcome:to_table() + return { + status = self.status.value, + endpoint = self.endpoint:to_table(), + successful_steps = self.successful_steps, + complete = self.complete, + } +end + +local DotPayload = {} +M.DotPayload = DotPayload + +register_type("DotPayload", DotPayload, function(data) + return "dot:" .. data.descriptor.value +end, function(left, right) + return left.descriptor == right.descriptor and left.target == right.target +end) + +function DotPayload.new(descriptor, target) + if DotPayload.is(descriptor) and target == nil then + return descriptor + end + return new_record("DotPayload", { + descriptor = Descriptor.from_string(descriptor), + target = require_record(target, "TargetValue", "dot target"), + }) +end + +function DotPayload.is(value) + return is_record(value, "DotPayload") +end + +function DotPayload:to_table() + return { + descriptor = self.descriptor.value, + target = self.target:to_table(), + } +end + +local ExplicitRepeatRequest = {} +M.ExplicitRepeatRequest = ExplicitRepeatRequest + +register_type("ExplicitRepeatRequest", ExplicitRepeatRequest, function(data) + if data.neutral then + return "explicit-repeat:neutral" + end + return "explicit-repeat:" .. data.descriptor.value +end, function(left, right) + return left.neutral == right.neutral + and left.descriptor == right.descriptor + and left.target == right.target +end) + +local neutral_explicit_repeat_request + +function ExplicitRepeatRequest.new(descriptor, target) + if ExplicitRepeatRequest.is(descriptor) and target == nil then + return descriptor + end + descriptor = Descriptor.from_string(descriptor) + target = require_record(target, "TargetValue", "explicit repeat target") + return new_record("ExplicitRepeatRequest", { + descriptor = descriptor, + effective_descriptor = descriptor, + target = target, + neutral = false, + }) +end + +function ExplicitRepeatRequest.neutral() + if neutral_explicit_repeat_request == nil then + neutral_explicit_repeat_request = new_record("ExplicitRepeatRequest", { + descriptor = nil, + effective_descriptor = nil, + target = nil, + neutral = true, + }) + end + return neutral_explicit_repeat_request +end + +function ExplicitRepeatRequest.is(value) + return is_record(value, "ExplicitRepeatRequest") +end + +function ExplicitRepeatRequest:is_neutral() + return self.neutral +end + +function ExplicitRepeatRequest:to_table() + if self.neutral then + return { neutral = true } + end + return { + descriptor = self.descriptor.value, + target = self.target:to_table(), + neutral = false, + } +end + +local ActionOutcome = {} +M.ActionOutcome = ActionOutcome + +register_type("ActionOutcome", ActionOutcome, function(data) + return "action:" .. data.kind.value +end) + +local function new_action_outcome(options) + local kind = M.ActionKind.from_string(options.kind) + local position = Position.coerce(options.position) + local search_outcome = options.search_outcome + local descriptor = options.effective_descriptor + local dot_payload = options.dot_payload + + if search_outcome ~= nil then + require_record(search_outcome, "SearchOutcome", "search outcome") + end + if descriptor ~= nil then + descriptor = Descriptor.from_string(descriptor) + end + if dot_payload ~= nil then + require_record(dot_payload, "DotPayload", "dot payload") + end + if options.diagnostic ~= nil then + require_string(options.diagnostic, "diagnostic", false) + end + + if kind == M.ActionKind.MOVEMENT then + if search_outcome == nil or not search_outcome.complete then + fail("a movement action requires a complete search outcome", 3) + end + elseif kind == M.ActionKind.FAILED_SEARCH then + if search_outcome == nil or search_outcome.complete then + fail("a failed-search action requires an incomplete search outcome", 3) + end + elseif search_outcome ~= nil then + fail("only movement and failed-search actions can contain a search outcome", 3) + end + + if kind == M.ActionKind.ERROR and options.diagnostic == nil then + fail("an error action requires a diagnostic", 3) + end + + local complete + if search_outcome ~= nil then + complete = search_outcome.complete + end + + return new_record("ActionOutcome", { + kind = kind, + position = position, + search_outcome = search_outcome, + complete = complete, + successful_steps = search_outcome and search_outcome.successful_steps or 0, + effective_descriptor = descriptor, + dot_payload = dot_payload, + diagnostic = options.diagnostic, + }) +end + +function ActionOutcome.new(options) + if ActionOutcome.is(options) then + return options + end + if type(options) ~= "table" then + fail("action outcome options must be a table", 2) + end + return new_action_outcome(options) +end + +function ActionOutcome.from_search(search_outcome, descriptor, dot_payload) + require_record(search_outcome, "SearchOutcome", "search outcome") + return new_action_outcome({ + kind = search_outcome.complete and M.ActionKind.MOVEMENT or M.ActionKind.FAILED_SEARCH, + position = search_outcome.endpoint, + search_outcome = search_outcome, + effective_descriptor = descriptor, + dot_payload = dot_payload, + }) +end + +local function simple_action(kind, position, diagnostic) + return new_action_outcome({ + kind = kind, + position = position, + diagnostic = diagnostic, + }) +end + +function ActionOutcome.neutral(position) + return simple_action(M.ActionKind.NEUTRAL, position) +end + +function ActionOutcome.escape(position) + return simple_action(M.ActionKind.ESCAPE, position) +end + +function ActionOutcome.empty(position) + return simple_action(M.ActionKind.EMPTY, position) +end + +function ActionOutcome.error(position, diagnostic) + return simple_action(M.ActionKind.ERROR, position, diagnostic) +end + +function ActionOutcome.is(value) + return is_record(value, "ActionOutcome") +end + +function ActionOutcome:to_table() + return { + kind = self.kind.value, + position = self.position:to_table(), + complete = self.complete, + successful_steps = self.successful_steps, + effective_descriptor = self.effective_descriptor and self.effective_descriptor.value or nil, + dot_payload = self.dot_payload and self.dot_payload:to_table() or nil, + diagnostic = self.diagnostic, + } +end + +return M diff --git a/lua/clever_tee/feedback_service.lua b/lua/clever_tee/feedback_service.lua new file mode 100644 index 0000000..b99fe04 --- /dev/null +++ b/lua/clever_tee/feedback_service.lua @@ -0,0 +1,1003 @@ +local domain = require("clever_tee.domain") +local policy = require("clever_tee.policy") +local sequence_state = require("clever_tee.sequence_state") +local state_transitions = require("clever_tee.state_transitions") +local text_topology = require("clever_tee.text_topology") + +local M = {} +local FeedbackService = {} +FeedbackService.__index = FeedbackService +M.FeedbackService = FeedbackService +local CursorPresentationLease = {} +M.CursorPresentationLease = CursorPresentationLease + +M.DEFAULT_LABEL_GROUP = "CleverTeeDefaultLabel" +M.Priority = { + HIGH = "high", + ORDINARY = "ordinary", +} +M.FINALIZER_EVENTS = { + "CursorMoved", + "InsertEnter", + "TextChanged", +} +M.EAGER_EVENTS = { + "WinEnter", + "WinLeave", + "CmdwinLeave", +} +M.FinalizerAction = { + PRESERVE = "preserve", + FINALIZE = "finalize", +} +M.MigrationReason = { + LINE_CHANGE = "line_change", + TILL_DIRECTION_CHANGE = "till_direction_change", +} + +local OVERLAY_PRIORITIES = { + CleverTeeCursor = M.Priority.HIGH, + CleverTeeChar = M.Priority.HIGH, + CleverTeeDirect = M.Priority.ORDINARY, +} + +local service_records = setmetatable({}, { __mode = "k" }) +local cursor_lease_records = setmetatable({}, { __mode = "k" }) +local temporary_release_records = setmetatable({}, { __mode = "k" }) + +local FEATURE_GROUPS = { + "CleverTeeCursor", + "CleverTeeChar", + "CleverTeeDirect", +} + +local LEGACY_NORMAL_EX_CONTEXTS = { + cv = true, + cvr = true, +} + +local DIRECT_FINALIZER_EVENTS = { + InsertEnter = true, + TextChanged = true, +} + +local EAGER_EVENT_SET = {} +for _, event_name in ipairs(M.EAGER_EVENTS) do + EAGER_EVENT_SET[event_name] = true +end + +local DEFAULT_LABEL_DEFINITION = { + guifg = "red", + guibg = "NONE", + gui = { + bold = true, + underline = true, + }, + ctermfg = "red", + ctermbg = "NONE", + cterm = { + bold = true, + underline = true, + }, +} + +local function copy(value) + if type(value) ~= "table" then + return value + end + local result = {} + for key, item in pairs(value) do + result[key] = copy(item) + end + return result +end + +function M.default_label_definition() + return copy(DEFAULT_LABEL_DEFINITION) +end + +function M.overlay_priority(group) + local priority = OVERLAY_PRIORITIES[group] + if priority == nil then + error("unknown feedback overlay group '" .. tostring(group) .. "'", 2) + end + return priority +end + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function normalize_options(options) + if type(options) ~= "table" then + fail("FeedbackService options must be a table", 3) + end + if options.host == nil then + return { host = options } + end + return options +end + +local function require_host(host) + if type(host) ~= "table" + or type(host.read_highlight_group) ~= "function" + or type(host.define_highlight_group) ~= "function" + or type(host.create_highlight) ~= "function" + or type(host.remove_highlight) ~= "function" + or type(host.read_buffer) ~= "function" + or type(host.read_cursor) ~= "function" + or type(host.read_window) ~= "function" + or type(host.register_events) ~= "function" + or type(host.remove_event_registration) ~= "function" + or type(host.start_timer) ~= "function" + or type(host.stop_timer) ~= "function" + or type(host.supports_timers) ~= "function" + or type(host.supports_cursor_presentation) ~= "function" + or type(host.suppress_cursor_presentation) ~= "function" + or type(host.restore_cursor_presentation) ~= "function" + then + fail("FeedbackService host must provide highlight groups", 3) + end + return host +end + +local function require_transitions(transitions, state) + transitions = transitions or state_transitions.new(state) + if type(transitions) ~= "table" + or type(transitions.AddTemporaryOverlay) ~= "function" + or type(transitions.RemoveTemporaryOverlay) ~= "function" + or type(transitions.AddTargetOverlay) ~= "function" + or type(transitions.ClearTargetOverlays) ~= "function" + or type(transitions.AddFinalizer) ~= "function" + or type(transitions.RemoveFinalizer) ~= "function" + or type(transitions.FullFinalization) ~= "function" + or type(transitions.ClearTargetFeedback) ~= "function" + or type(transitions.SetHighlightTimer) ~= "function" + or type(transitions.ClearHighlightTimer) ~= "function" + then + fail("FeedbackService transitions must manage overlay resources", 3) + end + return transitions +end + +local function require_policy(service, host) + service = service or policy.new(host) + if type(service) ~= "table" + or type(service.evaluate_highlight_links) ~= "function" + or type(service.sample_acquisition) ~= "function" + or type(service.sample_markers) ~= "function" + or type(service.sample_timeouts) ~= "function" + or type(service.capture_activation) ~= "function" + then + fail("FeedbackService policy must evaluate highlight links", 3) + end + return service +end + +function FeedbackService.new(options) + if FeedbackService.is(options) then + return options + end + options = normalize_options(options) + local service = setmetatable({}, FeedbackService) + local host = require_host(options.host) + local state = options.state or sequence_state.get() + if not sequence_state.is(state) then + fail("FeedbackService state must be the plugin-global SequenceState", 2) + end + service_records[service] = { + host = host, + policy = require_policy(options.policy or options.policy_service, host), + state = state, + transitions = require_transitions( + options.transitions or options.state_transitions, + state + ), + persistent_requests = {}, + owned_finalizer = nil, + activation = nil, + eager_registration = nil, + last_eager_decision = nil, + } + return service +end + +function FeedbackService.is(value) + return type(value) == "table" and service_records[value] ~= nil +end + +local cursor_lease_metatable = { + __index = function(lease, key) + local method = CursorPresentationLease[key] + if method ~= nil then + return method + end + local record = cursor_lease_records[lease] + if key == "identity" then + return record.identity + end + if key == "active" then + return record.active + end + return nil + end, + __newindex = function() + fail("cursor presentation leases are read-only", 2) + end, + __metatable = "clever_tee.feedback_service.CursorPresentationLease", +} + +local function new_cursor_presentation_lease(host, suppress) + local lease = setmetatable({}, cursor_lease_metatable) + local identity = suppress and host:suppress_cursor_presentation() or nil + cursor_lease_records[lease] = { + host = host, + identity = identity, + active = identity ~= nil, + } + return lease +end + +function CursorPresentationLease.is(value) + return type(value) == "table" and cursor_lease_records[value] ~= nil +end + +function CursorPresentationLease:release() + local record = cursor_lease_records[self] + if record == nil then + fail("cursor presentation lease is invalid", 2) + end + if not record.active then + return false + end + record.active = false + record.host:restore_cursor_presentation(record.identity) + return true +end + +function FeedbackService:create_cursor_presentation_lease(enabled) + local record = service_records[self] + if enabled == nil then + enabled = record.policy:sample_acquisition().hide_cursor_on_cmdline + elseif type(enabled) ~= "boolean" then + fail("cursor presentation policy must be a Boolean", 2) + end + local supported = enabled and record.host:supports_cursor_presentation() + return new_cursor_presentation_lease(record.host, supported == true) +end + +local function position_list(positions) + if type(positions) ~= "table" then + fail("direct marker positions must be a list", 3) + end + local result = {} + 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 marker positions must be a list", 3) + end + result[key] = domain.Position.coerce(position) + item_count = item_count + 1 + end + if item_count ~= #positions then + fail("direct marker positions must be a list", 3) + end + return result +end + +function FeedbackService:create_direct_markers(positions, window) + positions = position_list(positions) + if #positions == 0 then + return nil + end + if window == nil then + fail("direct marker window must identify its host window", 2) + end + + local record = service_records[self] + local identity = record.host:create_highlight({ + group = "CleverTeeDirect", + window = window, + positions = positions, + priority = M.overlay_priority("CleverTeeDirect"), + }) + record.transitions:AddTemporaryOverlay(identity, window, "CleverTeeDirect") + local resource = { + identity = identity, + window = window, + group = "CleverTeeDirect", + positions = positions, + } + temporary_release_records[resource] = false + return resource +end + +function FeedbackService:create_cursor_marker(position, window) + position = domain.Position.coerce(position) + if window == nil then + fail("cursor marker window must identify its host window", 2) + end + + local record = service_records[self] + local identity = record.host:create_highlight({ + group = "CleverTeeCursor", + window = window, + position = position, + priority = M.overlay_priority("CleverTeeCursor"), + }) + record.transitions:AddTemporaryOverlay(identity, window, "CleverTeeCursor") + local resource = { + identity = identity, + window = window, + group = "CleverTeeCursor", + position = position, + } + temporary_release_records[resource] = false + return resource +end + +function FeedbackService:remove_temporary_overlay(resource) + if type(resource) ~= "table" or resource.identity == nil then + fail("temporary overlay resource must identify its highlight", 2) + end + if temporary_release_records[resource] == true then + return false + end + temporary_release_records[resource] = true + local record = service_records[self] + local ok, removed = pcall( + record.host.remove_highlight, + record.host, + resource.identity + ) + record.transitions:RemoveTemporaryOverlay(resource.identity, resource.window) + if not ok then + error(removed, 0) + end + return removed +end + +function M.persistent_context_eligible(context) + context = domain.ModeContext.from_full_mode(context) + return context.key == "n" + or context.visual_kind ~= nil + or context.select_kind ~= nil + or LEGACY_NORMAL_EX_CONTEXTS[context.key] == true +end + +function M.persistent_destination( + view, + target_position, + descriptor, + endpoint_policy +) + if not text_topology.TextView.is(view) then + fail("persistent feedback requires a TextView", 2) + end + target_position = domain.Position.coerce(target_position) + descriptor = domain.Descriptor.from_string(descriptor) + endpoint_policy = domain.EndpointPolicy.from_string(endpoint_policy) + + if endpoint_policy == domain.EndpointPolicy.VISUAL_EXCLUSIVE + and descriptor.direction == domain.Direction.FORWARD + then + if descriptor.family == domain.Family.FIND then + return view:successor(target_position) + end + return target_position + end + if descriptor.family == domain.Family.FIND then + return target_position + end + if descriptor.direction == domain.Direction.FORWARD then + return view:predecessor(target_position) + end + return view:successor(target_position) +end + +function M.persistent_match_positions( + view, + match_start_line, + target_plan, + descriptor, + endpoint_policy +) + if not text_topology.TextView.is(view) then + fail("persistent feedback requires a TextView", 2) + end + if not domain.TargetPlan.is(target_plan) then + fail("persistent feedback requires a TargetPlan", 2) + end + local positions = {} + local seen = {} + local candidates = view:iter_line_forward(match_start_line) + while true do + local position, character = candidates() + if position == nil then + break + end + if target_plan:matches(character, position, view) then + local destination = M.persistent_destination( + view, + position, + descriptor, + endpoint_policy + ) + if destination ~= nil then + local key = tostring(destination.line) + .. ":" + .. tostring(destination.byte_column) + if not seen[key] then + seen[key] = true + positions[#positions + 1] = destination + end + end + end + end + return positions +end + +function FeedbackService:build_persistent(specification) + if type(specification) ~= "table" then + fail("persistent feedback request must be a table", 2) + end + local context = domain.ModeContext.from_full_mode(specification.context) + if not M.persistent_context_eligible(context) then + fail("persistent feedback request requires an eligible context", 2) + end + if not domain.TargetPlan.is(specification.target_plan) then + fail("persistent feedback request requires a TargetPlan", 2) + end + if not domain.ResolvedMotionPlan.is(specification.motion_plan) then + fail("persistent feedback request requires a ResolvedMotionPlan", 2) + end + if specification.motion_plan.target_plan ~= specification.target_plan then + fail("persistent feedback must reuse the movement TargetPlan", 2) + end + local descriptor = domain.Descriptor.from_string( + specification.descriptor or specification.motion_plan.descriptor + ) + local endpoint_policy = domain.EndpointPolicy.from_string( + specification.endpoint_policy or specification.motion_plan.endpoint_policy + ) + local anchor = domain.Position.coerce(specification.anchor) + local view = specification.text_view + or text_topology.from_host(service_records[self].host) + return { + context = context, + anchor = anchor, + target_plan = specification.target_plan, + motion_plan = specification.motion_plan, + descriptor = descriptor, + endpoint_policy = endpoint_policy, + anchor_line = anchor.line, + match_start_line = anchor.line, + positions = M.persistent_match_positions( + view, + anchor.line, + specification.target_plan, + descriptor, + endpoint_policy + ), + text_view = view, + window = specification.window, + } +end + +local function release_target_overlays(record, resources) + for _, resource in ipairs(resources) do + record.host:remove_highlight(resource.identity) + end +end + +local function remove_target_overlays(record, window) + local resources = record.transitions:ClearTargetOverlays(window) + release_target_overlays(record, resources) + return resources +end + +function FeedbackService:remove_character_overlays(window) + if window == nil then + fail("character overlay window must identify its host window", 2) + end + return remove_target_overlays(service_records[self], window) +end + +function FeedbackService:cursor_moved_decision() + local record = service_records[self] + local context = record.state.last_input_context + local expected = context and record.state:get_previous_landing(context) or nil + local actual = record.host:read_cursor() + return { + context = context, + expected = expected, + actual = actual, + equal = expected ~= nil and domain.Position.equal(actual, expected), + } +end + +local function release_finalizers(record, resources) + for _, resource in ipairs(resources) do + record.host:remove_event_registration(resource.identity) + end +end + +local function release_highlight_timer(record, identity) + if identity == nil then + return false + end + return record.host:stop_timer(identity) +end + +function FeedbackService:release_transition_cleanup(cleanup) + if type(cleanup) ~= "table" then + fail("feedback transition cleanup must be a table", 2) + end + local record = service_records[self] + release_finalizers(record, cleanup.finalizers or {}) + release_highlight_timer(record, cleanup.highlight_timer) + release_target_overlays(record, cleanup.target_overlays or {}) + if #(cleanup.finalizers or {}) > 0 then + record.owned_finalizer = nil + end + return cleanup +end + +function FeedbackService:full_finalize(window) + local record = service_records[self] + window = window or record.host:read_window() + local cleanup = record.transitions:FullFinalization(window) + self:release_transition_cleanup(cleanup) + record.owned_finalizer = nil + return cleanup +end + +function FeedbackService:handle_finalizer_event(name, payload) + if name == "CursorMoved" then + local decision = self:cursor_moved_decision() + if decision.equal then + decision.action = M.FinalizerAction.PRESERVE + else + decision.action = M.FinalizerAction.FINALIZE + decision.cleanup = self:full_finalize(payload and payload.window) + end + return decision + end + if DIRECT_FINALIZER_EVENTS[name] then + return { + action = M.FinalizerAction.FINALIZE, + cleanup = self:full_finalize(payload and payload.window), + } + end + return false +end + +local function register_finalizers(service, record) + local buffer = record.host:read_buffer() + local owned = record.owned_finalizer + if owned ~= nil and owned.buffer == buffer then + return owned + end + if owned ~= nil then + record.host:remove_event_registration(owned.identity) + record.transitions:RemoveFinalizer(owned.identity, owned.buffer) + end + + local identity = record.host:register_events( + M.FINALIZER_EVENTS, + function(name, payload) + service:handle_finalizer_event(name, payload) + end, + { buffer = buffer } + ) + record.transitions:AddFinalizer(identity, buffer) + owned = { + identity = identity, + buffer = buffer, + } + record.owned_finalizer = owned + return owned +end + +local function materialize_persistent(service, request) + if request.window == nil then + fail("persistent feedback window must identify its host window", 3) + end + local record = service_records[service] + remove_target_overlays(record, request.window) + request.identity = record.host:create_highlight({ + group = "CleverTeeChar", + window = request.window, + positions = request.positions, + priority = M.overlay_priority("CleverTeeChar"), + target_plan = request.target_plan, + descriptor = request.descriptor, + endpoint_policy = request.endpoint_policy, + anchor_line = request.anchor_line, + match_start_line = request.match_start_line, + }) + request.group = "CleverTeeChar" + request.priority = M.overlay_priority("CleverTeeChar") + local owned, ownership_error = pcall(function() + record.transitions:AddTargetOverlay( + request.identity, + request.window, + request.anchor.line + ) + request.finalizers = register_finalizers(service, record) + end) + if not owned then + local resources = record.transitions:RemoveTargetOverlay( + request.identity, + request.window + ) + if #resources == 0 then + resources[1] = { + identity = request.identity, + window = request.window, + } + end + pcall(release_target_overlays, record, resources) + error(ownership_error, 0) + end + local requests = record.persistent_requests + requests[#requests + 1] = request + return request +end + +function FeedbackService:request_persistent(specification) + return materialize_persistent(self, self:build_persistent(specification)) +end + +function FeedbackService:restore_primary(specification) + local restoration = self:build_primary_restoration(specification) + if restoration == nil then + return nil + end + return materialize_persistent(self, restoration) +end + +function FeedbackService:persistent_requests() + local result = {} + for index, request in ipairs(service_records[self].persistent_requests) do + result[index] = request + end + return result +end + +function M.repeated_till_migration_candidate(request) + if type(request) ~= "table" then + fail("command feedback migration request must be a table", 2) + end + local plan = request.resolved_motion_plan or request.plan + return domain.ResolvedMotionPlan.is(plan) + and plan.descriptor.family == domain.Family.TILL + and request.first_move == false +end + +function M.till_direction_changed(request) + if not M.repeated_till_migration_candidate(request) then + return false + end + if type(request.moved_forward) ~= "boolean" + or type(request.previous_moved_forward) ~= "boolean" + then + fail("TILL feedback migration requires movement directions", 2) + end + return request.moved_forward ~= request.previous_moved_forward +end + +function M.command_migration_reason(request) + if type(request) ~= "table" then + fail("command feedback migration request must be a table", 2) + end + local origin = domain.Position.coerce(request.origin) + local destination = domain.Position.coerce(request.destination) + if request.outcome ~= nil and request.outcome.complete ~= true then + return nil + end + if origin.line ~= destination.line then + return M.MigrationReason.LINE_CHANGE + end + if M.till_direction_changed(request) then + return M.MigrationReason.TILL_DIRECTION_CHANGE + end + return nil +end + +local function has_target_overlay(record, window) + for _, resource in ipairs(record.state.target_overlays) do + if resource.window == window then + return true + end + end + return false +end + +function FeedbackService:primary_restoration_active(context, window) + local record = service_records[self] + context = domain.ModeContext.from_full_mode(context) + local mark_char = record.policy:sample_markers().mark_char + if not mark_char or not M.persistent_context_eligible(context) then + return false + end + window = window or record.host:read_window() + return not has_target_overlay(record, window) +end + +function FeedbackService:build_primary_restoration(specification) + if type(specification) ~= "table" then + fail("primary feedback restoration must be a table", 2) + end + local window = specification.window + or service_records[self].host:read_window() + if not self:primary_restoration_active(specification.context, window) then + return nil + end + if not domain.TargetPlan.is(specification.target_plan) then + fail("primary feedback restoration requires an action TargetPlan", 2) + end + local action_motion_plan = specification.motion_plan + local search_scope = specification.search_scope + or (domain.ResolvedMotionPlan.is(action_motion_plan) + and action_motion_plan.search_scope) + or domain.SearchScope.BUFFER + local motion_plan = domain.ResolvedMotionPlan.new({ + target_plan = specification.target_plan, + descriptor = specification.stored_descriptor, + search_scope = search_scope, + endpoint_policy = specification.endpoint_policy, + }) + return self:build_persistent({ + context = specification.context, + anchor = specification.anchor, + target_plan = specification.target_plan, + motion_plan = motion_plan, + descriptor = specification.stored_descriptor, + endpoint_policy = specification.endpoint_policy, + text_view = specification.text_view, + window = window, + }) +end + +function FeedbackService:migrate_command(request) + local reason = M.command_migration_reason(request) + local record = service_records[self] + local window = request.window or record.host:read_window() + if reason == nil or not has_target_overlay(record, window) then + return { + migrated = false, + reason = reason, + } + end + + local plan = request.resolved_motion_plan or request.plan + if not domain.ResolvedMotionPlan.is(plan) then + fail("command feedback migration requires a ResolvedMotionPlan", 2) + end + local overlay = self:request_persistent({ + context = request.context, + anchor = request.destination, + target_plan = plan.target_plan, + motion_plan = plan, + descriptor = plan.descriptor, + endpoint_policy = plan.endpoint_policy, + window = window, + }) + return { + migrated = true, + reason = reason, + overlay = overlay, + } +end + +function FeedbackService:highlight_timer_delay() + local record = service_records[self] + if not record.policy:sample_markers().mark_char then + return nil + end + local delay = record.policy:sample_timeouts().highlight_timeout_ms + if delay == 0 or record.host:supports_timers() ~= true then + return nil + end + return delay +end + +function FeedbackService:cancel_highlight_timer() + local record = service_records[self] + local identity = record.transitions:ClearHighlightTimer() + release_highlight_timer(record, identity) + return identity +end + +function FeedbackService:handle_highlight_timer(callback_identity, window) + if callback_identity == nil then + fail("highlight timer callback identity must be present", 2) + end + local record = service_records[self] + if callback_identity ~= record.state.highlight_timer then + return false + end + local _, current = record.transitions:ClearHighlightTimer(callback_identity) + if not current then + return false + end + self:remove_character_overlays(window or record.host:read_window()) + return true +end + +function FeedbackService:start_highlight_timer(window) + local record = service_records[self] + local delay = self:highlight_timer_delay() + if delay == nil then + return nil + end + window = window or record.host:read_window() + self:cancel_highlight_timer() + local identity + identity = record.host:start_timer(delay, function(callback_identity) + self:handle_highlight_timer(callback_identity or identity, window) + end) + record.transitions:SetHighlightTimer(identity) + return identity +end + +function FeedbackService:refresh_primary(resolved_target, window) + if resolved_target == nil then + return nil + end + if not domain.TargetValue.is(resolved_target) then + fail("primary timer refresh requires a resolved TargetValue", 2) + end + return self:start_highlight_timer(window) +end + +function FeedbackService:handle_eager_event(name, payload) + if not EAGER_EVENT_SET[name] then + return false + end + local record = service_records[self] + local decision = { + event = name, + payload = payload, + mark_char = record.policy:sample_markers().mark_char, + cleaned = false, + } + if decision.mark_char then + local window = payload and payload.window or record.host:read_window() + local cleanup = record.transitions:ClearTargetFeedback(window) + release_highlight_timer(record, cleanup.highlight_timer) + release_target_overlays(record, cleanup.target_overlays) + decision.cleaned = true + decision.cleanup = cleanup + end + record.last_eager_decision = decision + return decision +end + +function FeedbackService:last_eager_decision() + local decision = service_records[self].last_eager_decision + return decision and copy(decision) or nil +end + +function FeedbackService:activate() + local record = service_records[self] + if record.activation ~= nil then + return copy(record.activation) + end + local sampled = record.policy:capture_activation() + local activation = { + clean_labels_eagerly = sampled.clean_labels_eagerly, + eager_registration = nil, + } + if sampled.clean_labels_eagerly then + local identity = record.host:register_events( + M.EAGER_EVENTS, + function(name, payload) + self:handle_eager_event(name, payload) + end, + { owner = "clever_tee", lifecycle = "eager" } + ) + record.eager_registration = identity + activation.eager_registration = identity + end + record.activation = activation + return copy(activation) +end + +function FeedbackService:evaluate_feature_links() + local record = service_records[self] + local rules = record.policy:evaluate_highlight_links() + local results = {} + for _, group in ipairs(FEATURE_GROUPS) do + local rule = rules[group] + if rule.enabled then + if rule.configured_target ~= nil then + record.host:define_highlight_group( + group, + { link = rule.configured_target }, + { force = true } + ) + results[group] = { + group = group, + target = rule.configured_target, + source = "configured", + applied = true, + } + else + local existing = record.host:read_highlight_group(group) + if existing ~= nil then + results[group] = { + group = group, + definition = existing, + source = "colorscheme", + applied = false, + } + else + record.host:define_highlight_group( + group, + { link = rule.target }, + { default = true } + ) + results[group] = { + group = group, + target = rule.target, + source = "fallback", + applied = true, + } + end + end + end + end + return results +end + +function FeedbackService:ensure_default_label() + local existing = service_records[self].host:read_highlight_group( + M.DEFAULT_LABEL_GROUP + ) + if existing ~= nil then + return { + group = M.DEFAULT_LABEL_GROUP, + definition = existing, + source = "colorscheme", + applied = false, + } + end + + local definition = M.default_label_definition() + service_records[self].host:define_highlight_group( + M.DEFAULT_LABEL_GROUP, + definition, + { default = true } + ) + return { + group = M.DEFAULT_LABEL_GROUP, + definition = definition, + source = "fallback", + applied = true, + } +end + +function FeedbackService:evaluate_highlights() + return { + default_label = self:ensure_default_label(), + feature_links = self:evaluate_feature_links(), + } +end + +function M.new(options) + return FeedbackService.new(options) +end + +setmetatable(M, { + __call = function(_, options) + return FeedbackService.new(options) + end, +}) + +return M diff --git a/lua/clever_tee/host_adapter.lua b/lua/clever_tee/host_adapter.lua new file mode 100644 index 0000000..c746f60 --- /dev/null +++ b/lua/clever_tee/host_adapter.lua @@ -0,0 +1,1165 @@ +local capabilities = require("clever_tee.capabilities") +local domain = require("clever_tee.domain") + +local M = {} +local unpack_values = table.unpack or unpack +local HostAdapter = {} +HostAdapter.__index = HostAdapter +M.HostAdapter = HostAdapter + +M.ActionEffect = { + NONE = "none", + ESCAPE = "escape", + ERROR = "error", +} +M.CONFIGURATION_PREFIX = "clever_tee_" +M.CONFIGURATION_GLOBALS = { + suppress_default_mappings = "clever_tee_not_overwrites_standard_mappings", +} + +local BOOLEAN_CONFIGURATION = { + search_current_line_only = true, + ignore_case = true, + smart_case = true, + use_migemo = true, + fix_key_direction = true, + show_prompt = true, + mark_cursor = true, + hide_cursor_on_cmdline = true, + mark_char = true, + mark_direct = true, + clean_labels_eagerly = true, +} + +local adapter_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function current_runtime(options) + if type(options) == "table" then + if options.runtime ~= nil then + return options.runtime + end + if options.api ~= nil then + return options + end + return rawget(_G, "vim") + end + if options ~= nil and options ~= HostAdapter then + return options + end + return rawget(_G, "vim") +end + +local function require_runtime(runtime) + if type(runtime) ~= "table" or type(runtime.api) ~= "table" then + fail("HostAdapter requires the Nvim Lua runtime", 3) + end + return runtime +end + +function HostAdapter.new(options) + if HostAdapter.is(options) then + return options + end + local adapter = setmetatable({}, HostAdapter) + local record = { + runtime = require_runtime(current_runtime(options)), + next_identity = 1, + highlights = {}, + timers = {}, + cursor_presentations = {}, + events = {}, + actions = {}, + mappings = {}, + dot_repeat = nil, + dot_bridge = nil, + event_order = {}, + action_diagnostics = nil, + augroup = nil, + } + record.event_queue = capabilities.EventQueue.new(function(_, delivery) + delivery.callback(delivery.name, delivery.payload) + end) + adapter_records[adapter] = record + return adapter +end + +function HostAdapter.is(value) + return type(value) == "table" and adapter_records[value] ~= nil +end + +function HostAdapter:runtime() + return adapter_records[self].runtime +end + +function HostAdapter:read_text() + local lines = self:runtime().api.nvim_buf_get_lines(0, 0, -1, true) + if #lines == 0 then + lines = { "" } + end + return domain.TextSnapshot.new(lines) +end + +function HostAdapter:read_buffer() + return self:runtime().api.nvim_get_current_buf() +end + +function HostAdapter:read_window() + return self:runtime().api.nvim_get_current_win() +end + +function HostAdapter:read_cursor() + local position = self:runtime().api.nvim_win_get_cursor(0) + return domain.Position.new(position[1], position[2] + 1) +end + +function HostAdapter:read_mode() + return self:runtime().api.nvim_get_mode().mode +end + +local function selection_option(runtime) + local value = runtime.api.nvim_get_option_value( + "selection", + { scope = "global" } + ) + if value == "exclusive" then + return domain.SelectionOption.EXCLUSIVE + end + return domain.SelectionOption.INCLUSIVE +end + +function HostAdapter:read_selection() + local runtime = self:runtime() + local context = domain.ModeContext.from_full_mode(self:read_mode()) + local kind = context.visual_kind or context.select_kind + local option = selection_option(runtime) + if kind == nil then + return domain.Selection.inactive(option) + end + local raw_anchor = runtime.fn.getpos("v") + local focus = self:read_cursor() + local anchor + if type(raw_anchor) == "table" + and type(raw_anchor[2]) == "number" + and raw_anchor[2] > 0 + and type(raw_anchor[3]) == "number" + and raw_anchor[3] > 0 + then + anchor = domain.Position.new(raw_anchor[2], raw_anchor[3]) + else + anchor = focus + end + return domain.Selection.active(kind, anchor, focus, option) +end + +function HostAdapter:read_count() + local runtime = self:runtime() + local count = runtime.v.count1 + if type(count) ~= "number" or count < 1 then + count = 1 + end + return domain.Count.new(count) +end + +local function configuration_global(name) + if type(name) ~= "string" or name == "" then + fail("configuration name must be a nonempty string", 3) + end + return M.CONFIGURATION_GLOBALS[name] or M.CONFIGURATION_PREFIX .. name +end + +function M.configuration_global(name) + return configuration_global(name) +end + +function HostAdapter:configuration_present(name) + local global = configuration_global(name) + return self:runtime().fn.exists("g:" .. global) == 1 +end + +local function normalize_configuration(name, value) + if BOOLEAN_CONFIGURATION[name] and type(value) == "number" then + return value ~= 0 + end + return value +end + +function HostAdapter:read_configuration(name) + local global = configuration_global(name) + return normalize_configuration(name, self:runtime().g[global]) +end + +function HostAdapter:write_configuration(name, value) + local global = configuration_global(name) + self:runtime().g[global] = value +end + +function HostAdapter:read_encoding() + local runtime = self:runtime() + return runtime.api.nvim_get_option_value( + "encoding", + { scope = "global" } + ) +end + +function HostAdapter:lowercase(value) + if type(value) ~= "string" then + fail("case conversion value must be a string", 2) + end + local result = self:runtime().fn.tolower(value) + if type(result) ~= "string" then + fail("Nvim case conversion must return a string", 2) + end + return result +end + +function HostAdapter:read_macro_state() + local register = self:runtime().fn.reg_executing() + return domain.MacroState.new(register ~= "" and register or nil) +end + +local function fold_open_policies(value) + local result = {} + for item in tostring(value):gmatch("[^,]+") do + if item == "hor" then + item = "horizontal" + end + result[#result + 1] = item + end + return result +end + +function HostAdapter:read_fold_state() + local runtime = self:runtime() + local foldopen = runtime.api.nvim_get_option_value( + "foldopen", + { scope = "global" } + ) + local line = self:read_cursor().line + local closed_levels = runtime.fn.foldclosed(line) == -1 and 0 or 1 + return domain.FoldState.new( + fold_open_policies(foldopen), + closed_levels + ) +end + +function HostAdapter:read_time_ms() + local runtime = self:runtime() + local uv = runtime.uv or runtime.loop + if type(uv) ~= "table" or type(uv.hrtime) ~= "function" then + fail("HostAdapter runtime must provide a monotonic clock", 2) + end + return uv.hrtime() / 1000000 +end + +function HostAdapter:read_pending_operator() + local operator = self:runtime().v.operator + if operator == nil then + return "" + end + return operator +end + +function HostAdapter:apply_cursor(position) + position = domain.Position.coerce(position) + self:runtime().api.nvim_win_set_cursor( + 0, + { position.line, position.byte_column - 1 } + ) +end + +function HostAdapter:apply_selection(position) + if domain.Selection.is(position) then + if not position.active then + fail("selection movement requires an active selection", 2) + end + position = position.focus + end + return self:apply_cursor(position) +end + +function HostAdapter:set_operator_inclusive(enabled) + if type(enabled) ~= "boolean" then + fail("operator inclusivity must be a Boolean", 2) + end + if not enabled then + return + end + + local runtime = self:runtime() + local api = runtime.api + local selection + if type(api.nvim_get_option_value) == "function" then + selection = api.nvim_get_option_value("selection", { scope = "global" }) + end + if selection ~= "exclusive" then + api.nvim_cmd({ + cmd = "normal", + bang = true, + args = { "v" }, + }, {}) + return + end + if type(api.nvim_set_option_value) ~= "function" + or type(runtime.schedule) ~= "function" + then + fail("HostAdapter cannot preserve exclusive selection during an operator", 2) + end + + api.nvim_set_option_value("selection", "inclusive", { scope = "global" }) + local ok, command_error = pcall(api.nvim_cmd, { + cmd = "normal", + bang = true, + args = { "v" }, + }, {}) + if not ok then + api.nvim_set_option_value("selection", selection, { scope = "global" }) + error(command_error, 0) + end + runtime.schedule(function() + api.nvim_set_option_value("selection", selection, { scope = "global" }) + end) +end + +local function string_bytes(value) + local bytes = {} + for index = 1, #value do + bytes[index] = string.byte(value, index) + end + return bytes +end + +function HostAdapter:read_input() + local runtime = self:runtime() + local value = runtime.fn.getcharstr() + if type(value) ~= "string" or value == "" then + fail("Nvim target input must be a nonempty string", 2) + end + local bytes = string_bytes(value) + if #bytes == 3 + and bytes[1] == 0x80 + and bytes[2] == 0xfd + and bytes[3] == 0x60 + then + return domain.InputPacket.raw_bytes(bytes) + end + if #bytes == 1 and bytes[1] == 27 then + return domain.InputPacket.special_key("Escape", bytes) + end + if bytes[1] == 0x80 then + local name = type(runtime.fn.keytrans) == "function" + and runtime.fn.keytrans(value) + or "Special" + return domain.InputPacket.special_key(name, value) + end + return domain.InputPacket.text(value) +end + +function HostAdapter:open_fold(position) + position = position and domain.Position.coerce(position) or self:read_cursor() + local runtime = self:runtime() + if runtime.fn.foldclosed(position.line) == -1 then + return false + end + runtime.api.nvim_cmd({ + cmd = "normal", + bang = true, + args = { "zo" }, + }, {}) + return true +end + +function HostAdapter:show_prompt(text) + if type(text) ~= "string" then + fail("prompt must be a string", 2) + end + self:runtime().api.nvim_echo({ { text } }, false, {}) +end + +function HostAdapter:redraw(kind) + if kind == "suppressed" then + return false + end + if kind ~= "screen" and kind ~= "full" then + fail("redraw kind must be screen, full, or suppressed", 2) + end + self:runtime().api.nvim_cmd({ + cmd = "redraw", + bang = kind == "full", + }, {}) + return true +end + +local DIAGNOSTIC_LEVELS = { + error = "ERROR", + warning = "WARN", + info = "INFO", +} + +function HostAdapter:emit_diagnostic(level, text) + local level_name = DIAGNOSTIC_LEVELS[level] + if level_name == nil then + fail("diagnostic level must be error, warning, or info", 2) + end + if type(text) ~= "string" or text == "" then + fail("diagnostic text must be a nonempty string", 2) + end + local record = adapter_records[self] + local runtime = record.runtime + if type(runtime.notify) ~= "function" then + fail("HostAdapter runtime must provide notify", 2) + end + local levels = type(runtime.log) == "table" and runtime.log.levels or {} + runtime.notify(text, levels[level_name], { title = "clever-tee" }) + if record.action_diagnostics ~= nil then + record.action_diagnostics[level .. "\0" .. text] = true + end +end + +local install_dot_bridge + +function HostAdapter:register_dot_repeat(payload, callback) + if not domain.DotPayload.is(payload) then + fail("dot-repeat payload must be a DotPayload", 2) + end + if callback ~= nil and type(callback) ~= "function" then + fail("dot-repeat callback must be a function", 2) + end + local record = adapter_records[self] + record.dot_repeat = { + payload = payload, + callback = callback, + operator = self:read_pending_operator(), + } + if install_dot_bridge ~= nil then + install_dot_bridge(self) + end + if record.dot_bridge ~= nil then + record.dot_bridge.awaiting_change = true + end + return payload +end + +function HostAdapter:dot_repeat_payload() + local registration = adapter_records[self].dot_repeat + return registration and registration.payload or nil +end + +function HostAdapter:replay_dot(count) + local registration = adapter_records[self].dot_repeat + if registration == nil or registration.callback == nil then + fail("dot repeat is not executable", 2) + end + return registration.callback( + registration.payload, + domain.Count.new(count) + ) +end + +local function next_identity(adapter, prefix) + local record = adapter_records[adapter] + local identity = prefix .. "-" .. tostring(record.next_identity) + record.next_identity = record.next_identity + 1 + return identity +end + +local function highlight_exists(runtime, name) + if type(runtime.fn) == "table" and type(runtime.fn.hlexists) == "function" then + return runtime.fn.hlexists(name) == 1 + end + local definition = runtime.api.nvim_get_hl(0, { + name = name, + link = true, + create = false, + }) + return next(definition) ~= nil +end + +function HostAdapter:read_highlight_group(name) + if type(name) ~= "string" or name == "" then + fail("highlight group name must be a nonempty string", 2) + end + local runtime = self:runtime() + if not highlight_exists(runtime, name) then + return nil + end + return runtime.api.nvim_get_hl(0, { + name = name, + link = true, + create = false, + }) +end + +local function native_highlight_definition(definition, options) + if type(definition) ~= "table" then + fail("highlight group definition must be a table", 3) + end + options = options or {} + if type(options) ~= "table" then + fail("highlight group options must be a table", 3) + end + local native = {} + for key, value in pairs(definition) do + if key ~= "guifg" and key ~= "guibg" and key ~= "gui" then + native[key] = value + end + end + if definition.guifg ~= nil then + native.fg = definition.guifg + end + if definition.guibg ~= nil then + native.bg = definition.guibg + end + for key, value in pairs(definition.gui or {}) do + native[key] = value + end + if options.default ~= nil then + native.default = options.default + end + if options.force ~= nil then + native.force = options.force + end + return native +end + +function HostAdapter:define_highlight_group(name, definition, options) + if type(name) ~= "string" or name == "" then + fail("highlight group name must be a nonempty string", 2) + end + options = options or {} + local runtime = self:runtime() + if options.default and highlight_exists(runtime, name) then + return false + end + runtime.api.nvim_set_hl( + 0, + name, + native_highlight_definition(definition, options) + ) + return true +end + +local function overlay_positions(specification) + local positions = specification.positions + if positions == nil and specification.position ~= nil then + positions = { specification.position } + end + if type(positions) ~= "table" then + fail("highlight positions must be a list", 3) + end + local native = {} + for index, position in ipairs(positions) do + position = domain.Position.coerce(position) + native[index] = { position.line, position.byte_column } + end + if #native == 0 then + native[1] = { 0 } + end + return native +end + +local function overlay_priority(value) + if value == "high" then + return 100 + end + if value == "ordinary" or value == nil then + return 10 + end + if type(value) == "number" then + return value + end + fail("highlight priority must be high, ordinary, or numeric", 3) +end + +function HostAdapter:create_highlight(specification) + if type(specification) ~= "table" then + fail("highlight specification must be a table", 2) + end + if type(specification.group) ~= "string" or specification.group == "" then + fail("highlight group must be a nonempty string", 2) + end + if specification.window == nil then + fail("highlight window must identify its Nvim window", 2) + end + local record = adapter_records[self] + local identity = specification.identity or next_identity(self, "highlight") + if record.highlights[identity] ~= nil then + fail("highlight identity is already active", 2) + end + local match_id = record.runtime.fn.matchaddpos( + specification.group, + overlay_positions(specification), + overlay_priority(specification.priority), + -1, + { window = specification.window } + ) + if type(match_id) ~= "number" or match_id < 0 then + fail("Nvim could not create the window-local highlight", 2) + end + record.highlights[identity] = { + match_id = match_id, + window = specification.window, + } + return identity +end + +function HostAdapter:remove_highlight(identity) + local record = adapter_records[self] + local resource = record.highlights[identity] + if resource == nil then + return false + end + record.highlights[identity] = nil + record.runtime.fn.matchdelete(resource.match_id, resource.window) + return true +end + +local function nonnegative_integer(value, name) + if type(value) ~= "number" + or value < 0 + or value ~= math.floor(value) + or value == math.huge + then + fail((name or "value") .. " must be a nonnegative integer", 3) + end + return value +end + +function HostAdapter:supports_timers() + local fn = self:runtime().fn + return type(fn) == "table" + and type(fn.timer_start) == "function" + and type(fn.timer_stop) == "function" +end + +function HostAdapter:start_timer(delay_ms, callback) + nonnegative_integer(delay_ms, "timer delay") + if type(callback) ~= "function" then + fail("timer callback must be a function", 2) + end + if not self:supports_timers() then + return nil + end + local record = adapter_records[self] + local identity = next_identity(self, "timer") + local timer_id = record.runtime.fn.timer_start(delay_ms, function() + local resource = record.timers[identity] + if resource == nil or not resource.active then + return + end + record.timers[identity] = nil + callback(identity) + end) + if type(timer_id) ~= "number" or timer_id < 0 then + fail("Nvim could not start the timer", 2) + end + record.timers[identity] = { + timer_id = timer_id, + active = true, + } + return identity +end + +function HostAdapter:stop_timer(identity) + local record = adapter_records[self] + local resource = record.timers[identity] + if resource == nil or not resource.active then + return false + end + record.timers[identity] = nil + record.runtime.fn.timer_stop(resource.timer_id) + return true +end + +local function event_names(value) + if type(value) == "string" then + value = { value } + end + if type(value) ~= "table" or #value == 0 then + fail("event names must be a nonempty list", 3) + end + local names = {} + local set = {} + for index, name in ipairs(value) do + if type(name) ~= "string" or name == "" then + fail("event name must be a nonempty string", 3) + end + if not set[name] then + names[#names + 1] = name + set[name] = true + end + end + return names, set +end + +local function event_payload(adapter, event) + local payload = { + buffer = event.buf, + file = event.file, + match = event.match, + data = event.data, + } + local api = adapter:runtime().api + if type(api.nvim_get_current_win) == "function" then + payload.window = api.nvim_get_current_win() + end + return payload +end + +local function event_augroup(record) + if record.augroup == nil then + record.augroup = record.runtime.api.nvim_create_augroup( + "clever_tee", + { clear = true } + ) + end + return record.augroup +end + +local function queue_event(record, name, payload, callback) + return record.event_queue:emit(name, { + name = name, + payload = payload, + callback = callback, + }) +end + +function HostAdapter:register_events(names, callback, options) + local name_set + names, name_set = event_names(names) + if type(callback) ~= "function" then + fail("event callback must be a function", 2) + end + options = options or {} + if type(options) ~= "table" then + fail("event registration options must be a table", 2) + end + local record = adapter_records[self] + local identity = next_identity(self, "event-registration") + local autocmd_options = { + group = event_augroup(record), + desc = "clever-tee " .. table.concat(names, "/"), + callback = function(event) + local resource = record.events[identity] + if resource ~= nil and resource.active then + queue_event( + record, + event.event, + event_payload(self, event), + resource.callback + ) + end + end, + } + if options.buffer ~= nil then + autocmd_options.buffer = options.buffer + end + local autocmd_id = record.runtime.api.nvim_create_autocmd( + names, + autocmd_options + ) + record.events[identity] = { + autocmd_id = autocmd_id, + names = names, + name_set = name_set, + callback = callback, + buffer = options.buffer, + active = true, + } + record.event_order[#record.event_order + 1] = identity + return identity +end + +function HostAdapter:remove_event_registration(identity) + local record = adapter_records[self] + local resource = record.events[identity] + if resource == nil or not resource.active then + return false + end + resource.active = false + record.runtime.api.nvim_del_autocmd(resource.autocmd_id) + return true +end + +local DOT_MOTION_MAPPING = "<Plug>(clever-tee-dot-motion)" + +local function dot_bridge_supported(runtime) + return type(runtime.keymap) == "table" + and type(runtime.keymap.set) == "function" + and type(runtime.keymap.del) == "function" + and type(runtime.fn.maparg) == "function" + and type(runtime.fn.mapset) == "function" + and type(runtime.api.nvim_feedkeys) == "function" +end + +local function restore_dot_mapping(record) + local bridge = record.dot_bridge + if bridge == nil or not bridge.active then + return false + end + bridge.active = false + pcall(record.runtime.keymap.del, "n", ".") + if type(bridge.previous_mapping) == "table" + and next(bridge.previous_mapping) ~= nil + then + record.runtime.fn.mapset("n", false, bridge.previous_mapping) + end + return true +end + +local function dot_replay_keys(runtime, count, operator) + local prefix = count > 0 and tostring(count) or "" + local keys = prefix .. operator .. DOT_MOTION_MAPPING + if type(runtime.keycode) == "function" then + return runtime.keycode(keys) + end + return runtime.api.nvim_replace_termcodes(keys, true, false, true) +end + +install_dot_bridge = function(adapter) + local record = adapter_records[adapter] + local runtime = record.runtime + if not dot_bridge_supported(runtime) then + return nil + end + local bridge = record.dot_bridge + if bridge == nil then + bridge = { + active = false, + awaiting_change = false, + previous_mapping = nil, + } + record.dot_bridge = bridge + runtime.keymap.set("o", DOT_MOTION_MAPPING, function() + local registration = record.dot_repeat + if registration == nil or registration.callback == nil then + return + end + local outcome = registration.callback( + registration.payload, + adapter:read_count() + ) + if domain.ActionOutcome.is(outcome) then + adapter:translate_action_outcome(outcome) + end + end, { + silent = true, + remap = false, + desc = "clever-tee dot motion", + }) + local has_cmd_atom = type(runtime.fn.exists) == "function" + and runtime.fn.exists("##CmdAtom") == 1 + local ownership_events = has_cmd_atom + and "CmdAtom" + or { "TextChanged", "TextChangedI", "TextChangedP" } + runtime.api.nvim_create_autocmd(ownership_events, { + group = event_augroup(record), + desc = "clever-tee dot ownership", + callback = function(event) + if has_cmd_atom and not (event.data and event.data.changed) then + return + end + if bridge.awaiting_change then + bridge.awaiting_change = false + return + end + restore_dot_mapping(record) + end, + }) + end + if not bridge.active then + bridge.previous_mapping = runtime.fn.maparg(".", "n", false, true) + runtime.keymap.set("n", ".", function() + local registration = record.dot_repeat + if registration == nil or registration.operator == "" then + restore_dot_mapping(record) + runtime.api.nvim_feedkeys(".", "n", false) + return + end + bridge.awaiting_change = true + local count = runtime.v.count or 0 + runtime.api.nvim_feedkeys( + dot_replay_keys(runtime, count, registration.operator), + "n", + false + ) + end, { + silent = true, + remap = false, + desc = "clever-tee dot repeat", + }) + bridge.active = true + end + return bridge +end + +function HostAdapter:deliver_event(name, payload) + if type(name) ~= "string" or name == "" then + fail("event name must be a nonempty string", 2) + end + payload = payload or {} + local record = adapter_records[self] + local event_buffer = payload.buffer + for _, identity in ipairs(record.event_order) do + local resource = record.events[identity] + if resource.active + and resource.name_set[name] + and (resource.buffer == nil + or event_buffer == nil + or resource.buffer == event_buffer) + then + queue_event(record, name, payload, resource.callback) + end + end +end + +function HostAdapter:begin_action_transition() + local record = adapter_records[self] + record.action_diagnostics = {} + return record.event_queue:begin_transition() +end + +function HostAdapter:commit_action_transition(token) + local record = adapter_records[self] + local result = record.event_queue:commit_transition(token) + record.action_diagnostics = nil + return result +end + +local function terminal_cursor_option(runtime) + return runtime.fn.eval("&t_ve") +end + +local function set_terminal_cursor_option(runtime, value) + runtime.api.nvim_cmd({ + cmd = "let", + args = { "&t_ve", "=", runtime.fn.string(value) }, + }, {}) +end + +function HostAdapter:supports_cursor_presentation() + local runtime = self:runtime() + return type(runtime.api.nvim_get_option_value) == "function" + and type(runtime.api.nvim_set_option_value) == "function" + and type(runtime.api.nvim_cmd) == "function" + and type(runtime.fn) == "table" + and type(runtime.fn.exists) == "function" + and runtime.fn.exists("+t_ve") == 1 + and type(runtime.fn.eval) == "function" + and type(runtime.fn.string) == "function" +end + +function HostAdapter:suppress_cursor_presentation() + if not self:supports_cursor_presentation() then + return nil + end + local record = adapter_records[self] + local runtime = record.runtime + local identity = next_identity(self, "cursor-presentation") + local saved = { + guicursor = runtime.api.nvim_get_option_value( + "guicursor", + { scope = "global" } + ), + terminal_cursor = terminal_cursor_option(runtime), + } + runtime.api.nvim_set_option_value( + "guicursor", + "a:ver1", + { scope = "global" } + ) + local ok, failure = pcall(set_terminal_cursor_option, runtime, "") + if not ok then + runtime.api.nvim_set_option_value( + "guicursor", + saved.guicursor, + { scope = "global" } + ) + error(failure, 0) + end + record.cursor_presentations[identity] = saved + return identity +end + +function HostAdapter:restore_cursor_presentation(identity) + local record = adapter_records[self] + local saved = record.cursor_presentations[identity] + if saved == nil then + return false + end + record.cursor_presentations[identity] = nil + record.runtime.api.nvim_set_option_value( + "guicursor", + saved.guicursor, + { scope = "global" } + ) + set_terminal_cursor_option(record.runtime, saved.terminal_cursor) + return true +end + +local function escape_key(runtime) + if type(runtime.keycode) == "function" then + return runtime.keycode("<Esc>") + end + if type(runtime.api.nvim_replace_termcodes) == "function" then + return runtime.api.nvim_replace_termcodes("<Esc>", true, false, true) + end + return string.char(27) +end + +function HostAdapter:return_escape() + local runtime = self:runtime() + if type(runtime.api.nvim_feedkeys) ~= "function" then + fail("HostAdapter runtime must provide nvim_feedkeys", 2) + end + runtime.api.nvim_feedkeys(escape_key(runtime), "n", false) +end + +function HostAdapter:emit_action_error(text) + return self:emit_diagnostic("error", text) +end + +function HostAdapter:translate_action_outcome(outcome) + if not domain.ActionOutcome.is(outcome) then + fail("host action translation requires an ActionOutcome", 2) + end + if outcome.kind == domain.ActionKind.ESCAPE then + self:return_escape() + return M.ActionEffect.ESCAPE + end + if outcome.kind == domain.ActionKind.ERROR then + local diagnostics = adapter_records[self].action_diagnostics + local key = "error\0" .. outcome.diagnostic + if diagnostics == nil or not diagnostics[key] then + self:emit_action_error(outcome.diagnostic) + end + return M.ActionEffect.ERROR + end + return M.ActionEffect.NONE +end + +local function packed(...) + return { n = select("#", ...), ... } +end + +local function invoke_callback(adapter, callback, ...) + local arguments = packed(...) + local token = adapter:begin_action_transition() + local results = packed(pcall(function() + local values = packed(callback(unpack_values(arguments, 1, arguments.n))) + if domain.ActionOutcome.is(values[1]) then + adapter:translate_action_outcome(values[1]) + end + return unpack_values(values, 1, values.n) + end)) + local commit = packed(pcall(adapter.commit_action_transition, adapter, token)) + if not results[1] then + error(results[2], 0) + end + if not commit[1] then + error(commit[2], 0) + end + return unpack_values(results, 2, results.n) +end + +function HostAdapter:register_action(name, callback) + if type(name) ~= "string" or name == "" then + fail("action name must be a nonempty string", 2) + end + if type(callback) ~= "function" then + fail("action callback must be a function", 2) + end + local actions = adapter_records[self].actions + if actions[name] ~= nil then + fail("action is already registered", 2) + end + actions[name] = callback + return name +end + +function HostAdapter:invoke_action(name, ...) + local callback = adapter_records[self].actions[name] + if callback == nil then + fail("action is not registered", 2) + end + return invoke_callback(self, callback, ...) +end + +function HostAdapter:invoke_callback(callback, ...) + if type(callback) ~= "function" then + fail("action callback must be a function", 2) + end + return invoke_callback(self, callback, ...) +end + +local function mapping_modes(value) + if type(value) == "string" then + value = { value } + end + if type(value) ~= "table" or #value == 0 then + fail("mapping modes must be a nonempty list", 3) + end + local result = {} + for index, mode in ipairs(value) do + if type(mode) ~= "string" or mode == "" then + fail("mapping mode must be a nonempty string", 3) + end + result[index] = mode + end + return result +end + +function HostAdapter:register_mapping(modes, lhs, action, options) + modes = mapping_modes(modes) + if type(lhs) ~= "string" or lhs == "" then + fail("mapping lhs must be a nonempty string", 2) + end + if type(action) ~= "string" and type(action) ~= "function" then + fail("mapping action must be an action name or function", 2) + end + options = options or {} + if type(options) ~= "table" then + fail("mapping options must be a table", 2) + end + local callback + if type(action) == "string" then + callback = function() + return self:invoke_action(action) + end + else + callback = function(...) + return invoke_callback(self, action, ...) + end + end + local native_options = { + silent = options.silent == true, + remap = options.remap == true, + desc = options.desc + or ("clever-tee " .. (type(action) == "string" and action or lhs)), + } + self:runtime().keymap.set(modes, lhs, callback, native_options) + local identity = next_identity(self, "mapping") + adapter_records[self].mappings[identity] = { + modes = modes, + lhs = lhs, + action = action, + options = options, + callback = callback, + } + return identity +end + +function M.new(options) + return HostAdapter.new(options) +end + +setmetatable(M, { + __call = function(_, options) + return HostAdapter.new(options) + end, +}) + +return M diff --git a/lua/clever_tee/init.lua b/lua/clever_tee/init.lua new file mode 100644 index 0000000..85abc86 --- /dev/null +++ b/lua/clever_tee/init.lua @@ -0,0 +1,118 @@ +local composition_root = require("clever_tee.composition_root") +local host_adapter = require("clever_tee.host_adapter") + +local M = {} +local active_root +local active_activation + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function build_root(options) + if composition_root.CompositionRoot.is(options) then + return options + end + if host_adapter.HostAdapter.is(options) then + return composition_root.new({ host = options }) + end + options = options or {} + if type(options) ~= "table" then + fail("clever-tee activation options must be a table", 3) + end + if options.host == nil then + local adapter_options = options.runtime ~= nil + and { runtime = options.runtime } + or nil + options = { host = host_adapter.new(adapter_options) } + end + return composition_root.new(options) +end + +function M.activate(options) + if active_root == nil then + active_root = build_root(options) + active_activation = active_root:activate() + end + return active_activation +end + +local function root() + M.activate() + return active_root +end + +function M.root() + return root() +end + +function M.state() + return root():state() +end + +local function invoke(name) + local instance = root() + return instance:host():invoke_action(name) +end + +function M.StartFindForward() + return invoke("StartFindForward") +end + +function M.StartFindBackward() + return invoke("StartFindBackward") +end + +function M.StartTillForward() + return invoke("StartTillForward") +end + +function M.StartTillBackward() + return invoke("StartTillBackward") +end + +function M.Reset() + return invoke("Reset") +end + +function M.RepeatSameDirection() + return invoke("RepeatSameDirection") +end + +function M.RepeatOppositeDirection() + return invoke("RepeatOppositeDirection") +end + +local function invoke_direct(callback) + local instance = root() + local host = instance:host() + if type(host.invoke_callback) ~= "function" then + fail("clever-tee host must invoke direct action callbacks", 2) + end + return host:invoke_callback(function() + return callback(instance) + end) +end + +function M.invoke_descriptor(value) + return invoke_direct(function(instance) + return instance:invoke_descriptor(value) + end) +end + +function M._diagnostic_full_reset() + return invoke_direct(function(instance) + return instance:diagnostic_full_reset() + end) +end + +M.start_find_forward = M.StartFindForward +M.start_find_backward = M.StartFindBackward +M.start_till_forward = M.StartTillForward +M.start_till_backward = M.StartTillBackward +M.reset = M.Reset +M.repeat_same_direction = M.RepeatSameDirection +M.repeat_opposite_direction = M.RepeatOppositeDirection +M.free_form = M.invoke_descriptor + +return M diff --git a/lua/clever_tee/migemo_catalog.lua b/lua/clever_tee/migemo_catalog.lua new file mode 100644 index 0000000..0a7f87b --- /dev/null +++ b/lua/clever_tee/migemo_catalog.lua @@ -0,0 +1,527 @@ +local domain = require("clever_tee.domain") +local sequence_state = require("clever_tee.sequence_state") +local state_transitions = require("clever_tee.state_transitions") +local text_topology = require("clever_tee.text_topology") + +local M = {} +local MigemoCatalog = {} +local MigemoDictionary = {} +M.MigemoCatalog = MigemoCatalog +M.MigemoDictionary = MigemoDictionary + +local catalog_records = setmetatable({}, { __mode = "k" }) +local dictionary_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function copy_list(values) + local result = {} + for index = 1, #values do + result[index] = values[index] + end + return result +end + +local EXPECTED_KEYS = {} +for code = string.byte("a"), string.byte("z") do + EXPECTED_KEYS[#EXPECTED_KEYS + 1] = string.char(code) +end +for code = string.byte("A"), string.byte("Z") do + EXPECTED_KEYS[#EXPECTED_KEYS + 1] = string.char(code) +end + +local EXPECTED_KEY_SET = {} +for _, key in ipairs(EXPECTED_KEYS) do + EXPECTED_KEY_SET[key] = true +end + +local ASSETS = { + ["utf-8"] = { + file = "utf8.vim", + function_name = "clever_tee#migemo#utf8#load_dict", + }, + cp932 = { + file = "cp932.vim", + function_name = "clever_tee#migemo#cp932#load_dict", + }, + ["euc-jp"] = { + file = "eucjp.vim", + function_name = "clever_tee#migemo#eucjp#load_dict", + }, +} + +local module_source = debug.getinfo(1, "S").source +local module_file = module_source:sub(1, 1) == "@" and module_source:sub(2) or module_source +local bundled_root = module_file:match("^(.*)/lua/clever_tee/migemo_catalog%.lua$") + +local function require_nonempty_string(value, name) + if type(value) ~= "string" or value == "" then + fail((name or "value") .. " must be a nonempty string", 2) + end + return value +end + +local function asset_path(asset) + if bundled_root == nil then + fail("Migemo catalog could not locate its bundled assets", 2) + end + return bundled_root .. "/autoload/clever_tee/migemo/" .. asset.file +end + +local function read_asset_key_order(path) + local handle, open_error = io.open(path, "rb") + if handle == nil then + fail("Migemo asset could not be opened: " .. tostring(open_error), 2) + end + + local keys = {} + for line in handle:lines() do + local key = line:match("^%s*\\%s*'([A-Za-z])'%s*:") + if key ~= nil then + keys[#keys + 1] = key + end + end + handle:close() + return keys +end + +local function assert_key_order(keys, encoding) + if type(keys) ~= "table" or #keys ~= #EXPECTED_KEYS then + fail( + "Migemo " .. encoding .. " asset must contain exactly 52 ordered keys", + 2 + ) + end + for index, expected in ipairs(EXPECTED_KEYS) do + if keys[index] ~= expected then + fail( + "Migemo " .. encoding + .. " asset keys must be ordered a through z, then A through Z", + 2 + ) + end + end +end + +local function nvim_runtime() + local runtime = rawget(_G, "vim") + if type(runtime) ~= "table" + or runtime.cmd == nil + or type(runtime.fn) ~= "table" + or type(runtime.fn.fnameescape) ~= "function" + then + fail("Migemo dictionary loading requires Nvim", 2) + end + return runtime +end + +local function default_asset_loader(encoding, asset) + local runtime = nvim_runtime() + local path = asset_path(asset) + local keys = read_asset_key_order(path) + assert_key_order(keys, encoding) + + runtime.cmd("silent source " .. runtime.fn.fnameescape(path)) + local loader = runtime.fn[asset.function_name] + if type(loader) ~= "function" then + fail("Migemo " .. encoding .. " asset did not define its dictionary loader", 2) + end + local dictionary = loader() + return dictionary, keys, path +end + +local function explicit_pattern(pattern, case_mode) + local case_flag = case_mode == domain.CaseMode.INSENSITIVE and "\\c" or "\\C" + return "\\m" .. case_flag .. "^" .. pattern +end + +local function default_pattern_compiler(pattern, key, encoding) + local runtime = nvim_runtime() + if type(runtime.regex) ~= "function" or type(runtime.fn.match) ~= "function" then + fail("Migemo pattern evaluation requires Nvim regular expressions", 2) + end + + local sensitive = explicit_pattern(pattern, domain.CaseMode.SENSITIVE) + local insensitive = explicit_pattern(pattern, domain.CaseMode.INSENSITIVE) + local ok, compile_error = pcall(runtime.regex, sensitive) + if ok then + ok, compile_error = pcall(runtime.regex, insensitive) + end + if not ok then + fail( + "Migemo " .. encoding .. " pattern for '" .. key + .. "' could not be compiled: " .. tostring(compile_error), + 2 + ) + end + + return function(text, case_mode) + if type(text) ~= "string" then + fail("Migemo assertion text must be a string", 2) + end + case_mode = domain.CaseMode.from_string(case_mode) + local selected = case_mode == domain.CaseMode.INSENSITIVE + and insensitive + or sensitive + local matched, start_or_error = pcall(runtime.fn.match, text, selected) + if not matched then + fail( + "Migemo " .. encoding .. " pattern for '" .. key + .. "' could not be evaluated: " .. tostring(start_or_error), + 2 + ) + end + return start_or_error == 0 + end +end + +local dictionary_metatable = { + __index = function(dictionary, key) + local method = MigemoDictionary[key] + if method ~= nil then + return method + end + + local record = dictionary_records[dictionary] + if key == "encoding" or key == "effective_encoding" then + return record.encoding + end + if key == "entry_count" then + return #record.keys + end + if key == "asset_path" then + return record.asset_path + end + if EXPECTED_KEY_SET[key] then + return record.predicates[key] + end + return nil + end, + __newindex = function() + fail("MigemoDictionary values are immutable", 2) + end, + __tostring = function(dictionary) + return "migemo-dictionary:" .. dictionary_records[dictionary].encoding + end, + __metatable = "clever_tee.migemo_catalog.MigemoDictionary", +} + +local function validate_dictionary_data(data, ordered_keys, encoding) + if type(data) ~= "table" then + fail("Migemo " .. encoding .. " asset must return a dictionary", 3) + end + assert_key_order(ordered_keys, encoding) + + local count = 0 + for key, pattern in pairs(data) do + count = count + 1 + if EXPECTED_KEY_SET[key] ~= true then + fail("Migemo " .. encoding .. " asset contains an unexpected key", 3) + end + if type(pattern) ~= "string" or pattern == "" then + fail("Migemo " .. encoding .. " patterns must be nonempty strings", 3) + end + end + if count ~= #EXPECTED_KEYS then + fail("Migemo " .. encoding .. " asset must contain exactly 52 keys", 3) + end + for _, key in ipairs(EXPECTED_KEYS) do + if data[key] == nil then + fail("Migemo " .. encoding .. " asset is missing key '" .. key .. "'", 3) + end + end +end + +local function new_dictionary(encoding, data, ordered_keys, path, compiler) + validate_dictionary_data(data, ordered_keys, encoding) + + local patterns = {} + local predicates = {} + for _, key in ipairs(EXPECTED_KEYS) do + local pattern = data[key] + patterns[key] = pattern + local predicate = compiler(pattern, key, encoding) + if type(predicate) ~= "function" then + fail("Migemo pattern compiler must return a predicate", 3) + end + predicates[key] = predicate + end + + local dictionary = setmetatable({}, dictionary_metatable) + dictionary_records[dictionary] = { + encoding = encoding, + keys = copy_list(ordered_keys), + patterns = patterns, + predicates = predicates, + asset_path = path, + } + return dictionary +end + +function MigemoDictionary.is(value) + return type(value) == "table" and dictionary_records[value] ~= nil +end + +local function dictionary_record(dictionary) + if not MigemoDictionary.is(dictionary) then + fail("value must be a MigemoDictionary", 3) + end + return dictionary_records[dictionary] +end + +function MigemoDictionary:keys() + return copy_list(dictionary_record(self).keys) +end + +function MigemoDictionary:has(key) + return type(key) == "string" + and dictionary_record(self).predicates[key] ~= nil +end + +function MigemoDictionary:pattern(key) + require_nonempty_string(key, "Migemo dictionary key") + local pattern = dictionary_record(self).patterns[key] + if pattern == nil then + fail("Migemo dictionary key must be one ASCII alphabetic character", 2) + end + return pattern +end + +function MigemoDictionary:predicate(key, case_mode) + require_nonempty_string(key, "Migemo dictionary key") + local predicate = dictionary_record(self).predicates[key] + if predicate == nil then + fail("Migemo dictionary key must be one ASCII alphabetic character", 2) + end + if case_mode == nil then + return predicate + end + + case_mode = domain.CaseMode.from_string(case_mode) + return function(text) + return predicate(text, case_mode) + end +end + +function MigemoDictionary:matches(key, text, case_mode) + return self:predicate(key)(text, case_mode) +end + +function MigemoDictionary:to_table() + local record = dictionary_record(self) + return { + encoding = record.encoding, + entry_count = #record.keys, + keys = copy_list(record.keys), + asset_path = record.asset_path, + } +end + +local function normalize_catalog_options(options) + if options == nil then + return {} + end + if type(options) ~= "table" then + fail("MigemoCatalog options must be a table", 3) + end + if type(options.disable_migemo_for_unsupported_encoding) == "function" + and options.policy == nil + and options.policy_service == nil + and options.transitions == nil + and options.state == nil + and options.asset_loader == nil + and options.pattern_compiler == nil + then + return { policy = options } + end + return options +end + +local function require_policy(service) + if service ~= nil and (type(service) ~= "table" + or type(service.disable_migemo_for_unsupported_encoding) ~= "function") + then + fail( + "MigemoCatalog policy must provide disable_migemo_for_unsupported_encoding", + 3 + ) + end + return service +end + +local function require_transitions(transitions, state) + transitions = transitions or state_transitions.new(state) + if type(transitions) ~= "table" + or type(transitions.CacheMigemo) ~= "function" + or type(transitions.state) ~= "function" + or transitions:state() ~= state + then + fail("MigemoCatalog transitions must mutate its SequenceState", 3) + end + return transitions +end + +local function selected_function(value, fallback, name) + value = value or fallback + if type(value) ~= "function" then + fail("MigemoCatalog " .. name .. " must be a function", 3) + end + return value +end + +local catalog_metatable = { + __index = MigemoCatalog, + __newindex = function() + fail("MigemoCatalog values are immutable", 2) + end, + __tostring = function() + return "migemo-catalog" + end, + __metatable = "clever_tee.migemo_catalog.MigemoCatalog", +} + +function MigemoCatalog.new(options) + if MigemoCatalog.is(options) then + return options + end + options = normalize_catalog_options(options) + local state = options.state or sequence_state.get() + if not sequence_state.is(state) then + fail("MigemoCatalog requires the plugin-global SequenceState", 2) + end + + local catalog = setmetatable({}, catalog_metatable) + catalog_records[catalog] = { + state = state, + transitions = require_transitions(options.transitions, state), + policy = require_policy(options.policy or options.policy_service), + disable_migemo = options.disable_migemo, + asset_loader = selected_function( + options.asset_loader, + default_asset_loader, + "asset_loader" + ), + pattern_compiler = selected_function( + options.pattern_compiler, + default_pattern_compiler, + "pattern_compiler" + ), + load_counts = {}, + } + if catalog_records[catalog].disable_migemo ~= nil + and type(catalog_records[catalog].disable_migemo) ~= "function" + then + fail("MigemoCatalog disable_migemo must be a function", 2) + end + return catalog +end + +function MigemoCatalog.is(value) + return type(value) == "table" and catalog_records[value] ~= nil +end + +function M.new(options) + return MigemoCatalog.new(options) +end + +setmetatable(M, { + __call = function(_, options) + return MigemoCatalog.new(options) + end, +}) + +local function catalog_record(catalog) + if not MigemoCatalog.is(catalog) then + fail("value must be a MigemoCatalog", 3) + end + return catalog_records[catalog] +end + +local function unsupported(catalog, requested_encoding, policy_override) + local record = catalog_record(catalog) + local active_policy = policy_override or record.policy + if active_policy ~= nil then + require_policy(active_policy):disable_migemo_for_unsupported_encoding() + elseif record.disable_migemo ~= nil then + record.disable_migemo() + end + error( + "clever-tee: Encoding '" .. requested_encoding + .. "' is not supported. Migemo is disabled", + 0 + ) +end + +function MigemoCatalog:get(effective_encoding, policy_override) + local requested = require_nonempty_string(effective_encoding, "effective encoding") + local encoding = text_topology.normalize_encoding(requested) + local asset = ASSETS[encoding] + if asset == nil then + return unsupported(self, requested, policy_override) + end + + local record = catalog_record(self) + local cached = record.state:get_migemo(encoding) + if cached ~= nil then + if not MigemoDictionary.is(cached) then + fail("Migemo cache contains an invalid dictionary", 2) + end + return cached + end + + local data, ordered_keys, path = record.asset_loader(encoding, asset) + local dictionary = new_dictionary( + encoding, + data, + ordered_keys, + path, + record.pattern_compiler + ) + record.transitions:CacheMigemo(encoding, dictionary) + record.load_counts[encoding] = (record.load_counts[encoding] or 0) + 1 + return dictionary +end + +function MigemoCatalog:load_count(effective_encoding) + local encoding = text_topology.normalize_encoding(effective_encoding) + return catalog_record(self).load_counts[encoding] or 0 +end + +function MigemoCatalog:cached(effective_encoding) + local encoding = text_topology.normalize_encoding(effective_encoding) + local value = catalog_record(self).state:get_migemo(encoding) + if value ~= nil and not MigemoDictionary.is(value) then + fail("Migemo cache contains an invalid dictionary", 2) + end + return value +end + +MigemoCatalog.load = MigemoCatalog.get +MigemoCatalog.select = MigemoCatalog.get +MigemoCatalog.dictionary = MigemoCatalog.get + +function M.expected_keys() + return copy_list(EXPECTED_KEYS) +end + +function M.supported_encodings() + return { "utf-8", "cp932", "euc-jp" } +end + +function M.bundled_asset_path(effective_encoding) + local encoding = text_topology.normalize_encoding(effective_encoding) + local asset = ASSETS[encoding] + if asset == nil then + return nil + end + return asset_path(asset) +end + +M.load = function(effective_encoding, options) + return MigemoCatalog.new(options):get(effective_encoding) +end +M.EXPECTED_ENTRY_COUNT = #EXPECTED_KEYS + +return M diff --git a/lua/clever_tee/motion_executor.lua b/lua/clever_tee/motion_executor.lua new file mode 100644 index 0000000..4001661 --- /dev/null +++ b/lua/clever_tee/motion_executor.lua @@ -0,0 +1,436 @@ +local destination_engine = require("clever_tee.destination_engine") +local domain = require("clever_tee.domain") +local sequence_state = require("clever_tee.sequence_state") +local state_transitions = require("clever_tee.state_transitions") +local text_topology = require("clever_tee.text_topology") + +local M = {} +local MotionExecutor = {} +M.MotionExecutor = MotionExecutor + +M.ExecutionPath = { + VISUAL = "visual", + COMMAND = "command", +} + +local executor_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +function M.execution_path(context) + context = domain.ModeContext.from_full_mode(context) + if context.visual_kind ~= nil then + return M.ExecutionPath.VISUAL + end + return M.ExecutionPath.COMMAND +end + +function M.moved_forward(origin, destination) + origin = domain.Position.coerce(origin) + destination = domain.Position.coerce(destination) + return domain.Position.compare(destination, origin) > 0 +end + +function M.command_moved_forward(descriptor, origin, destination) + descriptor = domain.Descriptor.from_string(descriptor) + origin = domain.Position.coerce(origin) + destination = domain.Position.coerce(destination) + if descriptor.family == domain.Family.TILL + and domain.Position.stationary(origin, destination) + then + return false + end + return M.moved_forward(origin, destination) +end + +function M.create_dot_payload(plan) + if not domain.ResolvedMotionPlan.is(plan) then + fail("dot payload plan must be a ResolvedMotionPlan", 2) + end + return domain.DotPayload.new(plan.descriptor, plan.target_plan.target) +end + +function M.plan_for_dot_payload(plan, payload) + if not domain.ResolvedMotionPlan.is(plan) then + fail("dot replay plan must be a ResolvedMotionPlan", 2) + end + if not domain.DotPayload.is(payload) then + fail("dot replay payload must be a DotPayload", 2) + end + if payload.target ~= plan.target_plan.target then + fail("dot replay payload target must match its resolved target plan", 2) + end + return domain.ResolvedMotionPlan.new({ + target_plan = plan.target_plan, + descriptor = payload.descriptor, + search_scope = plan.search_scope, + endpoint_policy = plan.endpoint_policy, + }) +end + +local function copy_options(options) + local result = {} + for key, value in pairs(options or {}) do + result[key] = value + end + return result +end + +local function normalize_options(options, dependencies) + if MotionExecutor.is(options) and dependencies == nil then + return options + end + if type(options) ~= "table" then + fail("MotionExecutor options must be a table", 3) + end + if options.host ~= nil then + if dependencies ~= nil then + fail("MotionExecutor dependencies must be part of its options", 3) + end + return options + end + local result = copy_options(dependencies) + result.host = options + return result +end + +local function require_host(host) + if type(host) ~= "table" + or type(host.read_cursor) ~= "function" + or type(host.read_encoding) ~= "function" + or type(host.read_pending_operator) ~= "function" + or type(host.read_selection) ~= "function" + or type(host.read_text) ~= "function" + or type(host.apply_cursor) ~= "function" + or type(host.apply_selection) ~= "function" + or type(host.set_operator_inclusive) ~= "function" + or type(host.register_dot_repeat) ~= "function" + then + fail("MotionExecutor host must provide movement state", 3) + end + return host +end + +local function require_destination_engine(engine) + engine = engine or destination_engine.new() + if type(engine) ~= "table" or type(engine.calculate) ~= "function" then + fail("MotionExecutor destination engine must provide calculate", 3) + end + return engine +end + +local function require_feedback_service(service) + if service ~= nil and (type(service) ~= "table" + or type(service.migrate_command) ~= "function") + then + fail("MotionExecutor feedback service must provide migrate_command", 3) + end + return service +end + +local function require_state(state) + state = state or sequence_state.get() + if not sequence_state.is(state) then + fail("MotionExecutor state must be the plugin-global SequenceState", 3) + end + return state +end + +local function require_transitions(transitions, state) + transitions = transitions or state_transitions.new(state) + if type(transitions) ~= "table" + or type(transitions.CommitCommandSuccess) ~= "function" + or type(transitions.CommitVisualSuccess) ~= "function" + then + fail("MotionExecutor transitions must commit motion success", 3) + end + return transitions +end + +local executor_metatable = { + __index = MotionExecutor, + __newindex = function() + fail("MotionExecutor values are immutable", 2) + end, + __tostring = function() + return "motion-executor" + end, + __metatable = "clever_tee.motion_executor.MotionExecutor", +} + +function MotionExecutor.new(options, dependencies) + options = normalize_options(options, dependencies) + if MotionExecutor.is(options) then + return options + end + + local executor = setmetatable({}, executor_metatable) + local state = require_state(options.state) + executor_records[executor] = { + host = require_host(options.host), + destination_engine = require_destination_engine( + options.destination_engine or options.engine + ), + feedback_service = require_feedback_service( + options.feedback_service or options.feedback + ), + state = state, + transitions = require_transitions( + options.transitions or options.state_transitions, + state + ), + } + return executor +end + +function MotionExecutor.is(value) + return type(value) == "table" and executor_records[value] ~= nil +end + +local function execution_request( + view, + context, + plan, + count, + first_move, + execution_options +) + if not text_topology.TextView.is(view) then + fail("motion execution view must be a TextView", 3) + end + context = domain.ModeContext.from_full_mode(context) + if not domain.ResolvedMotionPlan.is(plan) then + fail("motion execution plan must be a ResolvedMotionPlan", 3) + end + count = domain.Count.new(count) + if type(first_move) ~= "boolean" then + fail("motion execution first_move must be a Boolean", 3) + end + execution_options = execution_options or {} + if type(execution_options) ~= "table" then + fail("motion execution options must be a table", 3) + end + local dot_payload = execution_options.dot_payload + if dot_payload ~= nil and not domain.DotPayload.is(dot_payload) then + fail("motion execution dot_payload must be a DotPayload", 3) + end + local register_dot_repeat = execution_options.register_dot_repeat + if register_dot_repeat == nil then + register_dot_repeat = true + elseif type(register_dot_repeat) ~= "boolean" then + fail("motion execution register_dot_repeat must be a Boolean", 3) + end + return { + view = view, + context = context, + plan = plan, + count = count, + first_move = first_move, + dot_payload = dot_payload, + register_dot_repeat = register_dot_repeat, + } +end + +local function calculate(executor, request, origin) + return executor_records[executor].destination_engine:calculate( + request.view, + origin, + request.plan, + request.count, + request.first_move + ) +end + +local function command_action( + host, + outcome, + descriptor, + dot_payload, + use_current_position +) + return domain.ActionOutcome.new({ + kind = outcome.complete + and domain.ActionKind.MOVEMENT + or domain.ActionKind.FAILED_SEARCH, + position = use_current_position and host:read_cursor() or outcome.endpoint, + search_outcome = outcome, + effective_descriptor = descriptor, + dot_payload = dot_payload, + }) +end + +local function register_dot_replay(executor, request, payload) + local host = executor_records[executor].host + host:register_dot_repeat(payload, function(replayed_payload, replay_count) + return executor:execute_dot( + text_topology.from_host(host), + request.context, + request.plan, + replayed_payload, + replay_count + ) + end) +end + +local function migrate_command_feedback(executor, request, origin, outcome) + local record = executor_records[executor] + local feedback = record.feedback_service + if feedback == nil then + return + end + feedback:migrate_command({ + context = request.context, + origin = origin, + destination = outcome.endpoint, + plan = request.plan, + resolved_motion_plan = request.plan, + outcome = outcome, + count = request.count, + first_move = request.first_move, + moved_forward = request.moved_forward, + previous_moved_forward = record.state.moved_forward, + previous_moved_forward_initialized = record.state.moved_forward_initialized, + }) +end + +function MotionExecutor:_execute_command(request) + local host = executor_records[self].host + local origin = host:read_cursor() + local pending_operator = request.context.operator + and host:read_pending_operator() + or nil + local outcome = calculate(self, request, origin) + if outcome.successful_steps > 0 then + if request.context.operator + and request.plan.descriptor.direction == domain.Direction.FORWARD + then + host:set_operator_inclusive(true) + end + host:apply_cursor(outcome.endpoint, { + context = request.context, + descriptor = request.plan.descriptor, + origin = origin, + }) + end + if not outcome.complete then + return command_action( + host, + outcome, + request.plan.descriptor, + nil, + pending_operator ~= nil and pending_operator ~= "" + ) + end + request.moved_forward = M.command_moved_forward( + request.plan.descriptor, + origin, + outcome.endpoint + ) + migrate_command_feedback(self, request, origin, outcome) + executor_records[self].transitions:CommitCommandSuccess( + request.context, + outcome.endpoint, + request.moved_forward + ) + local dot_payload + if pending_operator ~= nil and pending_operator ~= "" then + dot_payload = request.dot_payload or M.create_dot_payload(request.plan) + if request.register_dot_repeat then + register_dot_replay(self, request, dot_payload) + end + end + return command_action( + host, + outcome, + request.plan.descriptor, + dot_payload, + pending_operator ~= nil and pending_operator ~= "" + ) +end + +function MotionExecutor:_execute_visual(request) + local host = executor_records[self].host + local selection = host:read_selection() + if not domain.Selection.is(selection) + or not selection.active + or selection.kind ~= request.context.visual_kind + then + fail("Visual motion execution requires its active selection kind", 2) + end + local origin = host:read_cursor() + local outcome = calculate(self, request, origin) + request.selection = selection + if outcome.successful_steps > 0 then + host:apply_selection(selection:with_focus(outcome.endpoint)) + end + if not outcome.complete then + return domain.ActionOutcome.from_search(outcome, request.plan.descriptor) + end + executor_records[self].transitions:CommitVisualSuccess( + request.context, + outcome.endpoint + ) + return domain.ActionOutcome.from_search(outcome, request.plan.descriptor) +end + +function MotionExecutor:execute( + view, + context, + plan, + count, + first_move, + execution_options +) + local request = execution_request( + view, + context, + plan, + count, + first_move, + execution_options + ) + if M.execution_path(request.context) == M.ExecutionPath.VISUAL then + return self:_execute_visual(request) + end + return self:_execute_command(request) +end + +function MotionExecutor:execute_dot(view, context, plan, payload, count) + return self:execute( + view, + context, + M.plan_for_dot_payload(plan, payload), + count, + false, + { + dot_payload = payload, + register_dot_repeat = false, + } + ) +end + +function M.new(options, dependencies) + return MotionExecutor.new(options, dependencies) +end + +function M.execute(host, view, context, plan, count, first_move, dependencies) + return MotionExecutor.new(host, dependencies):execute( + view, + context, + plan, + count, + first_move + ) +end + +M.run = M.execute + +setmetatable(M, { + __call = function(_, options, dependencies) + return MotionExecutor.new(options, dependencies) + end, +}) + +return M diff --git a/lua/clever_tee/motion_plan.lua b/lua/clever_tee/motion_plan.lua new file mode 100644 index 0000000..17e06eb --- /dev/null +++ b/lua/clever_tee/motion_plan.lua @@ -0,0 +1,188 @@ +local domain = require("clever_tee.domain") + +local M = {} +local MotionPlanFactory = {} +M.MotionPlanFactory = MotionPlanFactory + +local factory_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function normalize_options(options) + if options == nil then + return {} + end + if type(options) == "table" and type(options.sample_search) == "function" then + return { policy = options } + end + if type(options) ~= "table" then + fail("MotionPlanFactory options must be a table", 3) + end + return options +end + +local function require_policy(service) + if service ~= nil and (type(service) ~= "table" + or type(service.sample_search) ~= "function") + then + fail("MotionPlanFactory policy must provide sample_search", 3) + end + return service +end + +local factory_metatable = { + __index = MotionPlanFactory, + __newindex = function() + fail("MotionPlanFactory values are immutable", 2) + end, + __tostring = function() + return "motion-plan-factory" + end, + __metatable = "clever_tee.motion_plan.MotionPlanFactory", +} + +function MotionPlanFactory.new(options) + if MotionPlanFactory.is(options) then + return options + end + options = normalize_options(options) + local factory = setmetatable({}, factory_metatable) + factory_records[factory] = { + policy = require_policy(options.policy or options.policy_service), + } + return factory +end + +function MotionPlanFactory.is(value) + return type(value) == "table" and factory_records[value] ~= nil +end + +local function resolved_scope(factory, search_scope) + if search_scope == nil then + local policy = factory_records[factory].policy + if policy ~= nil then + search_scope = policy:sample_search().search_scope + else + search_scope = domain.SearchScope.BUFFER + end + elseif search_scope == "line" then + search_scope = domain.SearchScope.CURRENT_LINE + end + return domain.SearchScope.from_string(search_scope) +end + +function MotionPlanFactory:build( + target_plan, + effective_descriptor, + search_scope, + endpoint_policy +) + if not domain.TargetPlan.is(target_plan) then + fail("motion target plan must be a TargetPlan", 2) + end + + return domain.ResolvedMotionPlan.new({ + target_plan = target_plan, + descriptor = effective_descriptor, + search_scope = resolved_scope(self, search_scope), + endpoint_policy = endpoint_policy or domain.EndpointPolicy.REGULAR, + }) +end + +local function selection_option(selection) + if selection == nil then + return domain.SelectionOption.INCLUSIVE + end + if domain.Selection.is(selection) then + return selection.option + end + if domain.SelectionOption.is(selection) then + return selection + end + if type(selection) == "table" and selection.option ~= nil then + return domain.SelectionOption.from_string(selection.option) + end + return domain.SelectionOption.from_string(selection) +end + +function M.endpoint_policy(context, selection) + context = domain.ModeContext.from_full_mode(context) + local option = selection_option(selection) + local visual_kind = context.visual_kind + if option == domain.SelectionOption.EXCLUSIVE + and (visual_kind == domain.SelectionKind.CHARACTER + or visual_kind == domain.SelectionKind.LINE) + then + return domain.EndpointPolicy.VISUAL_EXCLUSIVE + end + return domain.EndpointPolicy.REGULAR +end + +function MotionPlanFactory:endpoint_policy(context, selection) + return M.endpoint_policy(context, selection) +end + +function MotionPlanFactory:build_for_context( + target_plan, + effective_descriptor, + context, + selection, + search_scope +) + return self:build( + target_plan, + effective_descriptor, + search_scope, + self:endpoint_policy(context, selection) + ) +end + +function M.new(options) + return MotionPlanFactory.new(options) +end + +function M.build( + target_plan, + effective_descriptor, + search_scope, + endpoint_policy, + options +) + return MotionPlanFactory.new(options):build( + target_plan, + effective_descriptor, + search_scope, + endpoint_policy + ) +end + +function M.build_for_context( + target_plan, + effective_descriptor, + context, + selection, + search_scope, + options +) + return MotionPlanFactory.new(options):build_for_context( + target_plan, + effective_descriptor, + context, + selection, + search_scope + ) +end + +M.create = M.build +M.resolve = M.build +M.for_context = M.build_for_context + +setmetatable(M, { + __call = function(_, options) + return MotionPlanFactory.new(options) + end, +}) + +return M diff --git a/lua/clever_tee/policy.lua b/lua/clever_tee/policy.lua new file mode 100644 index 0000000..94bf6df --- /dev/null +++ b/lua/clever_tee/policy.lua @@ -0,0 +1,488 @@ +local case_policy = require("clever_tee.case_policy") +local domain = require("clever_tee.domain") + +local M = {} +local PolicyService = {} +PolicyService.__index = PolicyService +M.PolicyService = PolicyService + +M.ValueType = { + BOOLEAN = "boolean", + STRING = "string", + STRING_LIST = "string_list", + OPTIONAL_GROUP_NAME = "optional_group_name", + NONNEGATIVE_INTEGER = "nonnegative_integer", + PRESENCE = "presence", +} + +M.Sampling = { + LIVE = "live", + ACTIVATION = "activation", + LINK_EVALUATION = "link_evaluation", +} + +M.DEFAULT_MAP_SUPPRESSION_SENTINEL = "suppress_default_mappings" + +local NO_VALUE = {} +local SCHEMA = { + search_current_line_only = { + value_type = M.ValueType.BOOLEAN, + default = false, + sampling = M.Sampling.LIVE, + }, + ignore_case = { + value_type = M.ValueType.BOOLEAN, + default = false, + sampling = M.Sampling.LIVE, + }, + smart_case = { + value_type = M.ValueType.BOOLEAN, + default = false, + sampling = M.Sampling.LIVE, + }, + use_migemo = { + value_type = M.ValueType.BOOLEAN, + default = false, + sampling = M.Sampling.LIVE, + }, + fix_key_direction = { + value_type = M.ValueType.BOOLEAN, + default = false, + sampling = M.Sampling.LIVE, + }, + show_prompt = { + value_type = M.ValueType.BOOLEAN, + default = false, + sampling = M.Sampling.LIVE, + }, + chars_match_any_signs = { + value_type = M.ValueType.STRING, + default = "", + sampling = M.Sampling.LIVE, + }, + mark_cursor = { + value_type = M.ValueType.BOOLEAN, + default = true, + sampling = M.Sampling.LIVE, + }, + mark_cursor_color = { + value_type = M.ValueType.OPTIONAL_GROUP_NAME, + default = NO_VALUE, + default_target = "Cursor", + feature_setting = "mark_cursor", + highlight_group = "CleverTeeCursor", + sampling = M.Sampling.LINK_EVALUATION, + }, + hide_cursor_on_cmdline = { + value_type = M.ValueType.BOOLEAN, + default = true, + sampling = M.Sampling.LIVE, + }, + repeat_timeout_ms = { + value_type = M.ValueType.NONNEGATIVE_INTEGER, + default = 0, + sampling = M.Sampling.LIVE, + }, + mark_char = { + value_type = M.ValueType.BOOLEAN, + default = true, + sampling = M.Sampling.LIVE, + }, + mark_char_color = { + value_type = M.ValueType.OPTIONAL_GROUP_NAME, + default = NO_VALUE, + default_target = "CleverTeeDefaultLabel", + feature_setting = "mark_char", + highlight_group = "CleverTeeChar", + sampling = M.Sampling.LINK_EVALUATION, + }, + highlight_timeout_ms = { + value_type = M.ValueType.NONNEGATIVE_INTEGER, + default = 0, + sampling = M.Sampling.LIVE, + }, + repeat_last_char_inputs = { + value_type = M.ValueType.STRING_LIST, + default = { "\r" }, + sampling = M.Sampling.LIVE, + }, + mark_direct = { + value_type = M.ValueType.BOOLEAN, + default = false, + sampling = M.Sampling.LIVE, + }, + mark_direct_color = { + value_type = M.ValueType.OPTIONAL_GROUP_NAME, + default = NO_VALUE, + default_target = "CleverTeeDefaultLabel", + feature_setting = "mark_direct", + highlight_group = "CleverTeeDirect", + sampling = M.Sampling.LINK_EVALUATION, + }, + clean_labels_eagerly = { + value_type = M.ValueType.BOOLEAN, + default = true, + sampling = M.Sampling.ACTIVATION, + }, + [M.DEFAULT_MAP_SUPPRESSION_SENTINEL] = { + value_type = M.ValueType.PRESENCE, + default = false, + sampling = M.Sampling.ACTIVATION, + }, +} + +local COLOR_SETTINGS = { + "mark_cursor_color", + "mark_char_color", + "mark_direct_color", +} + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function is_integer(value) + return type(value) == "number" + and value > -math.huge + and value < math.huge + and value == math.floor(value) +end + +local function copy_list(values) + local result = {} + for index = 1, #values do + result[index] = values[index] + end + return result +end + +local function copy_table(value) + local result = {} + for key, item in pairs(value) do + if type(item) == "table" and domain.type_of(item) == nil then + result[key] = copy_table(item) + else + result[key] = item + end + end + return result +end + +local function schema_entry(name) + local entry = SCHEMA[name] + if entry == nil then + fail("unknown policy setting '" .. tostring(name) .. "'", 2) + end + return entry +end + +local function default_value(entry) + if entry.default == NO_VALUE then + return nil + end + if type(entry.default) == "table" then + return copy_table(entry.default) + end + return entry.default +end + +local function validate_boolean(value, name) + if type(value) ~= "boolean" then + fail("policy setting '" .. name .. "' must be a Boolean", 3) + end + return value +end + +local function validate_string(value, name) + if type(value) ~= "string" then + fail("policy setting '" .. name .. "' must be a string", 3) + end + return value +end + +local function validate_string_list(value, name) + if type(value) ~= "table" then + fail("policy setting '" .. name .. "' must be a list of strings", 3) + end + + local length = #value + local item_count = 0 + for key, item in pairs(value) do + if not is_integer(key) or key < 1 or key > length then + fail("policy setting '" .. name .. "' must be a list of strings", 3) + end + if type(item) ~= "string" then + fail("policy setting '" .. name .. "' must be a list of strings", 3) + end + item_count = item_count + 1 + end + if item_count ~= length then + fail("policy setting '" .. name .. "' must be a list of strings", 3) + end + return copy_list(value) +end + +local function validate_optional_group_name(value, name) + if value ~= nil and (type(value) ~= "string" or value == "") then + fail("policy setting '" .. name .. "' must be an optional group name", 3) + end + return value +end + +local function validate_nonnegative_integer(value, name) + if not is_integer(value) or value < 0 then + fail("policy setting '" .. name .. "' must be a nonnegative integer", 3) + end + return value +end + +local VALIDATORS = { + [M.ValueType.BOOLEAN] = validate_boolean, + [M.ValueType.STRING] = validate_string, + [M.ValueType.STRING_LIST] = validate_string_list, + [M.ValueType.OPTIONAL_GROUP_NAME] = validate_optional_group_name, + [M.ValueType.NONNEGATIVE_INTEGER] = validate_nonnegative_integer, +} + +local function require_provider(provider) + if type(provider) ~= "table" then + fail("policy configuration provider must be a table", 2) + end + local required = { + "configuration_present", + "read_configuration", + "write_configuration", + } + for _, method_name in ipairs(required) do + if type(provider[method_name]) ~= "function" then + fail("policy configuration provider is missing " .. method_name, 2) + end + end + return provider +end + +function M.setting_names() + local names = {} + for name in pairs(SCHEMA) do + names[#names + 1] = name + end + table.sort(names) + return names +end + +function M.schema() + local result = {} + for name, entry in pairs(SCHEMA) do + local public_entry = { + value_type = entry.value_type, + sampling = entry.sampling, + has_default = true, + } + local value = default_value(entry) + if value ~= nil then + public_entry.default = value + end + if entry.default_target ~= nil then + public_entry.default_target = entry.default_target + public_entry.feature_setting = entry.feature_setting + public_entry.highlight_group = entry.highlight_group + end + result[name] = public_entry + end + return result +end + +function M.default(name) + return default_value(schema_entry(name)) +end + +function M.defaults() + local result = {} + for name, entry in pairs(SCHEMA) do + local value = default_value(entry) + if value ~= nil then + result[name] = value + end + end + return result +end + +function PolicyService.new(provider) + return setmetatable({ + _provider = require_provider(provider), + _activation = nil, + }, PolicyService) +end + +function M.new(provider) + return PolicyService.new(provider) +end + +setmetatable(M, { + __call = function(_, provider) + return PolicyService.new(provider) + end, +}) + +function PolicyService:get(name) + local entry = schema_entry(name) + if entry.value_type == M.ValueType.PRESENCE then + return self._provider:configuration_present(name) + end + + local value + if self._provider:configuration_present(name) then + value = self._provider:read_configuration(name) + else + value = default_value(entry) + end + return VALIDATORS[entry.value_type](value, name) +end + +function PolicyService:_get_typed(name, expected_type) + local entry = schema_entry(name) + if entry.value_type ~= expected_type then + fail( + "policy setting '" .. name .. "' does not have type " .. expected_type, + 2 + ) + end + return self:get(name) +end + +function PolicyService:get_boolean(name) + return self:_get_typed(name, M.ValueType.BOOLEAN) +end + +function PolicyService:get_string(name) + return self:_get_typed(name, M.ValueType.STRING) +end + +function PolicyService:get_string_list(name) + return self:_get_typed(name, M.ValueType.STRING_LIST) +end + +function PolicyService:get_optional_group_name(name) + return self:_get_typed(name, M.ValueType.OPTIONAL_GROUP_NAME) +end + +function PolicyService:get_nonnegative_integer(name) + return self:_get_typed(name, M.ValueType.NONNEGATIVE_INTEGER) +end + +function PolicyService:get_presence(name) + return self:_get_typed(name, M.ValueType.PRESENCE) +end + +function PolicyService:default_maps_suppressed() + return self:get_presence(M.DEFAULT_MAP_SUPPRESSION_SENTINEL) +end + +function PolicyService:capture_activation() + if self._activation == nil then + self._activation = { + install_default_mappings = not self:default_maps_suppressed(), + clean_labels_eagerly = self:get_boolean("clean_labels_eagerly"), + } + end + return copy_table(self._activation) +end + +function PolicyService:evaluate_highlight_links() + local result = {} + for _, color_setting in ipairs(COLOR_SETTINGS) do + local entry = SCHEMA[color_setting] + local configured_target = self:get_optional_group_name(color_setting) + result[entry.highlight_group] = { + enabled = self:get_boolean(entry.feature_setting), + feature_setting = entry.feature_setting, + color_setting = color_setting, + configured_target = configured_target, + target = configured_target or entry.default_target, + } + end + return result +end + +function M.resolve_case_mode(target, ignore_case, smart_case) + return case_policy.resolve_case_mode(target, ignore_case, smart_case) +end + +function PolicyService:case_mode(target) + return M.resolve_case_mode( + target, + self:get_boolean("ignore_case"), + self:get_boolean("smart_case") + ) +end + +function PolicyService:sample_search() + local current_line_only = self:get_boolean("search_current_line_only") + return { + search_current_line_only = current_line_only, + search_scope = current_line_only + and domain.SearchScope.CURRENT_LINE + or domain.SearchScope.BUFFER, + } +end + +function PolicyService:sample_match(target) + local ignore_case = self:get_boolean("ignore_case") + local smart_case = self:get_boolean("smart_case") + return { + ignore_case = ignore_case, + smart_case = smart_case, + use_migemo = self:get_boolean("use_migemo"), + chars_match_any_signs = self:get_string("chars_match_any_signs"), + case_mode = M.resolve_case_mode(target, ignore_case, smart_case), + } +end + +function PolicyService:sample_direction() + return { + fix_key_direction = self:get_boolean("fix_key_direction"), + } +end + +function PolicyService:sample_acquisition() + return { + show_prompt = self:get_boolean("show_prompt"), + mark_cursor = self:get_boolean("mark_cursor"), + hide_cursor_on_cmdline = self:get_boolean("hide_cursor_on_cmdline"), + mark_direct = self:get_boolean("mark_direct"), + } +end + +function PolicyService:sample_direct_preview() + return { + ignore_case = self:get_boolean("ignore_case"), + smart_case = self:get_boolean("smart_case"), + } +end + +function PolicyService:sample_markers() + return { + mark_cursor = self:get_boolean("mark_cursor"), + mark_char = self:get_boolean("mark_char"), + mark_direct = self:get_boolean("mark_direct"), + } +end + +function PolicyService:sample_timeouts() + return { + repeat_timeout_ms = self:get_nonnegative_integer("repeat_timeout_ms"), + highlight_timeout_ms = self:get_nonnegative_integer("highlight_timeout_ms"), + } +end + +function PolicyService:sample_previous_input() + return { + repeat_last_char_inputs = self:get_string_list("repeat_last_char_inputs"), + } +end + +function PolicyService:disable_migemo_for_unsupported_encoding() + self._provider:write_configuration("use_migemo", false) +end + +return M diff --git a/lua/clever_tee/repeat_resolver.lua b/lua/clever_tee/repeat_resolver.lua new file mode 100644 index 0000000..67d6617 --- /dev/null +++ b/lua/clever_tee/repeat_resolver.lua @@ -0,0 +1,333 @@ +local domain = require("clever_tee.domain") +local sequence_state = require("clever_tee.sequence_state") +local state_transitions = require("clever_tee.state_transitions") + +local M = {} +local RepeatResolver = {} +M.RepeatResolver = RepeatResolver + +M.Decision = { + ACQUIRE = "acquire", + REPEAT = "repeat", +} +M.ACQUIRE = M.Decision.ACQUIRE +M.REPEAT = M.Decision.REPEAT + +local resolver_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function is_nonnegative_integer(value) + return type(value) == "number" + and value >= 0 + and value < math.huge + and value == math.floor(value) +end + +local function require_policy(service) + if service ~= nil and (type(service) ~= "table" + or type(service.sample_timeouts) ~= "function" + or type(service.sample_direction) ~= "function") + then + fail("RepeatResolver policy must sample timeouts and direction", 3) + end + return service +end + +local function require_clock(clock) + if clock ~= nil and (type(clock) ~= "table" + or type(clock.read_time_ms) ~= "function") + then + fail("RepeatResolver clock must provide read_time_ms", 3) + end + return clock +end + +local function require_transitions(transitions, state) + transitions = transitions or state_transitions.new(state) + if type(transitions) ~= "table" + or type(transitions.SetRepeatTimestamp) ~= "function" + or type(transitions.PublicReset) ~= "function" + then + fail("RepeatResolver transitions must set repeat time and apply Public Reset", 3) + end + return transitions +end + +local function finite_time(value) + return type(value) == "number" + and value == value + and value > -math.huge + and value < math.huge +end + +function M.truncate_elapsed_ms(elapsed_ms) + if not finite_time(elapsed_ms) then + fail("elapsed milliseconds must be finite", 2) + end + local integer_part = math.modf(elapsed_ms) + return integer_part +end + +M.truncate_milliseconds = M.truncate_elapsed_ms + +local resolver_metatable = { + __index = RepeatResolver, + __newindex = function() + fail("RepeatResolver values are immutable", 2) + end, + __tostring = function() + return "repeat-resolver" + end, + __metatable = "clever_tee.repeat_resolver.RepeatResolver", +} + +function RepeatResolver.new(options) + if RepeatResolver.is(options) then + return options + end + if options == nil then + options = {} + elseif sequence_state.is(options) then + options = { state = options } + elseif type(options) ~= "table" then + fail("RepeatResolver options must be a table", 2) + end + + local state = options.state or sequence_state.get() + if not sequence_state.is(state) then + fail("RepeatResolver state must be the plugin-global SequenceState", 2) + end + + local resolver = setmetatable({}, resolver_metatable) + resolver_records[resolver] = { + clock = require_clock(options.clock or options.time_provider or options.host), + policy = require_policy(options.policy or options.policy_service), + state = state, + transitions = require_transitions( + options.transitions or options.state_transitions, + state + ), + } + return resolver +end + +function RepeatResolver.is(value) + return type(value) == "table" and resolver_records[value] ~= nil +end + +function RepeatResolver:previous_landing(context) + context = domain.ModeContext.from_full_mode(context) + return resolver_records[self].state:get_previous_landing(context) +end + +function RepeatResolver:decide(context, current_position, macro_state) + current_position = domain.Position.coerce(current_position) + local landing = self:previous_landing(context) + if landing == nil or not domain.Position.equal(landing, current_position) then + return M.Decision.ACQUIRE + end + if domain.MacroState.new(macro_state).executing then + return M.Decision.ACQUIRE + end + return M.Decision.REPEAT +end + +RepeatResolver.eligibility = RepeatResolver.decide +RepeatResolver.resolve_eligibility = RepeatResolver.decide + +function RepeatResolver:sample_repeat_timeout_ms() + local service = resolver_records[self].policy + if service == nil then + fail("RepeatResolver requires a policy to sample repeat timeout", 2) + end + local sampled = service:sample_timeouts() + local timeout = type(sampled) == "table" and sampled.repeat_timeout_ms or nil + if not is_nonnegative_integer(timeout) then + fail("repeat_timeout_ms sample must be a nonnegative integer", 2) + end + return timeout +end + +RepeatResolver.sample_repeat_timeout = RepeatResolver.sample_repeat_timeout_ms + +function RepeatResolver:evaluate_timeout(current_window) + local timeout = self:sample_repeat_timeout_ms() + if timeout == 0 then + return M.Decision.REPEAT, nil + end + + local clock = resolver_records[self].clock + if clock == nil then + fail("RepeatResolver requires a clock for positive repeat timeout", 2) + end + local current_time = clock:read_time_ms() + if not finite_time(current_time) then + fail("repeat clock must return finite milliseconds", 2) + end + local record = resolver_records[self] + local elapsed_ms = M.truncate_elapsed_ms( + current_time - record.state.repeat_timestamp_ms + ) + record.transitions:SetRepeatTimestamp(current_time) + if elapsed_ms <= timeout then + return M.Decision.REPEAT, elapsed_ms + end + local cleanup = record.transitions:PublicReset(current_window) + return M.Decision.ACQUIRE, elapsed_ms, cleanup +end + +RepeatResolver.check_timeout = RepeatResolver.evaluate_timeout +RepeatResolver.resolve_timeout = RepeatResolver.evaluate_timeout + +local function sampled_fixed_direction(resolver) + local service = resolver_records[resolver].policy + if service == nil then + fail("RepeatResolver requires a policy to resolve primary direction", 3) + end + local sampled = service:sample_direction() + local fixed + if type(sampled) == "table" then + fixed = sampled.fix_key_direction + end + if type(fixed) ~= "boolean" then + fail("fix_key_direction sample must be a Boolean", 3) + end + return fixed +end + +function M.reverse_request(stored_descriptor, pressed_key, fix_key_direction) + local stored = domain.Descriptor.from_string(stored_descriptor) + local pressed = domain.Descriptor.from_string(pressed_key) + if type(fix_key_direction) ~= "boolean" then + fail("fix_key_direction must be a Boolean", 2) + end + + local reverse = domain.Descriptor.is_uppercase(pressed) + if fix_key_direction and domain.Descriptor.is_uppercase(stored) then + reverse = not reverse + end + return reverse +end + +function M.primary_direction(stored_descriptor, pressed_key, fix_key_direction) + local stored = domain.Descriptor.from_string(stored_descriptor) + if M.reverse_request(stored, pressed_key, fix_key_direction) then + return domain.Descriptor.swap(stored) + end + return stored +end + +M.resolve_primary_direction = M.primary_direction +M.effective_primary_descriptor = M.primary_direction + +function RepeatResolver:resolve_primary_direction(stored_descriptor, pressed_key) + return M.primary_direction( + stored_descriptor, + pressed_key, + sampled_fixed_direction(self) + ) +end + +RepeatResolver.primary_direction = RepeatResolver.resolve_primary_direction +RepeatResolver.effective_primary_descriptor = + RepeatResolver.resolve_primary_direction + +function M.explicit_target(stored_target) + if stored_target == nil then + return domain.TargetValue.code_fallback(0) + end + return stored_target +end + +local function build_explicit_request(descriptor, stored_target) + if descriptor == nil then + return domain.ExplicitRepeatRequest.neutral() + end + local target = M.explicit_target(stored_target) + if target.first_code == 0x80 then + return domain.ExplicitRepeatRequest.neutral() + end + return domain.ExplicitRepeatRequest.new(descriptor, target) +end + +function M.build_same_direction_request(stored_descriptor, stored_target) + return build_explicit_request(stored_descriptor, stored_target) +end + +M.explicit_same_direction = M.build_same_direction_request +M.same_direction_request = M.build_same_direction_request + +function RepeatResolver:same_direction_request(context) + context = domain.ModeContext.from_full_mode(context) + local state = resolver_records[self].state + return M.build_same_direction_request( + state:get_previous_descriptor(context), + state:get_previous_target(context) + ) +end + +RepeatResolver.resolve_explicit_same = RepeatResolver.same_direction_request +RepeatResolver.explicit_same = RepeatResolver.same_direction_request + +function M.build_opposite_direction_request(stored_descriptor, stored_target) + if stored_descriptor == nil then + return domain.ExplicitRepeatRequest.neutral() + end + return build_explicit_request( + domain.Descriptor.swap(stored_descriptor), + stored_target + ) +end + +M.explicit_opposite_direction = M.build_opposite_direction_request +M.opposite_direction_request = M.build_opposite_direction_request + +function RepeatResolver:opposite_direction_request(context) + context = domain.ModeContext.from_full_mode(context) + local state = resolver_records[self].state + return M.build_opposite_direction_request( + state:get_previous_descriptor(context), + state:get_previous_target(context) + ) +end + +RepeatResolver.resolve_explicit_opposite = + RepeatResolver.opposite_direction_request +RepeatResolver.explicit_opposite = RepeatResolver.opposite_direction_request + +function M.new(options) + return RepeatResolver.new(options) +end + +M.landing = function(context, options) + return RepeatResolver.new(options):previous_landing(context) +end + +function M.decide(context, current_position, macro_state, options) + return RepeatResolver.new(options):decide( + context, + current_position, + macro_state + ) +end + +M.eligibility = M.decide + +function M.sample_repeat_timeout_ms(options) + return RepeatResolver.new(options):sample_repeat_timeout_ms() +end + +function M.evaluate_timeout(options, current_window) + return RepeatResolver.new(options):evaluate_timeout(current_window) +end + +setmetatable(M, { + __call = function(_, options) + return RepeatResolver.new(options) + end, +}) + +return M diff --git a/lua/clever_tee/sequence_coordinator.lua b/lua/clever_tee/sequence_coordinator.lua new file mode 100644 index 0000000..1437d6c --- /dev/null +++ b/lua/clever_tee/sequence_coordinator.lua @@ -0,0 +1,675 @@ +local acquisition_service_factory = require("clever_tee.acquisition_service") +local case_policy = require("clever_tee.case_policy") +local direct_preview_planner = require("clever_tee.direct_preview_planner") +local domain = require("clever_tee.domain") +local feedback_service_factory = require("clever_tee.feedback_service") +local motion_executor_factory = require("clever_tee.motion_executor") +local motion_plan_factory = require("clever_tee.motion_plan") +local policy = require("clever_tee.policy") +local repeat_resolver_factory = require("clever_tee.repeat_resolver") +local sequence_state = require("clever_tee.sequence_state") +local state_transitions = require("clever_tee.state_transitions") +local target_plan_factory = require("clever_tee.target_plan") +local text_topology = require("clever_tee.text_topology") + +local M = {} +local SequenceCoordinator = {} +SequenceCoordinator.__index = SequenceCoordinator +M.SequenceCoordinator = SequenceCoordinator + +local coordinator_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function descriptor_text(value) + if domain.Descriptor.is(value) then + return value.value + end + return tostring(value) +end + +function M.validate_primary_descriptor(value) + local descriptor = domain.Descriptor.try_from_string(value) + if descriptor == nil then + error("clever-tee: Invalid mapping '" .. descriptor_text(value) .. "'", 0) + end + return descriptor +end + +function SequenceCoordinator.new(options) + if SequenceCoordinator.is(options) then + return options + end + if type(options) ~= "table" then + fail("SequenceCoordinator options must be a table", 2) + end + local host = options.host or options + local state = options.state or sequence_state.get() + if not sequence_state.is(state) then + fail("SequenceCoordinator state must be the plugin-global SequenceState", 2) + end + local transitions = options.transitions + or options.state_transitions + or state_transitions.new(state) + local policy_service = options.policy + or options.policy_service + or policy.new(host) + local resolver = options.repeat_resolver + or options.resolver + or repeat_resolver_factory.new({ + state = state, + transitions = transitions, + policy = policy_service, + clock = host, + }) + if type(resolver) ~= "table" or type(resolver.decide) ~= "function" then + fail("SequenceCoordinator repeat resolver must provide decide", 2) + end + local feedback = options.feedback + or options.feedback_service + or feedback_service_factory.new({ + host = host, + state = state, + transitions = transitions, + policy = policy_service, + }) + local lowercase = options.lowercase + if lowercase == nil and type(host.lowercase) == "function" then + lowercase = function(value) + return host:lowercase(value) + end + end + local case_resolver = options.case_resolver + or case_policy.new({ lowercase = lowercase }) + local target_factory = options.target_factory + or options.target_plan_factory + or target_plan_factory.new({ + policy = policy_service, + case_resolver = case_resolver, + }) + if type(target_factory) ~= "table" or type(target_factory.build) ~= "function" then + fail("SequenceCoordinator target factory must provide build", 2) + end + local motion_factory = options.motion_factory + or options.motion_plan_factory + or motion_plan_factory.new({ policy = policy_service }) + if type(motion_factory) ~= "table" + or type(motion_factory.build_for_context) ~= "function" + then + fail("SequenceCoordinator motion factory must build contextual plans", 2) + end + local direct_planner = options.direct_planner + or options.direct_preview_planner + or direct_preview_planner.new({ case_resolver = case_resolver }) + local acquisition = options.acquisition + or options.acquisition_service + or acquisition_service_factory.new({ + host = host, + state = state, + transitions = transitions, + policy = policy_service, + feedback = feedback, + direct_planner = direct_planner, + target_factory = target_factory, + motion_factory = motion_factory, + }) + if type(acquisition) ~= "table" or type(acquisition.acquire) ~= "function" then + fail("SequenceCoordinator acquisition service must provide acquire", 2) + end + local executor = options.motion_executor + or options.executor + or motion_executor_factory.new({ + host = host, + state = state, + transitions = transitions, + feedback = feedback, + }) + if type(executor) ~= "table" or type(executor.execute) ~= "function" then + fail("SequenceCoordinator motion executor must provide execute", 2) + end + + local coordinator = setmetatable({}, SequenceCoordinator) + coordinator_records[coordinator] = { + host = host, + state = state, + transitions = transitions, + policy = policy_service, + repeat_resolver = resolver, + feedback = feedback, + target_factory = target_factory, + motion_factory = motion_factory, + acquisition = acquisition, + motion_executor = executor, + last_primary_resolution = nil, + last_explicit_resolution = nil, + } + return coordinator +end + +function SequenceCoordinator.is(value) + return type(value) == "table" and coordinator_records[value] ~= nil +end + +function SequenceCoordinator:validate_primary_descriptor(value) + return M.validate_primary_descriptor(value) +end + +local function require_primary_reader(host) + if type(host) ~= "table" + or type(host.read_mode) ~= "function" + or type(host.read_cursor) ~= "function" + or type(host.read_count) ~= "function" + or type(host.read_macro_state) ~= "function" + then + fail("SequenceCoordinator host must provide primary action state", 3) + end + return host +end + +function SequenceCoordinator:read_primary_invocation() + local host = require_primary_reader(coordinator_records[self].host) + local context = domain.ModeContext.from_full_mode(host:read_mode()) + local position = domain.Position.coerce(host:read_cursor()) + local count = domain.Count.new(host:read_count()) + local macro_state = domain.MacroState.new(host:read_macro_state()) + return { + context = context, + position = position, + origin = position, + count = count, + macro_state = macro_state, + } +end + +function SequenceCoordinator:inspect_fold_open_policy(invocation) + if type(invocation) ~= "table" or not domain.Position.is(invocation.position) then + fail("fold preflight requires primary invocation state", 2) + end + local host = coordinator_records[self].host + if type(host.read_fold_state) ~= "function" then + fail("SequenceCoordinator host must provide fold state", 2) + end + local fold_state = host:read_fold_state() + if not domain.FoldState.is(fold_state) then + fail("SequenceCoordinator host must return FoldState", 2) + end + return fold_state +end + +local function fold_open_enabled(fold_state) + return fold_state:opens("horizontal") or fold_state:opens("all") +end + +function SequenceCoordinator:open_enclosing_folds(invocation, fold_state) + if type(invocation) ~= "table" or not domain.Position.is(invocation.position) then + fail("fold opening requires primary invocation state", 2) + end + if not domain.FoldState.is(fold_state) then + fail("fold opening requires FoldState", 2) + end + if not fold_open_enabled(fold_state) then + return 0 + end + + local host = coordinator_records[self].host + if type(host.open_fold) ~= "function" then + fail("SequenceCoordinator host must open folds", 2) + end + local opened = 0 + while fold_state.closed_levels > 0 do + if host:open_fold(invocation.position) ~= true then + break + end + opened = opened + 1 + fold_state = self:inspect_fold_open_policy(invocation) + end + return opened +end + +function SequenceCoordinator:decide_primary(invocation) + if type(invocation) ~= "table" + or not domain.ModeContext.is(invocation.context) + or not domain.Position.is(invocation.position) + or not domain.MacroState.is(invocation.macro_state) + then + fail("primary decision requires invocation state", 2) + end + return coordinator_records[self].repeat_resolver:decide( + invocation.context, + invocation.position, + invocation.macro_state + ) +end + +function SequenceCoordinator:acquire_primary(descriptor, invocation) + descriptor = self:validate_primary_descriptor(descriptor) + if type(invocation) ~= "table" then + fail("primary acquisition requires invocation state", 2) + end + return coordinator_records[self].acquisition:acquire( + descriptor, + invocation.context, + invocation.position, + invocation.count, + invocation.macro_state + ) +end + +function SequenceCoordinator:fresh_primary_resolution( + initiating_descriptor, + acquisition_result, + invocation +) + initiating_descriptor = self:validate_primary_descriptor(initiating_descriptor) + if type(acquisition_result) ~= "table" + or acquisition_result.resolved ~= true + or not domain.TargetValue.is(acquisition_result.target) + or not domain.TargetPlan.is(acquisition_result.target_plan) + or not domain.ResolvedMotionPlan.is(acquisition_result.motion_plan) + then + fail("fresh primary resolution requires acquired motion plans", 2) + end + return { + kind = "fresh", + invocation = invocation, + acquisition_result = acquisition_result, + target = acquisition_result.target, + target_plan = acquisition_result.target_plan, + motion_plan = acquisition_result.motion_plan, + effective_descriptor = initiating_descriptor, + first_move = coordinator_records[self].state:get_first_move( + invocation.context + ) == true, + skip_destination = acquisition_result.target_plan.kind + == domain.TargetPlanKind.EMPTY, + } +end + +function SequenceCoordinator:resolve_acquisition(descriptor, invocation) + local result = self:acquire_primary(descriptor, invocation) + if type(result.has_outcome) ~= "function" then + fail("AcquisitionService must return an AcquisitionResult", 2) + end + if result:has_outcome() then + return result.outcome + end + return self:fresh_primary_resolution(descriptor, result, invocation) +end + +function SequenceCoordinator:evaluate_repeat_timeout(invocation) + if type(invocation) ~= "table" then + fail("repeat timeout requires primary invocation state", 2) + end + local record = coordinator_records[self] + if type(record.repeat_resolver.evaluate_timeout) ~= "function" then + fail("SequenceCoordinator repeat resolver must evaluate timeout", 2) + end + local window = record.host:read_window() + local decision, elapsed_ms, cleanup = + record.repeat_resolver:evaluate_timeout(window) + return { + decision = decision, + elapsed_ms = elapsed_ms, + cleanup = cleanup, + window = window, + } +end + +function SequenceCoordinator:build_live_target_plan(target, invocation) + if not domain.TargetValue.is(target) then + fail("primary target planning requires a TargetValue", 2) + end + if type(invocation) ~= "table" or not domain.Position.is(invocation.position) then + fail("primary target planning requires invocation state", 2) + end + local record = coordinator_records[self] + local view = text_topology.from_host(record.host) + local sampled_search = record.policy:sample_search() + local target_plan = record.target_factory:build(target, nil, { + text_view = view, + origin = invocation.position, + search_scope = sampled_search.search_scope, + effective_encoding = view.effective_encoding, + }) + if not domain.TargetPlan.is(target_plan) then + fail("TargetPlanFactory must return a TargetPlan", 2) + end + return target_plan, view, sampled_search.search_scope +end + +function SequenceCoordinator:build_movement_plan( + target_plan, + effective_descriptor, + invocation, + search_scope +) + if not domain.TargetPlan.is(target_plan) then + fail("movement planning requires a TargetPlan", 2) + end + if type(invocation) ~= "table" or not domain.ModeContext.is(invocation.context) then + fail("movement planning requires invocation state", 2) + end + local record = coordinator_records[self] + local selection = invocation.context.visual and record.host:read_selection() or nil + local motion_plan = record.motion_factory:build_for_context( + target_plan, + effective_descriptor, + invocation.context, + selection, + search_scope + ) + if not domain.ResolvedMotionPlan.is(motion_plan) then + fail("MotionPlanFactory must return a ResolvedMotionPlan", 2) + end + return motion_plan +end + +function SequenceCoordinator:restore_repeated_feedback(resolution) + if type(resolution) ~= "table" + or not domain.TargetPlan.is(resolution.target_plan) + or not domain.ResolvedMotionPlan.is(resolution.motion_plan) + then + fail("feedback restoration requires a repeated primary resolution", 2) + end + local feedback = coordinator_records[self].feedback + if type(feedback.restore_primary) ~= "function" then + fail("FeedbackService must restore primary feedback", 2) + end + return feedback:restore_primary({ + context = resolution.invocation.context, + anchor = resolution.invocation.position, + target_plan = resolution.target_plan, + motion_plan = resolution.motion_plan, + stored_descriptor = resolution.stored_descriptor, + endpoint_policy = resolution.motion_plan.endpoint_policy, + text_view = resolution.text_view, + window = resolution.timeout.window, + }) +end + +function SequenceCoordinator:stored_primary_resolution( + invocation, + pressed_descriptor, + timeout +) + if type(invocation) ~= "table" or not domain.ModeContext.is(invocation.context) then + fail("stored primary resolution requires invocation state", 2) + end + pressed_descriptor = self:validate_primary_descriptor(pressed_descriptor) + local state = coordinator_records[self].state + local stored_descriptor = state:get_previous_descriptor(invocation.context) + local stored_target = state:get_previous_target(invocation.context) + if stored_descriptor == nil or stored_target == nil then + fail("repeat-eligible primary state must contain descriptor and target", 2) + end + local resolver = coordinator_records[self].repeat_resolver + if type(resolver.resolve_primary_direction) ~= "function" then + fail("SequenceCoordinator repeat resolver must resolve primary direction", 2) + end + local effective_descriptor = domain.Descriptor.from_string( + resolver:resolve_primary_direction(stored_descriptor, pressed_descriptor) + ) + if effective_descriptor.family ~= stored_descriptor.family then + fail("primary repetition must preserve the stored motion family", 2) + end + local target_plan, text_view, search_scope = self:build_live_target_plan( + stored_target, + invocation + ) + local motion_plan = self:build_movement_plan( + target_plan, + effective_descriptor, + invocation, + search_scope + ) + local resolution = { + kind = "repeat", + invocation = invocation, + pressed_descriptor = pressed_descriptor, + timeout = timeout, + stored_descriptor = stored_descriptor, + target = stored_target, + target_plan = target_plan, + motion_plan = motion_plan, + text_view = text_view, + search_scope = search_scope, + effective_descriptor = effective_descriptor, + first_move = state:get_first_move(invocation.context) == true, + } + resolution.restored_feedback = self:restore_repeated_feedback(resolution) + return resolution +end + +function SequenceCoordinator:refresh_primary_feedback(resolution) + if type(resolution) ~= "table" or not domain.TargetValue.is(resolution.target) then + fail("primary feedback refresh requires a resolved target", 2) + end + local record = coordinator_records[self] + if type(record.feedback.refresh_primary) ~= "function" then + fail("FeedbackService must refresh primary feedback", 2) + end + local window = resolution.timeout and resolution.timeout.window + or record.host:read_window() + return record.feedback:refresh_primary(resolution.target, window) +end + +function SequenceCoordinator:execute_resolved_motion(resolution, execution_options) + if type(resolution) ~= "table" + or not domain.ModeContext.is(resolution.invocation.context) + or not domain.ResolvedMotionPlan.is(resolution.motion_plan) + then + fail("motion execution requires a resolved motion", 2) + end + if resolution.skip_destination then + return domain.ActionOutcome.empty(resolution.invocation.position) + end + local record = coordinator_records[self] + local view = resolution.text_view or text_topology.from_host(record.host) + local outcome = record.motion_executor:execute( + view, + resolution.invocation.context, + resolution.motion_plan, + resolution.invocation.count, + resolution.first_move, + execution_options + ) + if not domain.ActionOutcome.is(outcome) then + fail("MotionExecutor must return an ActionOutcome", 2) + end + return outcome +end + +function SequenceCoordinator:execute_primary_resolution(resolution) + local record = coordinator_records[self] + record.last_primary_resolution = resolution + local outcome = self:execute_resolved_motion(resolution) + resolution.highlight_timer = self:refresh_primary_feedback(resolution) + return outcome +end + +function SequenceCoordinator:last_primary_resolution() + return coordinator_records[self].last_primary_resolution +end + +function SequenceCoordinator:last_explicit_resolution() + return coordinator_records[self].last_explicit_resolution +end + +function SequenceCoordinator:reset() + local record = coordinator_records[self] + local position = domain.Position.coerce(record.host:read_cursor()) + local cleanup = record.transitions:PublicReset(record.host:read_window()) + if type(record.feedback.release_transition_cleanup) ~= "function" then + fail("FeedbackService must release reset cleanup", 2) + end + record.feedback:release_transition_cleanup(cleanup) + return domain.ActionOutcome.neutral(position) +end + +SequenceCoordinator.Reset = SequenceCoordinator.reset + +function SequenceCoordinator:diagnostic_full_reset() + local record = coordinator_records[self] + local position = domain.Position.coerce(record.host:read_cursor()) + local cleanup = record.transitions:DiagnosticFullReset( + record.host:read_window() + ) + if type(record.feedback.release_transition_cleanup) ~= "function" then + fail("FeedbackService must release diagnostic cleanup", 2) + end + record.feedback:release_transition_cleanup(cleanup) + return domain.ActionOutcome.neutral(position) +end + +SequenceCoordinator.DiagnosticFullReset = + SequenceCoordinator.diagnostic_full_reset + +function SequenceCoordinator:read_explicit_invocation() + local host = coordinator_records[self].host + if type(host) ~= "table" + or type(host.read_mode) ~= "function" + or type(host.read_cursor) ~= "function" + or type(host.read_count) ~= "function" + then + fail("SequenceCoordinator host must provide explicit action state", 2) + end + local position = domain.Position.coerce(host:read_cursor()) + return { + context = domain.ModeContext.from_full_mode(host:read_mode()), + position = position, + origin = position, + count = domain.Count.new(host:read_count()), + } +end + +function SequenceCoordinator:resolve_explicit(kind, resolver_method) + if type(kind) ~= "string" or kind == "" then + fail("explicit repeat kind must be a nonempty string", 2) + end + if type(resolver_method) ~= "string" or resolver_method == "" then + fail("explicit repeat resolver method must be a nonempty string", 2) + end + local invocation = self:read_explicit_invocation() + local resolver = coordinator_records[self].repeat_resolver + if type(resolver[resolver_method]) ~= "function" then + fail("RepeatResolver must build " .. kind .. " requests", 2) + end + local request = resolver[resolver_method](resolver, invocation.context) + local resolution = { + kind = kind, + invocation = invocation, + request = request, + } + if request.neutral then + return resolution + end + local target_plan, text_view, search_scope = self:build_live_target_plan( + request.target, + invocation + ) + local motion_plan = self:build_movement_plan( + target_plan, + request.descriptor, + invocation, + search_scope + ) + resolution.target = request.target + resolution.target_plan = target_plan + resolution.motion_plan = motion_plan + resolution.text_view = text_view + resolution.search_scope = search_scope + resolution.effective_descriptor = request.descriptor + resolution.first_move = coordinator_records[self].state:get_first_move( + invocation.context + ) == true + resolution.skip_destination = target_plan.kind == domain.TargetPlanKind.EMPTY + return resolution +end + +function SequenceCoordinator:resolve_explicit_same() + return self:resolve_explicit("explicit_same", "same_direction_request") +end + +function SequenceCoordinator:resolve_explicit_opposite() + return self:resolve_explicit( + "explicit_opposite", + "opposite_direction_request" + ) +end + +function SequenceCoordinator:primary(value) + local descriptor = self:validate_primary_descriptor(value) + local invocation = self:read_primary_invocation() + invocation.fold_state = self:inspect_fold_open_policy(invocation) + invocation.opened_folds = self:open_enclosing_folds( + invocation, + invocation.fold_state + ) + invocation.repeat_decision = self:decide_primary(invocation) + if invocation.repeat_decision == repeat_resolver_factory.Decision.ACQUIRE then + local acquired = self:resolve_acquisition(descriptor, invocation) + if domain.ActionOutcome.is(acquired) then + return acquired + end + return self:execute_primary_resolution(acquired) + end + local timeout = self:evaluate_repeat_timeout(invocation) + if timeout.decision == repeat_resolver_factory.Decision.ACQUIRE then + local record = coordinator_records[self] + if timeout.cleanup ~= nil then + if type(record.feedback.release_transition_cleanup) ~= "function" then + fail("FeedbackService must release reset cleanup", 2) + end + record.feedback:release_transition_cleanup(timeout.cleanup) + end + local acquired = self:resolve_acquisition(descriptor, invocation) + if domain.ActionOutcome.is(acquired) then + return acquired + end + return self:execute_primary_resolution(acquired) + end + return self:execute_primary_resolution( + self:stored_primary_resolution(invocation, descriptor, timeout) + ) +end + +function SequenceCoordinator:execute_explicit_resolution(resolution) + if type(resolution) ~= "table" + or not domain.ExplicitRepeatRequest.is(resolution.request) + then + fail("explicit execution requires a resolved repeat request", 2) + end + coordinator_records[self].last_explicit_resolution = resolution + if resolution.request.neutral then + return domain.ActionOutcome.empty(resolution.invocation.position) + end + return self:execute_resolved_motion(resolution) +end + +function SequenceCoordinator:repeat_same_direction() + return self:execute_explicit_resolution(self:resolve_explicit_same()) +end + +SequenceCoordinator.RepeatSameDirection = + SequenceCoordinator.repeat_same_direction + +function SequenceCoordinator:repeat_opposite_direction() + return self:execute_explicit_resolution(self:resolve_explicit_opposite()) +end + +SequenceCoordinator.RepeatOppositeDirection = + SequenceCoordinator.repeat_opposite_direction + +function M.new(options) + return SequenceCoordinator.new(options) +end + +setmetatable(M, { + __call = function(_, options) + return SequenceCoordinator.new(options) + end, +}) + +return M diff --git a/lua/clever_tee/sequence_state.lua b/lua/clever_tee/sequence_state.lua new file mode 100644 index 0000000..5c66a42 --- /dev/null +++ b/lua/clever_tee/sequence_state.lua @@ -0,0 +1,302 @@ +local domain = require("clever_tee.domain") + +local M = {} +local State = {} +M.State = State + +local MAP_FIELDS = { + "previous_descriptor", + "previous_landing", + "first_move", + "previous_target", +} + +local MAP_FIELD_SET = {} +for _, field in ipairs(MAP_FIELDS) do + MAP_FIELD_SET[field] = true +end + +local data = { + previous_descriptor = {}, + previous_landing = {}, + first_move = {}, + previous_target = {}, + known_contexts = {}, + last_input_context = nil, + moved_forward = false, + moved_forward_initialized = false, + migemo_cache = {}, + repeat_timestamp_ms = 0, + highlight_timer = nil, + target_overlays = {}, + temporary_overlays = {}, + finalizers = {}, +} + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function normalize_context(context, name) + if domain.ModeContext.is(context) then + return domain.ModeContext.from_full_mode(context.full_mode) + end + if type(context) ~= "string" or context == "" then + fail((name or "context") .. " must be a ModeContext or full mode string", 2) + end + return domain.ModeContext.from_full_mode(context) +end + +local function copy_map(source) + local result = {} + for key, value in pairs(source) do + result[key] = value + end + return result +end + +local function copy_resource(resource) + local result = {} + for key, value in pairs(resource) do + result[key] = value + end + return result +end + +local function copy_resources(resources) + local result = {} + for index, resource in ipairs(resources) do + result[index] = copy_resource(resource) + end + return result +end + +local function sorted_contexts() + local result = {} + for context in pairs(data.known_contexts) do + result[#result + 1] = context + end + table.sort(result, function(left, right) + return left.key < right.key + end) + return result +end + +local function context_record(context) + return { + context = context, + previous_descriptor = data.previous_descriptor[context], + previous_landing = data.previous_landing[context], + first_move = data.first_move[context], + previous_target = data.previous_target[context], + } +end + +local function context_records() + local result = {} + for _, context in ipairs(sorted_contexts()) do + result[context.key] = context_record(context) + end + return result +end + +function State:get_previous_descriptor(context) + context = normalize_context(context) + return data.previous_descriptor[context] +end + +function State:get_previous_landing(context) + context = normalize_context(context) + return data.previous_landing[context] +end + +function State:get_first_move(context) + context = normalize_context(context) + return data.first_move[context] +end + +function State:get_previous_target(context) + context = normalize_context(context) + return data.previous_target[context] +end + +function State:get_context(context) + context = normalize_context(context) + return context_record(context) +end + +State.context = State.get_context + +function State:has_previous_landing(context) + return self:get_previous_landing(context) ~= nil +end + +function State:get_migemo(encoding) + if type(encoding) ~= "string" or encoding == "" then + fail("encoding must be a nonempty string", 2) + end + return data.migemo_cache[encoding] +end + +function State:target_overlay_identities() + local result = {} + for index, resource in ipairs(data.target_overlays) do + result[index] = resource.identity + end + return result +end + +function State:temporary_overlay_identities() + local result = {} + for index, resource in ipairs(data.temporary_overlays) do + result[index] = resource.identity + end + return result +end + +function State:finalizer_identities() + local result = {} + for index, resource in ipairs(data.finalizers) do + result[index] = resource.identity + end + return result +end + +function State:resources() + return { + highlight_timer = data.highlight_timer, + target_overlays = copy_resources(data.target_overlays), + temporary_overlays = copy_resources(data.temporary_overlays), + finalizers = copy_resources(data.finalizers), + } +end + +function State:snapshot() + local snapshot = { + contexts = context_records(), + last_input_context = data.last_input_context, + moved_forward = data.moved_forward, + moved_forward_initialized = data.moved_forward_initialized, + migemo_cache = copy_map(data.migemo_cache), + repeat_timestamp_ms = data.repeat_timestamp_ms, + highlight_timer = data.highlight_timer, + target_overlays = copy_resources(data.target_overlays), + temporary_overlays = copy_resources(data.temporary_overlays), + finalizers = copy_resources(data.finalizers), + } + for _, field in ipairs(MAP_FIELDS) do + snapshot[field] = copy_map(data[field]) + end + return snapshot +end + +local function target_to_table(target) + return target and target:to_table() or nil +end + +function State:to_table() + local contexts = {} + for _, context in ipairs(sorted_contexts()) do + local record = context_record(context) + contexts[context.key] = { + previous_descriptor = record.previous_descriptor + and record.previous_descriptor.value + or nil, + previous_landing = record.previous_landing + and record.previous_landing:to_table() + or nil, + first_move = record.first_move, + previous_target = target_to_table(record.previous_target), + } + end + + local cache_keys = {} + for encoding in pairs(data.migemo_cache) do + cache_keys[#cache_keys + 1] = encoding + end + table.sort(cache_keys) + + return { + contexts = contexts, + last_input_context = data.last_input_context and data.last_input_context.key or nil, + moved_forward = data.moved_forward, + moved_forward_initialized = data.moved_forward_initialized, + migemo_cache = cache_keys, + repeat_timestamp_ms = data.repeat_timestamp_ms, + highlight_timer = data.highlight_timer, + target_overlays = self:target_overlay_identities(), + temporary_overlays = self:temporary_overlay_identities(), + finalizers = self:finalizer_identities(), + } +end + +local state +local state_metatable = { + __index = function(_, key) + local method = State[key] + if method ~= nil then + return method + end + if MAP_FIELD_SET[key] then + return copy_map(data[key]) + end + if key == "contexts" then + return context_records() + end + if key == "last_input_context" + or key == "moved_forward" + or key == "moved_forward_initialized" + or key == "highlight_timer" + then + return data[key] + end + if key == "repeat_timestamp" or key == "repeat_timestamp_ms" then + return data.repeat_timestamp_ms + end + if key == "migemo_cache" then + return copy_map(data.migemo_cache) + end + if key == "target_overlays" + or key == "temporary_overlays" + or key == "finalizers" + then + return copy_resources(data[key]) + end + return nil + end, + __newindex = function() + fail("SequenceState is read-only; use StateTransitions", 2) + end, + __metatable = "clever_tee.sequence_state.State", +} +state = setmetatable({}, state_metatable) + +function M.get() + return state +end + +function M.new() + return state +end + +function M.is(value) + return value == state +end + +M.global = state + +function M._mutate(target, mutation) + if target ~= state then + fail("StateTransitions must use the plugin-global SequenceState", 2) + end + if type(mutation) ~= "function" then + fail("state mutation must be a function", 2) + end + return mutation(data) +end + +function M._normalize_context(context) + return normalize_context(context) +end + +return M diff --git a/lua/clever_tee/state_transitions.lua b/lua/clever_tee/state_transitions.lua new file mode 100644 index 0000000..377f04f --- /dev/null +++ b/lua/clever_tee/state_transitions.lua @@ -0,0 +1,493 @@ +local domain = require("clever_tee.domain") +local sequence_state = require("clever_tee.sequence_state") + +local M = {} +local StateTransitions = {} +StateTransitions.__index = StateTransitions +M.StateTransitions = StateTransitions + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function is_integer(value) + return type(value) == "number" + and value > -math.huge + and value < math.huge + and value == math.floor(value) +end + +local function require_time(value, name) + if type(value) ~= "number" + or value ~= value + or value <= -math.huge + or value >= math.huge + then + fail((name or "time") .. " must be a finite number", 2) + end + return value +end + +local function require_identity(identity, name) + if identity == nil then + fail((name or "resource identity") .. " must be active", 2) + end + return identity +end + +local function require_location(location, name) + if location == nil then + fail((name or "resource location") .. " must identify its host location", 2) + end + return location +end + +local function require_target(target) + if not domain.TargetValue.is(target) then + fail("acquired target must be a TargetValue", 2) + end + return target +end + +local function require_position(position) + return domain.Position.coerce(position) +end + +local function moved_forward_value(direction) + if type(direction) == "boolean" then + return direction + end + if domain.Direction.is(direction) then + return direction == domain.Direction.FORWARD + end + if domain.Descriptor.is(direction) then + return direction.direction == domain.Direction.FORWARD + end + if direction == "forward" or direction == "backward" then + return direction == "forward" + end + fail("movement direction must be a Boolean, Direction, or Descriptor", 2) +end + +local function copy_resource(resource) + local result = {} + for key, value in pairs(resource) do + result[key] = value + end + return result +end + +local function resource_matches(resource, identity, location_field, location) + return resource.identity == identity + and (location == nil or resource[location_field] == location) +end + +local function add_unique_resource(resources, resource, location_field, field_name) + for _, active in ipairs(resources) do + if resource_matches( + active, + resource.identity, + location_field, + resource[location_field] + ) then + fail(field_name .. " resource is already active at this host location", 3) + end + end + resources[#resources + 1] = resource + return copy_resource(resource) +end + +local function remove_resources(data, field, predicate) + local removed = {} + local retained = {} + for _, resource in ipairs(data[field]) do + if predicate(resource) then + removed[#removed + 1] = copy_resource(resource) + else + retained[#retained + 1] = resource + end + end + data[field] = retained + return removed +end + +local function clear_target_overlays(data, window) + return remove_resources(data, "target_overlays", function(resource) + return window == nil or resource.window == window + end) +end + +local function clear_temporary_overlays(data, window) + return remove_resources(data, "temporary_overlays", function(resource) + return window == nil or resource.window == window + end) +end + +local function clear_finalizers(data, buffer) + return remove_resources(data, "finalizers", function(resource) + return buffer == nil or resource.buffer == buffer + end) +end + +local function clear_highlight_timer(data) + local identity = data.highlight_timer + data.highlight_timer = nil + return identity +end + +local function clear_all_landings_and_direction(data) + data.previous_landing = {} + data.moved_forward = false +end + +local function public_reset(data, current_window) + local cleanup = { + highlight_timer = clear_highlight_timer(data), + target_overlays = clear_target_overlays(data, current_window), + finalizers = {}, + temporary_overlays = {}, + } + data.previous_descriptor = {} + data.previous_landing = {} + data.first_move = {} + data.migemo_cache = {} + data.repeat_timestamp_ms = 0 + return cleanup +end + +function StateTransitions.new(state) + state = state or sequence_state.get() + if not sequence_state.is(state) then + fail("StateTransitions requires the plugin-global SequenceState", 2) + end + return setmetatable({ _state = state }, StateTransitions) +end + +function M.new(state) + return StateTransitions.new(state) +end + +setmetatable(M, { + __call = function(_, state) + return StateTransitions.new(state) + end, +}) + +function StateTransitions:state() + return self._state +end + +function StateTransitions:_mutate(mutation) + return sequence_state._mutate(self._state, mutation) +end + +function StateTransitions:BeginAcquisition(context, descriptor) + context = sequence_state._normalize_context(context) + descriptor = domain.Descriptor.from_string(descriptor) + return self:_mutate(function(state) + state.known_contexts[context] = true + state.previous_descriptor[context] = descriptor + state.first_move[context] = true + return self._state:get_context(context) + end) +end + +function StateTransitions:CommitAcquiredTarget(context, target, time_ms) + context = sequence_state._normalize_context(context) + target = require_target(target) + if time_ms ~= nil then + time_ms = require_time(time_ms, "acquisition time") + end + return self:_mutate(function(state) + state.known_contexts[context] = true + state.previous_target[context] = target + state.last_input_context = context + if time_ms ~= nil then + state.repeat_timestamp_ms = time_ms + end + return self._state:get_context(context) + end) +end + +function StateTransitions:CommitCommandSuccess(context, destination, direction) + context = sequence_state._normalize_context(context) + destination = require_position(destination) + local forward = moved_forward_value(direction) + return self:_mutate(function(state) + state.known_contexts[context] = true + state.moved_forward = forward + state.moved_forward_initialized = true + state.previous_landing[context] = destination + state.first_move[context] = false + return self._state:get_context(context) + end) +end + +function StateTransitions:CommitVisualSuccess(context, destination) + context = sequence_state._normalize_context(context) + destination = require_position(destination) + return self:_mutate(function(state) + state.known_contexts[context] = true + state.previous_landing[context] = destination + state.first_move[context] = false + return self._state:get_context(context) + end) +end + +function StateTransitions:ClearAllLandingsAndDirection() + return self:_mutate(function(state) + clear_all_landings_and_direction(state) + end) +end + +function StateTransitions:SetRepeatTimestamp(time_ms) + time_ms = require_time(time_ms, "repeat timestamp") + return self:_mutate(function(state) + local previous = state.repeat_timestamp_ms + state.repeat_timestamp_ms = time_ms + return previous + end) +end + +function StateTransitions:CacheMigemo(encoding, dictionary) + if type(encoding) ~= "string" or encoding == "" then + fail("Migemo cache encoding must be a nonempty string", 2) + end + if dictionary == nil then + fail("Migemo cache dictionary must be present", 2) + end + return self:_mutate(function(state) + local previous = state.migemo_cache[encoding] + state.migemo_cache[encoding] = dictionary + return previous + end) +end + +function StateTransitions:RemoveMigemo(encoding) + if type(encoding) ~= "string" or encoding == "" then + fail("Migemo cache encoding must be a nonempty string", 2) + end + return self:_mutate(function(state) + local previous = state.migemo_cache[encoding] + state.migemo_cache[encoding] = nil + return previous + end) +end + +function StateTransitions:ClearMigemoCache() + return self:_mutate(function(state) + local previous = state.migemo_cache + state.migemo_cache = {} + return previous + end) +end + +function StateTransitions:SetHighlightTimer(identity) + return self:_mutate(function(state) + local previous = state.highlight_timer + state.highlight_timer = identity + return previous + end) +end + +function StateTransitions:ClearHighlightTimer(expected_identity) + return self:_mutate(function(state) + local current = state.highlight_timer + if current == nil then + return nil, false + end + if expected_identity ~= nil and current ~= expected_identity then + return nil, false + end + state.highlight_timer = nil + return current, true + end) +end + +function StateTransitions:AddTargetOverlay(identity, window, anchor_line) + if type(identity) == "table" and window == nil and identity.identity ~= nil then + local resource = identity + identity = resource.identity + window = resource.window + anchor_line = resource.anchor_line + end + require_identity(identity, "target overlay identity") + require_location(window, "target overlay window") + if anchor_line ~= nil and (not is_integer(anchor_line) or anchor_line < 1) then + fail("target overlay anchor_line must be a positive integer", 2) + end + local resource = { + identity = identity, + window = window, + group = "CleverTeeChar", + anchor_line = anchor_line, + } + return self:_mutate(function(state) + return add_unique_resource( + state.target_overlays, + resource, + "window", + "target overlay" + ) + end) +end + +function StateTransitions:RemoveTargetOverlay(identity, window) + require_identity(identity, "target overlay identity") + return self:_mutate(function(state) + return remove_resources(state, "target_overlays", function(resource) + return resource_matches(resource, identity, "window", window) + end) + end) +end + +function StateTransitions:ClearTargetOverlays(window) + return self:_mutate(function(state) + return clear_target_overlays(state, window) + end) +end + +function StateTransitions:AddTemporaryOverlay(identity, window, group) + if type(identity) == "table" and window == nil and identity.identity ~= nil then + local resource = identity + identity = resource.identity + window = resource.window + group = resource.group + end + require_identity(identity, "temporary overlay identity") + require_location(window, "temporary overlay window") + group = group or "CleverTeeCursor" + if group ~= "CleverTeeCursor" and group ~= "CleverTeeDirect" then + fail("temporary overlay group must be CleverTeeCursor or CleverTeeDirect", 2) + end + local resource = { + identity = identity, + window = window, + group = group, + } + return self:_mutate(function(state) + return add_unique_resource( + state.temporary_overlays, + resource, + "window", + "temporary overlay" + ) + end) +end + +function StateTransitions:RemoveTemporaryOverlay(identity, window) + require_identity(identity, "temporary overlay identity") + return self:_mutate(function(state) + return remove_resources(state, "temporary_overlays", function(resource) + return resource_matches(resource, identity, "window", window) + end) + end) +end + +function StateTransitions:ClearTemporaryOverlays(window) + return self:_mutate(function(state) + return clear_temporary_overlays(state, window) + end) +end + +function StateTransitions:AddFinalizer(identity, buffer) + if type(identity) == "table" and buffer == nil and identity.identity ~= nil then + local resource = identity + identity = resource.identity + buffer = resource.buffer + end + require_identity(identity, "finalizer identity") + require_location(buffer, "finalizer buffer") + local resource = { + identity = identity, + buffer = buffer, + } + return self:_mutate(function(state) + return add_unique_resource(state.finalizers, resource, "buffer", "finalizer") + end) +end + +function StateTransitions:RemoveFinalizer(identity, buffer) + require_identity(identity, "finalizer identity") + return self:_mutate(function(state) + return remove_resources(state, "finalizers", function(resource) + return resource_matches(resource, identity, "buffer", buffer) + end) + end) +end + +function StateTransitions:ClearFinalizers(buffer) + return self:_mutate(function(state) + return clear_finalizers(state, buffer) + end) +end + +function StateTransitions:ClearTargetFeedback(current_window) + return self:_mutate(function(state) + return { + highlight_timer = clear_highlight_timer(state), + target_overlays = clear_target_overlays(state, current_window), + finalizers = {}, + temporary_overlays = {}, + } + end) +end + +function StateTransitions:FullFinalization(current_window) + return self:_mutate(function(state) + local cleanup = { + highlight_timer = clear_highlight_timer(state), + target_overlays = clear_target_overlays(state, current_window), + finalizers = clear_finalizers(state), + temporary_overlays = {}, + } + clear_all_landings_and_direction(state) + return cleanup + end) +end + +function StateTransitions:PublicReset(current_window) + return self:_mutate(function(state) + return public_reset(state, current_window) + end) +end + +function StateTransitions:DiagnosticFullReset(current_window) + return self:_mutate(function(state) + local cleanup = public_reset(state, current_window) + cleanup.finalizers = clear_finalizers(state) + state.previous_target = {} + state.last_input_context = nil + state.moved_forward = false + state.moved_forward_initialized = false + return cleanup + end) +end + +StateTransitions.begin_acquisition = StateTransitions.BeginAcquisition +StateTransitions.commit_acquired_target = StateTransitions.CommitAcquiredTarget +StateTransitions.commit_command_success = StateTransitions.CommitCommandSuccess +StateTransitions.commit_visual_success = StateTransitions.CommitVisualSuccess +StateTransitions.clear_all_landings_and_direction = + StateTransitions.ClearAllLandingsAndDirection +StateTransitions.set_repeat_timestamp = StateTransitions.SetRepeatTimestamp +StateTransitions.cache_migemo = StateTransitions.CacheMigemo +StateTransitions.remove_migemo = StateTransitions.RemoveMigemo +StateTransitions.clear_migemo_cache = StateTransitions.ClearMigemoCache +StateTransitions.set_highlight_timer = StateTransitions.SetHighlightTimer +StateTransitions.clear_highlight_timer = StateTransitions.ClearHighlightTimer +StateTransitions.add_target_overlay = StateTransitions.AddTargetOverlay +StateTransitions.remove_target_overlay = StateTransitions.RemoveTargetOverlay +StateTransitions.clear_target_overlays = StateTransitions.ClearTargetOverlays +StateTransitions.add_temporary_overlay = StateTransitions.AddTemporaryOverlay +StateTransitions.remove_temporary_overlay = StateTransitions.RemoveTemporaryOverlay +StateTransitions.clear_temporary_overlays = StateTransitions.ClearTemporaryOverlays +StateTransitions.add_finalizer = StateTransitions.AddFinalizer +StateTransitions.remove_finalizer = StateTransitions.RemoveFinalizer +StateTransitions.clear_finalizers = StateTransitions.ClearFinalizers +StateTransitions.clear_target_feedback = StateTransitions.ClearTargetFeedback +StateTransitions.full_finalization = StateTransitions.FullFinalization +StateTransitions.public_reset = StateTransitions.PublicReset +StateTransitions.diagnostic_full_reset = StateTransitions.DiagnosticFullReset + +return M diff --git a/lua/clever_tee/target_plan.lua b/lua/clever_tee/target_plan.lua new file mode 100644 index 0000000..a6c2d68 --- /dev/null +++ b/lua/clever_tee/target_plan.lua @@ -0,0 +1,541 @@ +local case_policy = require("clever_tee.case_policy") +local domain = require("clever_tee.domain") +local migemo_catalog = require("clever_tee.migemo_catalog") +local text_topology = require("clever_tee.text_topology") + +local M = {} +local TargetPlanFactory = {} +M.TargetPlanFactory = TargetPlanFactory + +M.SYMBOLS = "!\"#$%&'()=~|\\-^@`[]{};:+*<>,.?_/" + +local SYMBOL_CHARACTERS = {} +local SYMBOL_SET = {} +for index = 1, #M.SYMBOLS do + local character = M.SYMBOLS:sub(index, index) + SYMBOL_CHARACTERS[index] = character + SYMBOL_SET[character] = true +end + +local factory_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function require_target(target) + if not domain.TargetValue.is(target) then + fail("target plan target must be a TargetValue", 2) + end + return target +end + +local function require_boolean(value, name) + if type(value) ~= "boolean" then + fail("match policy " .. name .. " must be a Boolean", 2) + end + return value +end + +local function require_string(value, name) + if type(value) ~= "string" then + fail("match policy " .. name .. " must be a string", 2) + end + return value +end + +local function copy_list(values) + local result = {} + for index = 1, #values do + result[index] = values[index] + end + return result +end + +function M.symbol_characters() + return copy_list(SYMBOL_CHARACTERS) +end + +function M.is_symbol(character) + return type(character) == "string" and SYMBOL_SET[character] == true +end + +local function require_character_list(characters, source) + if type(characters) ~= "table" then + fail("editor character splitter must return a list", 3) + end + + local result = {} + local item_count = 0 + for key, character in pairs(characters) do + if type(key) ~= "number" + or key ~= math.floor(key) + or key < 1 + or key > #characters + or type(character) ~= "string" + or character == "" + then + fail("editor character splitter must return a list of nonempty strings", 3) + end + result[key] = character + item_count = item_count + 1 + end + if item_count ~= #characters or table.concat(result) ~= source then + fail("editor character splitter must preserve the configured trigger string", 3) + end + return result +end + +function M.parse_trigger_characters(value, splitter) + if type(value) ~= "string" then + fail("chars_match_any_signs must be a string", 2) + end + splitter = splitter or text_topology.split_editor_characters + if type(splitter) ~= "function" then + fail("editor character splitter must be a function", 2) + end + return require_character_list(splitter(value), value) +end + +local function trigger_set(value, splitter) + local result = {} + for _, character in ipairs(M.parse_trigger_characters(value, splitter)) do + result[character] = true + end + return result +end + +local function false_matcher() + return false +end + +local function symbol_matcher(candidate_character) + return M.is_symbol(candidate_character) +end + +local function normalize_factory_options(options) + if options == nil then + return {} + end + if type(options) == "function" then + return { lowercase = options } + end + if type(options) ~= "table" then + fail("TargetPlanFactory options must be a table", 3) + end + if type(options.sample_match) == "function" + and options.policy == nil + and options.policy_service == nil + and options.case_resolver == nil + and options.lowercase == nil + and options.splitter == nil + and options.split_editor_characters == nil + then + return { policy = options } + end + return options +end + +local function require_policy_service(service) + if service ~= nil and (type(service) ~= "table" + or type(service.sample_match) ~= "function") + then + fail("TargetPlanFactory policy must provide sample_match", 3) + end + return service +end + +local function require_case_resolver(resolver, options) + if resolver == nil then + return case_policy.new({ + lowercase = options.lowercase, + }) + end + if type(resolver) ~= "table" + or type(resolver.resolve) ~= "function" + or type(resolver.comparator) ~= "function" + then + fail("TargetPlanFactory case resolver is invalid", 3) + end + return resolver +end + +local function require_splitter(splitter) + splitter = splitter or text_topology.split_editor_characters + if type(splitter) ~= "function" then + fail("TargetPlanFactory editor character splitter must be a function", 3) + end + return splitter +end + +local function require_migemo_catalog(catalog) + if catalog ~= nil and not migemo_catalog.MigemoCatalog.is(catalog) then + fail("TargetPlanFactory migemo_catalog must be a MigemoCatalog", 3) + end + return catalog +end + +local factory_metatable = { + __index = TargetPlanFactory, + __newindex = function() + fail("TargetPlanFactory values are immutable", 2) + end, + __tostring = function() + return "target-plan-factory" + end, + __metatable = "clever_tee.target_plan.TargetPlanFactory", +} + +function TargetPlanFactory.new(options) + if TargetPlanFactory.is(options) then + return options + end + options = normalize_factory_options(options) + local factory = setmetatable({}, factory_metatable) + factory_records[factory] = { + policy = require_policy_service(options.policy or options.policy_service), + case_resolver = require_case_resolver(options.case_resolver, options), + splitter = require_splitter( + options.split_editor_characters or options.splitter + ), + migemo_catalog = require_migemo_catalog( + options.migemo_catalog or options.catalog + ), + } + return factory +end + +function TargetPlanFactory.is(value) + return type(value) == "table" and factory_records[value] ~= nil +end + +function M.new(options) + return TargetPlanFactory.new(options) +end + +setmetatable(M, { + __call = function(_, options) + return TargetPlanFactory.new(options) + end, +}) + +local function default_match_policy() + return { + ignore_case = false, + smart_case = false, + use_migemo = false, + chars_match_any_signs = "", + } +end + +local function sampled_policy(factory, target, match_policy) + local service + if match_policy == nil then + service = factory_records[factory].policy + if service == nil then + return default_match_policy() + end + elseif type(match_policy) == "table" + and type(match_policy.sample_match) == "function" + then + service = match_policy + end + + if service ~= nil then + match_policy = service:sample_match(target) + end + if type(match_policy) ~= "table" then + fail("target match policy must be a table", 3) + end + + local use_migemo = match_policy.use_migemo + if use_migemo == nil then + use_migemo = false + end + + return { + ignore_case = require_boolean(match_policy.ignore_case, "ignore_case"), + smart_case = require_boolean(match_policy.smart_case, "smart_case"), + use_migemo = require_boolean(use_migemo, "use_migemo"), + chars_match_any_signs = require_string( + match_policy.chars_match_any_signs, + "chars_match_any_signs" + ), + } +end + +local function new_plan(target, kind, case_mode, matcher) + return domain.TargetPlan.new({ + target = target, + kind = kind, + case_mode = case_mode, + matcher = matcher, + }) +end + +local function is_ascii_alphabetic(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")) + or (code >= string.byte("A") and code <= string.byte("Z")) +end + +M.is_ascii_alphabetic = is_ascii_alphabetic + +local function context_field(context, primary, alternate) + local value = context[primary] + if value == nil and alternate ~= nil then + value = context[alternate] + end + return value +end + +local function context_table(match_policy, search_context) + if text_topology.TextView.is(search_context) then + return { text_view = search_context } + end + if search_context ~= nil and type(search_context) ~= "table" then + fail("target search context must be a table or TextView", 3) + end + + local context = search_context or {} + if search_context == nil and type(match_policy) == "table" then + if match_policy.text_view ~= nil + or match_policy.view ~= nil + or match_policy.search_scope ~= nil + or match_policy.scope ~= nil + or match_policy.origin ~= nil + or match_policy.current_line ~= nil + or match_policy.effective_encoding ~= nil + or match_policy.encoding ~= nil + then + context = match_policy + end + end + return context +end + +local function active_policy_service(factory, match_policy) + if type(match_policy) == "table" + and type(match_policy.sample_match) == "function" + then + return match_policy + end + return factory_records[factory].policy +end + +local function search_scope(factory, match_policy, context) + local value = context_field(context, "search_scope", "scope") + if value == nil and type(match_policy) == "table" then + value = match_policy.search_scope + if value == nil and match_policy.search_current_line_only ~= nil then + value = match_policy.search_current_line_only + and domain.SearchScope.CURRENT_LINE + or domain.SearchScope.BUFFER + end + end + if value == nil then + local service = active_policy_service(factory, match_policy) + if service ~= nil and type(service.sample_search) == "function" then + value = service:sample_search().search_scope + end + end + if value == nil then + return domain.SearchScope.BUFFER + end + if value == "line" then + value = domain.SearchScope.CURRENT_LINE + end + return domain.SearchScope.from_string(value) +end + +local function migemo_search_context(factory, match_policy, search_context) + local context = context_table(match_policy, search_context) + local view = context_field(context, "text_view", "view") + if not text_topology.TextView.is(view) then + fail("Migemo target planning requires a TextView", 3) + end + + local scope = search_scope(factory, match_policy, context) + local origin = context.origin + if origin == nil then + origin = context.current_line + end + if scope == domain.SearchScope.CURRENT_LINE and origin == nil then + fail("current-line Migemo planning requires an origin line", 3) + end + + local line_number + if scope == domain.SearchScope.CURRENT_LINE then + line_number = type(origin) == "number" + and origin + or domain.Position.coerce(origin).line + end + + local encoding = context_field(context, "effective_encoding", "encoding") + or view.requested_encoding + or view.effective_encoding + return { + view = view, + scope = scope, + origin = origin, + line_number = line_number, + encoding = encoding, + bounds = view:match_start_bounds(scope, origin), + } +end + +local function selected_migemo_catalog(factory, match_policy) + local record = factory_records[factory] + if record.migemo_catalog == nil then + record.migemo_catalog = migemo_catalog.new({ + policy = active_policy_service(factory, match_policy), + }) + end + return record.migemo_catalog +end + +local function migemo_matcher( + target_character, + case_mode, + resolver, + dictionary, + context +) + local target_equal = resolver:comparator(target_character, case_mode) + local assertion = dictionary:predicate(target_character, case_mode) + + return function(candidate_character, candidate_position, candidate_view) + if candidate_position == nil then + fail("Migemo matching requires a candidate Position", 2) + end + local position = domain.Position.coerce(candidate_position) + local view = candidate_view or context.view + if not text_topology.TextView.is(view) then + fail("Migemo matching requires a TextView", 2) + end + if not context.bounds:contains(position) + or not view:is_character_start(position) + then + return false + end + + local actual_character = view:character_at(position) + if candidate_character ~= actual_character then + return false + end + if is_ascii_alphabetic(actual_character) + and not target_equal(actual_character) + then + return false + end + return assertion(view:text_suffix(position)) + end +end + +function TargetPlanFactory:build(target, match_policy, search_context) + target = require_target(target) + local record = factory_records[self] + local sampled = sampled_policy(self, target, match_policy) + local case_mode = record.case_resolver:resolve( + target, + sampled.ignore_case, + sampled.smart_case + ) + + if target.first_code == 0x80 then + return new_plan( + target, + domain.TargetPlanKind.EMPTY, + case_mode, + false_matcher + ) + end + + if sampled.use_migemo and is_ascii_alphabetic(target.value) then + local context = migemo_search_context(self, match_policy, search_context) + local active = context.scope == domain.SearchScope.BUFFER + or context.view:line_byte_length(context.line_number) + > context.view:line_character_count(context.line_number) + if active then + local dictionary = selected_migemo_catalog(self, match_policy):get( + context.encoding, + active_policy_service(self, match_policy) + ) + return new_plan( + target, + domain.TargetPlanKind.MIGEMO, + case_mode, + migemo_matcher( + target.value, + case_mode, + record.case_resolver, + dictionary, + context + ) + ) + end + end + + local triggers = trigger_set(sampled.chars_match_any_signs, record.splitter) + if triggers[target.value] then + return new_plan( + target, + domain.TargetPlanKind.SYMBOL, + case_mode, + symbol_matcher + ) + end + + local kind = target.value == "\\" + and domain.TargetPlanKind.BACKSLASH + or domain.TargetPlanKind.LITERAL + return new_plan( + target, + kind, + case_mode, + record.case_resolver:comparator(target.value, case_mode) + ) +end + +local function is_search_context(value) + return text_topology.TextView.is(value) + or (type(value) == "table" and ( + value.text_view ~= nil + or value.view ~= nil + or value.search_scope ~= nil + or value.scope ~= nil + or value.origin ~= nil + or value.current_line ~= nil + or value.effective_encoding ~= nil + or value.encoding ~= nil + )) +end + +function M.build(target, match_policy, options, search_context) + if search_context == nil and is_search_context(options) then + search_context = options + options = nil + end + return TargetPlanFactory.new(options):build( + target, + match_policy, + search_context + ) +end + +function M.build_for_view(target, view, origin, scope, match_policy, options) + return TargetPlanFactory.new(options):build(target, match_policy, { + text_view = view, + origin = origin, + search_scope = scope, + }) +end + +M.create = M.build +M.create_plan = M.build +M.SYMBOL_SET_STRING = M.SYMBOLS + +return M diff --git a/lua/clever_tee/testing/memory_host.lua b/lua/clever_tee/testing/memory_host.lua new file mode 100644 index 0000000..4479da7 --- /dev/null +++ b/lua/clever_tee/testing/memory_host.lua @@ -0,0 +1,1075 @@ +local capabilities = require("clever_tee.capabilities") +local domain = require("clever_tee.domain") +local text_topology = require("clever_tee.text_topology") + +local M = {} +local MemoryHost = {} +MemoryHost.__index = MemoryHost +M.MemoryHost = MemoryHost +local unpack_values = table.unpack or unpack + +local function is_integer(value) + return type(value) == "number" + and value > -math.huge + and value < math.huge + and value == math.floor(value) +end + +local function copy(value, seen) + if type(value) ~= "table" or domain.type_of(value) ~= nil then + return value + end + seen = seen or {} + if seen[value] ~= nil then + return seen[value] + end + local result = {} + seen[value] = result + for key, item in pairs(value) do + result[copy(key, seen)] = copy(item, seen) + end + return result +end + +local function list_copy(values) + local result = {} + for index = 1, #values do + result[index] = values[index] + end + return result +end + +local function text_snapshot(value) + if domain.TextSnapshot.is(value) then + return value + end + if type(value) == "table" and value.lines ~= nil then + value = value.lines + end + return domain.TextSnapshot.new(value) +end + +local function selection_value(value) + if value == nil then + return domain.Selection.inactive() + end + return domain.Selection.new(value) +end + +local function macro_state(value) + if type(value) == "table" and not domain.MacroState.is(value) then + value = value.register + end + return domain.MacroState.new(value) +end + +local function fold_state(options) + if domain.FoldState.is(options.fold_state) then + return options.fold_state + end + return domain.FoldState.new( + options.fold_open_policy or {}, + options.closed_fold_levels or 0 + ) +end + +local function input_packet(value) + return domain.InputPacket.from_table(value) +end + +local function normalize_event_names(event_names) + if type(event_names) == "string" then + event_names = { event_names } + end + if type(event_names) ~= "table" or #event_names < 1 then + error("event names must be a nonempty list", 3) + end + local result = {} + local seen = {} + for index = 1, #event_names do + local name = event_names[index] + if type(name) ~= "string" or name == "" then + error("event name must be a nonempty string", 3) + end + if not seen[name] then + seen[name] = true + result[#result + 1] = name + end + end + return result, seen +end + +local function normalize_modes(modes) + if type(modes) == "string" then + modes = { modes } + end + if type(modes) ~= "table" or #modes < 1 then + error("mapping modes must be a nonempty list", 3) + end + local result = {} + for index = 1, #modes do + if type(modes[index]) ~= "string" or modes[index] == "" then + error("mapping mode must be a nonempty string", 3) + end + result[index] = modes[index] + end + return result +end + +function MemoryHost.new(options) + options = options or {} + if type(options) ~= "table" then + error("memory host options must be a table", 2) + end + + local cursor_presentation_support = options.cursor_presentation_support + if cursor_presentation_support == nil then + cursor_presentation_support = options.cmdline_cursor_support + end + if cursor_presentation_support == nil then + cursor_presentation_support = true + end + + local raw_mode = options.mode or "n" + if domain.ModeContext.is(raw_mode) then + raw_mode = raw_mode.full_mode + end + domain.ModeContext.from_full_mode(raw_mode) + + local self = setmetatable({ + _text = text_snapshot(options.text or options.buffer_lines or { "" }), + _buffer = options.buffer or "buffer-1", + _cursor = domain.Position.coerce(options.cursor or { line = 1, byte_column = 1 }), + _window = options.window or "window-1", + _mode = raw_mode, + _selection = selection_value(options.selection), + _count = domain.Count.new(options.count), + _configuration = copy(options.configuration or {}), + _encoding = options.encoding or options.effective_encoding or "utf-8", + _lowercase = options.lowercase or vim.fn.tolower, + _macro_state = macro_state(options.macro_state or options.macro_register), + _fold_state = fold_state(options), + _pending_operator = options.pending_operator, + _time_values = list_copy(options.time_values_ms or {}), + _time_index = 1, + _current_time = options.time_ms or 0, + _input_packets = {}, + _input_index = 1, + _timer_support = options.timer_support ~= false, + _cursor_presentation_support = cursor_presentation_support, + _cursor_presentation = copy(options.cursor_presentation or { + hidden = false, + }), + _emit_movement_events = options.emit_movement_events ~= false, + _operator_inclusive = false, + _operations = {}, + _prompts = {}, + _redraws = {}, + _diagnostics = {}, + _highlight_groups = copy(options.highlight_groups or {}), + _highlights = {}, + _timers = {}, + _event_registrations = {}, + _event_registration_order = {}, + _actions = {}, + _mappings = {}, + _cursor_leases = {}, + _dot_repeat = nil, + _identity_counters = {}, + }, MemoryHost) + + for index, packet in ipairs(options.input_packets or {}) do + self._input_packets[index] = input_packet(packet) + end + + self._event_queue = capabilities.EventQueue.new(function(name, payload) + self:_deliver_event_now(name, payload) + end) + + return capabilities.assert_implements(self) +end + +function M.new(options) + return MemoryHost.new(options) +end + +setmetatable(M, { + __call = function(_, options) + return MemoryHost.new(options) + end, +}) + +function MemoryHost:_next_identity(prefix) + local next_value = (self._identity_counters[prefix] or 0) + 1 + self._identity_counters[prefix] = next_value + return prefix .. "-" .. tostring(next_value) +end + +function MemoryHost:_record(operation, details) + local entry = { operation = operation } + for key, value in pairs(details or {}) do + entry[key] = copy(value) + end + self._operations[#self._operations + 1] = entry +end + +function MemoryHost:operations() + return copy(self._operations) +end + +function MemoryHost:clear_operations() + self._operations = {} +end + +function MemoryHost:read_text() + self:_record("read_text") + return self._text +end + +function MemoryHost:read_cursor() + self:_record("read_cursor") + return self._cursor +end + +function MemoryHost:read_buffer() + self:_record("read_buffer", { buffer = self._buffer }) + return self._buffer +end + +function MemoryHost:read_window() + self:_record("read_window", { window = self._window }) + return self._window +end + +function MemoryHost:read_mode() + self:_record("read_mode", { mode = self._mode }) + return self._mode +end + +function MemoryHost:read_mode_context() + return domain.ModeContext.from_full_mode(self:read_mode()) +end + +function MemoryHost:read_pending_operator() + self:_record("read_pending_operator", { operator = self._pending_operator }) + return self._pending_operator +end + +function MemoryHost:read_selection() + self:_record("read_selection") + return self._selection +end + +function MemoryHost:read_count() + self:_record("read_count", { count = self._count.value }) + return self._count +end + +function MemoryHost:configuration_present(name) + if type(name) ~= "string" or name == "" then + error("configuration name must be a nonempty string", 2) + end + local present = self._configuration[name] ~= nil + self:_record("configuration_present", { name = name, present = present }) + return present +end + +function MemoryHost:read_configuration(name) + if type(name) ~= "string" or name == "" then + error("configuration name must be a nonempty string", 2) + end + local value = copy(self._configuration[name]) + self:_record("read_configuration", { name = name, value = value }) + return value +end + +function MemoryHost:write_configuration(name, value) + if type(name) ~= "string" or name == "" then + error("configuration name must be a nonempty string", 2) + end + self._configuration[name] = copy(value) + self:_record("write_configuration", { name = name, value = value }) +end + +function MemoryHost:read_encoding() + self:_record("read_encoding", { encoding = self._encoding }) + return self._encoding +end + +function MemoryHost:lowercase(value) + if type(value) ~= "string" then + error("case conversion value must be a string", 2) + end + local result = self._lowercase(value) + if type(result) ~= "string" then + error("case converter must return a string", 2) + end + self:_record("lowercase", { value = value, result = result }) + return result +end + +function MemoryHost:read_macro_state() + self:_record("read_macro_state", { executing = self._macro_state.executing }) + return self._macro_state +end + +function MemoryHost:read_fold_state() + self:_record("read_fold_state", { closed_levels = self._fold_state.closed_levels }) + return self._fold_state +end + +function MemoryHost:read_time_ms() + local value = self._time_values[self._time_index] + if value ~= nil then + self._time_index = self._time_index + 1 + self._current_time = value + else + value = self._current_time + end + if type(value) ~= "number" then + error("time value must be a number", 2) + end + self:_record("read_time_ms", { value = value }) + return value +end + +function MemoryHost:set_text(value) + self._text = text_snapshot(value) +end + +function MemoryHost:set_cursor(position) + self._cursor = domain.Position.coerce(position) +end + +function MemoryHost:set_buffer(buffer) + if buffer == nil then + error("buffer identity must be present", 2) + end + self._buffer = buffer +end + +function MemoryHost:set_window(window) + if window == nil then + error("window identity must be present", 2) + end + self._window = window +end + +function MemoryHost:set_mode(full_mode) + if domain.ModeContext.is(full_mode) then + full_mode = full_mode.full_mode + end + domain.ModeContext.from_full_mode(full_mode) + self._mode = full_mode +end + +function MemoryHost:set_selection(selection) + self._selection = selection_value(selection) +end + +function MemoryHost:set_count(count) + self._count = domain.Count.new(count) +end + +function MemoryHost:set_configuration(name, value) + if type(name) ~= "string" or name == "" then + error("configuration name must be a nonempty string", 2) + end + self._configuration[name] = copy(value) +end + +function MemoryHost:unset_configuration(name) + self._configuration[name] = nil +end + +function MemoryHost:set_encoding(encoding) + if type(encoding) ~= "string" or encoding == "" then + error("encoding must be a nonempty string", 2) + end + self._encoding = encoding +end + +function MemoryHost:set_macro_state(state) + self._macro_state = macro_state(state) +end + +function MemoryHost:set_fold_state(state, closed_levels) + if domain.FoldState.is(state) then + self._fold_state = state + else + self._fold_state = domain.FoldState.new(state, closed_levels) + end +end + +function MemoryHost:set_pending_operator(operator) + self._pending_operator = operator +end + +function MemoryHost:push_time_ms(value) + if type(value) ~= "number" then + error("time value must be a number", 2) + end + self._time_values[#self._time_values + 1] = value +end + +function MemoryHost:push_input(packet) + self._input_packets[#self._input_packets + 1] = input_packet(packet) +end + +function MemoryHost:_emit_movement_event(previous) + if self._emit_movement_events and not domain.Position.equal(previous, self._cursor) then + self:deliver_event("CursorMoved", { + cursor = self._cursor, + }) + end +end + +local function motion_descriptor(motion) + if domain.Descriptor.is(motion) then + return motion + end + if type(motion) == "table" and motion.descriptor ~= nil then + return domain.Descriptor.from_string(motion.descriptor) + end + return nil +end + +local function character_boundary(view, position) + if view:line_is_empty(position.line) then + return 1 + end + return view:character_index_for_position(position) +end + +local function character_lines(snapshot) + local result = {} + for line_number, line in ipairs(snapshot:lines()) do + result[line_number] = text_topology.split_editor_characters(line) + end + return result +end + +local function joined_range(characters, first, last) + local result = {} + for index = first, last do + result[#result + 1] = characters[index] + end + return table.concat(result) +end + +local function delete_character_range( + snapshot, + start_line, + start_index, + finish_line, + finish_index +) + local source = character_lines(snapshot) + local lines = snapshot:lines() + local result = {} + + for line_number = 1, start_line - 1 do + result[#result + 1] = lines[line_number] + end + + local prefix = joined_range(source[start_line], 1, start_index - 1) + if start_line == finish_line then + result[#result + 1] = prefix + .. joined_range( + source[start_line], + finish_index, + #source[start_line] + ) + else + result[#result + 1] = prefix + .. joined_range( + source[finish_line], + finish_index, + #source[finish_line] + ) + end + + for line_number = finish_line + 1, #lines do + result[#result + 1] = lines[line_number] + end + return domain.TextSnapshot.new(result) +end + +local function normalized_cursor(snapshot, encoding, position) + local line_number = math.min(position.line, snapshot.line_count) + local view = text_topology.new(snapshot, encoding) + return view:normalize_endpoint(line_number, position.byte_column) +end + +function MemoryHost:_apply_pending_delete(origin, destination, descriptor) + if self._pending_operator ~= "delete" and self._pending_operator ~= "d" then + return false + end + + local view = text_topology.new(self._text, self._encoding) + local origin_index = character_boundary(view, origin) + local destination_index = character_boundary(view, destination) + local start_line + local start_index + local finish_line + local finish_index + local final_cursor + + if descriptor.direction == domain.Direction.FORWARD then + start_line = origin.line + start_index = origin_index + finish_line = destination.line + finish_index = destination_index + (self._operator_inclusive and 1 or 0) + final_cursor = origin + elseif descriptor.family == domain.Family.FIND then + start_line = destination.line + start_index = destination_index + 1 + finish_line = origin.line + finish_index = origin_index + 1 + final_cursor = destination + else + start_line = destination.line + start_index = destination_index + finish_line = origin.line + finish_index = origin_index + final_cursor = view:predecessor(destination) or destination + end + + self._text = delete_character_range( + self._text, + start_line, + start_index, + finish_line, + finish_index + ) + self._cursor = normalized_cursor(self._text, self._encoding, final_cursor) + self:_record("apply_operator", { + operator = self._pending_operator, + descriptor = descriptor.value, + origin = origin, + endpoint = destination, + position = self._cursor, + }) + return true +end + +function MemoryHost:apply_cursor(position, motion) + position = domain.Position.coerce(position) + local previous = self._cursor + local descriptor = motion_descriptor(motion) + self._cursor = position + self:_record("apply_cursor", { + position = position, + descriptor = descriptor and descriptor.value or nil, + }) + if descriptor ~= nil then + local origin = type(motion) == "table" and motion.origin or previous + self:_apply_pending_delete(domain.Position.coerce(origin), position, descriptor) + end + self:_emit_movement_event(previous) +end + +function MemoryHost:apply_selection(position, kind) + local previous = self._cursor + local next_selection + if domain.Selection.is(position) then + next_selection = position + position = next_selection.focus + else + position = domain.Position.coerce(position) + if kind == nil then + kind = self._selection.kind + end + kind = domain.SelectionKind.from_string(kind) + if kind == domain.SelectionKind.NONE then + error("selection movement requires a Visual selection kind", 2) + end + local anchor = self._selection.active and self._selection.anchor or previous + next_selection = domain.Selection.active( + kind, + anchor, + position, + self._selection.option + ) + end + + self._selection = next_selection + self._cursor = position + self:_record("apply_selection", { + position = position, + kind = next_selection.kind.value, + }) + self:_emit_movement_event(previous) +end + +function MemoryHost:set_operator_inclusive(enabled) + if type(enabled) ~= "boolean" then + error("operator inclusivity must be a Boolean", 2) + end + self._operator_inclusive = enabled + self:_record("set_operator_inclusive", { enabled = enabled }) +end + +function MemoryHost:operator_inclusive() + return self._operator_inclusive +end + +function MemoryHost:read_input() + local packet = self._input_packets[self._input_index] + if packet == nil then + error("in-memory input queue is empty", 2) + end + self._input_index = self._input_index + 1 + self:_record("read_input", { packet = packet:to_table() }) + if packet.kind == domain.InputPacketKind.ERROR then + error(packet.message, 0) + end + return packet +end + +function MemoryHost:open_fold(position) + position = position and domain.Position.coerce(position) or self._cursor + local closed_levels = self._fold_state.closed_levels + if closed_levels == 0 then + self:_record("open_fold", { position = position, opened = false }) + return false + end + self:_record("open_fold", { + position = position, + fold_level = closed_levels, + opened = true, + }) + self._fold_state = domain.FoldState.new( + self._fold_state:policies(), + closed_levels - 1 + ) + return true +end + +function MemoryHost:show_prompt(text) + if type(text) ~= "string" then + error("prompt must be a string", 2) + end + self._prompts[#self._prompts + 1] = text + self:_record("show_prompt", { text = text }) +end + +function MemoryHost:prompts() + return list_copy(self._prompts) +end + +function MemoryHost:redraw(kind) + if kind ~= "screen" and kind ~= "full" and kind ~= "suppressed" then + error("redraw kind must be screen, full, or suppressed", 2) + end + self._redraws[#self._redraws + 1] = kind + self:_record("redraw", { kind = kind }) +end + +function MemoryHost:redraws() + return list_copy(self._redraws) +end + +function MemoryHost:emit_diagnostic(level, text) + if level ~= "error" and level ~= "warning" and level ~= "info" then + error("diagnostic level must be error, warning, or info", 2) + end + if type(text) ~= "string" or text == "" then + error("diagnostic text must be a nonempty string", 2) + end + local diagnostic = { level = level, text = text } + self._diagnostics[#self._diagnostics + 1] = diagnostic + self:_record("emit_diagnostic", diagnostic) +end + +function MemoryHost:diagnostics() + return copy(self._diagnostics) +end + +function MemoryHost:read_highlight_group(name) + if type(name) ~= "string" or name == "" then + error("highlight group name must be a nonempty string", 2) + end + local definition = self._highlight_groups[name] + self:_record("read_highlight_group", { + name = name, + defined = definition ~= nil, + }) + return copy(definition) +end + +function MemoryHost:highlight_groups() + return copy(self._highlight_groups) +end + +function MemoryHost:define_highlight_group(name, definition, options) + if type(name) ~= "string" or name == "" then + error("highlight group name must be a nonempty string", 2) + end + if type(definition) ~= "table" then + error("highlight group definition must be a table", 2) + end + options = options or {} + if type(options) ~= "table" then + error("highlight group options must be a table", 2) + end + if options.default ~= nil and type(options.default) ~= "boolean" then + error("highlight group default option must be a Boolean", 2) + end + if options.force ~= nil and type(options.force) ~= "boolean" then + error("highlight group force option must be a Boolean", 2) + end + + local exists = self._highlight_groups[name] ~= nil + local applied = not (exists and options.default) + if applied then + self._highlight_groups[name] = copy(definition) + end + self:_record("define_highlight_group", { + name = name, + definition = definition, + options = options, + applied = applied, + }) + return applied +end + +function MemoryHost:create_highlight(specification) + if type(specification) ~= "table" then + error("highlight specification must be a table", 2) + end + if type(specification.group) ~= "string" or specification.group == "" then + error("highlight group must be a nonempty string", 2) + end + local identity = specification.identity or self:_next_identity("highlight") + if self._highlights[identity] ~= nil then + error("highlight identity is already active", 2) + end + local stored = copy(specification) + stored.identity = identity + self._highlights[identity] = stored + self:_record("create_highlight", stored) + return identity +end + +function MemoryHost:remove_highlight(identity) + if type(identity) ~= "string" or identity == "" then + error("highlight identity must be a nonempty string", 2) + end + local removed = self._highlights[identity] ~= nil + self._highlights[identity] = nil + self:_record("remove_highlight", { identity = identity, removed = removed }) + return removed +end + +function MemoryHost:highlights() + return copy(self._highlights) +end + +function MemoryHost:supports_cursor_presentation() + self:_record("supports_cursor_presentation", { + supported = self._cursor_presentation_support, + }) + return self._cursor_presentation_support +end + +function MemoryHost:suppress_cursor_presentation() + if not self._cursor_presentation_support then + self:_record("suppress_cursor_presentation", { supported = false }) + return nil + end + local identity = self:_next_identity("cursor-presentation") + self._cursor_leases[identity] = copy(self._cursor_presentation) + local suppressed = copy(self._cursor_presentation) + suppressed.hidden = true + self._cursor_presentation = suppressed + self:_record("suppress_cursor_presentation", { + identity = identity, + supported = true, + }) + return identity +end + +function MemoryHost:restore_cursor_presentation(identity) + if identity == nil then + self:_record("restore_cursor_presentation", { restored = false }) + return false + end + local saved = self._cursor_leases[identity] + if saved == nil then + error("cursor presentation lease is inactive", 2) + end + self._cursor_presentation = saved + self._cursor_leases[identity] = nil + self:_record("restore_cursor_presentation", { + identity = identity, + restored = true, + }) + return true +end + +function MemoryHost:cursor_presentation() + return copy(self._cursor_presentation) +end + +function MemoryHost:supports_timers() + self:_record("supports_timers", { supported = self._timer_support }) + return self._timer_support +end + +function MemoryHost:start_timer(delay_ms, callback) + if not is_integer(delay_ms) or delay_ms < 0 then + error("timer delay must be a nonnegative integer", 2) + end + if type(callback) ~= "function" then + error("timer callback must be a function", 2) + end + if not self._timer_support then + self:_record("start_timer", { delay_ms = delay_ms, supported = false }) + return nil + end + local identity = self:_next_identity("timer") + self._timers[identity] = { + identity = identity, + delay_ms = delay_ms, + callback = callback, + active = true, + } + self:_record("start_timer", { + identity = identity, + delay_ms = delay_ms, + supported = true, + }) + return identity +end + +function MemoryHost:stop_timer(identity) + if type(identity) ~= "string" or identity == "" then + error("timer identity must be a nonempty string", 2) + end + local timer = self._timers[identity] + local stopped = timer ~= nil and timer.active + if timer ~= nil then + timer.active = false + end + self:_record("stop_timer", { identity = identity, stopped = stopped }) + return stopped +end + +function MemoryHost:fire_timer(identity) + local timer = self._timers[identity] + if timer == nil then + error("timer identity is unknown", 2) + end + if not timer.active then + self:_record("ignore_timer", { identity = identity }) + return false + end + timer.active = false + self:_record("fire_timer", { identity = identity }) + timer.callback(identity) + return true +end + +function MemoryHost:timers() + local result = {} + for identity, timer in pairs(self._timers) do + result[identity] = { + identity = identity, + delay_ms = timer.delay_ms, + active = timer.active, + } + end + return result +end + +function MemoryHost:register_events(event_names, callback, options) + local names, name_set = normalize_event_names(event_names) + if type(callback) ~= "function" then + error("event callback must be a function", 2) + end + local identity = self:_next_identity("event-registration") + self._event_registrations[identity] = { + identity = identity, + names = names, + name_set = name_set, + callback = callback, + options = copy(options or {}), + active = true, + } + self._event_registration_order[#self._event_registration_order + 1] = identity + self:_record("register_events", { + identity = identity, + names = names, + options = options or {}, + }) + return identity +end + +function MemoryHost:remove_event_registration(identity) + local registration = self._event_registrations[identity] + local removed = registration ~= nil and registration.active + if registration ~= nil then + registration.active = false + end + self:_record("remove_event_registration", { + identity = identity, + removed = removed, + }) + return removed +end + +function MemoryHost:_deliver_event_now(name, payload) + self:_record("event", { name = name, payload = payload }) + local order = list_copy(self._event_registration_order) + local event_buffer = payload.buffer or self._buffer + for _, identity in ipairs(order) do + local registration = self._event_registrations[identity] + local registration_buffer = registration.options.buffer + if registration.active + and registration.name_set[name] + and (registration_buffer == nil or registration_buffer == event_buffer) + then + registration.callback(name, payload) + end + end +end + +function MemoryHost:deliver_event(name, payload) + if type(name) ~= "string" or name == "" then + error("event name must be a nonempty string", 2) + end + payload = copy(payload or {}) + local queued = self._event_queue:is_transition_active() + self:_record(queued and "queue_event" or "deliver_event", { + name = name, + payload = payload, + }) + return self._event_queue:emit(name, payload) +end + +function MemoryHost:begin_action_transition() + local token = self._event_queue:begin_transition() + self:_record("begin_action_transition", { identity = token }) + return token +end + +function MemoryHost:commit_action_transition(token) + self:_record("commit_action_transition", { identity = token }) + self._event_queue:commit_transition(token) +end + +function MemoryHost:pending_event_count() + return self._event_queue:pending_count() +end + +function MemoryHost:event_registrations() + local result = {} + for identity, registration in pairs(self._event_registrations) do + result[identity] = { + identity = identity, + names = list_copy(registration.names), + options = copy(registration.options), + active = registration.active, + } + end + return result +end + +function MemoryHost:register_action(name, callback) + if type(name) ~= "string" or name == "" then + error("action name must be a nonempty string", 2) + end + if type(callback) ~= "function" then + error("action callback must be a function", 2) + end + if self._actions[name] ~= nil then + error("action is already registered", 2) + end + self._actions[name] = callback + self:_record("register_action", { name = name }) + return name +end + +function MemoryHost:invoke_action(name, ...) + local callback = self._actions[name] + if callback == nil then + error("action is not registered", 2) + end + local arguments = { ... } + local argument_count = select("#", ...) + local token = self:begin_action_transition() + local results = { + pcall(function() + return callback(unpack_values(arguments, 1, argument_count)) + end), + } + self:commit_action_transition(token) + local succeeded = table.remove(results, 1) + if not succeeded then + error(results[1], 0) + end + return unpack_values(results) +end + +function MemoryHost:register_mapping(modes, lhs, action, options) + modes = normalize_modes(modes) + if type(lhs) ~= "string" or lhs == "" then + error("mapping lhs must be a nonempty string", 2) + end + if type(action) ~= "string" and type(action) ~= "function" then + error("mapping action must be an action name or function", 2) + end + local identity = self:_next_identity("mapping") + self._mappings[identity] = { + identity = identity, + modes = modes, + lhs = lhs, + action = action, + options = copy(options or {}), + } + self:_record("register_mapping", { + identity = identity, + modes = modes, + lhs = lhs, + action = type(action) == "string" and action or "<function>", + options = options or {}, + }) + return identity +end + +function MemoryHost:mappings() + return copy(self._mappings) +end + +function MemoryHost:register_dot_repeat(payload, callback) + if not domain.DotPayload.is(payload) then + error("dot-repeat payload must be a DotPayload", 2) + end + if callback ~= nil and type(callback) ~= "function" then + error("dot-repeat callback must be a function", 2) + end + self._dot_repeat = { + payload = payload, + callback = callback, + operator = self._pending_operator, + mode = self._mode, + } + self:_record("register_dot_repeat", { payload = payload:to_table() }) + return payload +end + +function MemoryHost:dot_repeat_payload() + return self._dot_repeat and self._dot_repeat.payload or nil +end + +function MemoryHost:replay_dot(count) + if self._dot_repeat == nil or self._dot_repeat.callback == nil then + error("dot repeat is not executable", 2) + end + self._pending_operator = self._dot_repeat.operator + self._mode = self._dot_repeat.mode + return self._dot_repeat.callback(self._dot_repeat.payload, domain.Count.new(count)) +end + +return M diff --git a/lua/clever_tee/text_topology.lua b/lua/clever_tee/text_topology.lua new file mode 100644 index 0000000..348af62 --- /dev/null +++ b/lua/clever_tee/text_topology.lua @@ -0,0 +1,1031 @@ +local domain = require("clever_tee.domain") + +local M = {} +local TextView = {} +local MatchStartBounds = {} +M.TextView = TextView +M.MatchStartBounds = MatchStartBounds + +local view_records = setmetatable({}, { __mode = "k" }) +local bounds_records = setmetatable({}, { __mode = "k" }) + +local function fail(message, level) + error(message, (level or 1) + 1) +end + +local function is_integer(value) + return type(value) == "number" + and value > -math.huge + and value < math.huge + and value == math.floor(value) +end + +local function require_nonempty_string(value, name) + if type(value) ~= "string" or value == "" then + fail((name or "value") .. " must be a nonempty string", 2) + end + return value +end + +local function canonical_encoding(encoding) + encoding = require_nonempty_string(encoding, "effective encoding"):lower() + encoding = encoding:gsub("_", "-") + + local aliases = { + ["utf8"] = "utf-8", + ["cp-932"] = "cp932", + ["932"] = "cp932", + ["windows-31j"] = "cp932", + ["eucjp"] = "euc-jp", + ["ujis"] = "euc-jp", + ["unix-jis"] = "euc-jp", + } + return aliases[encoding] or encoding +end + +M.normalize_encoding = canonical_encoding + +local function utf8_character_length(text, offset) + local first = text:byte(offset) + if first == nil then + return nil + end + if first < 0x80 then + return 1 + end + + local length + local minimum + if first >= 0xc2 and first <= 0xdf then + length = 2 + minimum = 0x80 + elseif first >= 0xe0 and first <= 0xef then + length = 3 + minimum = 0x800 + elseif first >= 0xf0 and first <= 0xf4 then + length = 4 + minimum = 0x10000 + else + fail("text contains an invalid UTF-8 character", 3) + end + + if offset + length - 1 > #text then + fail("text contains an incomplete UTF-8 character", 3) + end + + local codepoint = first % (2 ^ (8 - length - 1)) + for index = offset + 1, offset + length - 1 do + local byte = text:byte(index) + if byte < 0x80 or byte > 0xbf then + fail("text contains an invalid UTF-8 character", 3) + end + codepoint = codepoint * 0x40 + (byte - 0x80) + end + + if codepoint < minimum + or codepoint > 0x10ffff + or (codepoint >= 0xd800 and codepoint <= 0xdfff) + then + fail("text contains an invalid UTF-8 character", 3) + end + return length +end + +local function split_utf8_codepoints(text) + local characters = {} + local offset = 1 + while offset <= #text do + local length = utf8_character_length(text, offset) + characters[#characters + 1] = text:sub(offset, offset + length - 1) + offset = offset + length + end + return characters +end + +local function nvim_split_segment(segment, result) + if segment == "" then + return + end + if segment:find("[\128-\255]") == nil then + for index = 1, #segment do + result[#result + 1] = segment:sub(index, index) + end + return + end + + local offset = 0 + while offset < #segment do + local match = vim.fn.matchstrpos(segment, "\\m.", offset) + local character = match[1] + local first = match[2] + local following = match[3] + if first ~= offset or following <= first or character == "" then + fail("Nvim could not index an editor character", 3) + end + result[#result + 1] = character + offset = following + end +end + +local function default_split_editor_characters(text) + local runtime = rawget(_G, "vim") + if type(runtime) ~= "table" + or type(runtime.fn) ~= "table" + or type(runtime.fn.strchars) ~= "function" + or type(runtime.fn.byteidx) ~= "function" + then + return split_utf8_codepoints(text) + end + + local result = {} + local offset = 1 + while offset <= #text do + local nul = text:find("\0", offset, true) + local last = nul and (nul - 1) or #text + nvim_split_segment(text:sub(offset, last), result) + if nul == nil then + break + end + result[#result + 1] = "\0" + offset = nul + 1 + end + return result +end + +local function default_encode(text, encoding) + if encoding == "utf-8" then + return text + end + + local runtime = rawget(_G, "vim") + if type(runtime) ~= "table" or type(runtime.iconv) ~= "function" then + fail("text encoding conversion requires Nvim or an encoder", 3) + end + + local ok, encoded = pcall(runtime.iconv, text, "utf-8", encoding) + if not ok or encoded == nil then + fail("text could not be converted to " .. encoding, 3) + end + return encoded +end + +local function require_character_list(characters) + if type(characters) ~= "table" then + fail("editor character splitter must return a list", 3) + end + + local result = {} + local item_count = 0 + for key, character in pairs(characters) do + if not is_integer(key) or key < 1 or key > #characters then + fail("editor character splitter must return a list", 3) + end + if type(character) ~= "string" or character == "" then + fail("editor character splitter must return nonempty strings", 3) + end + result[key] = character + item_count = item_count + 1 + end + if item_count ~= #characters then + fail("editor character splitter must return a list", 3) + end + return result +end + +function M.split_editor_characters(text) + if type(text) ~= "string" then + fail("text to split must be a string", 2) + end + return require_character_list(default_split_editor_characters(text)) +end + +local function snapshot_value(text) + if domain.TextSnapshot.is(text) then + return text + end + if type(text) == "table" and text.lines ~= nil then + text = text.lines + end + return domain.TextSnapshot.new(text) +end + +local function require_options(options) + if options == nil then + return {} + end + if type(options) == "function" then + return { encoder = options } + end + if type(options) ~= "table" then + fail("TextView options must be a table", 2) + end + return options +end + +local function selected_function(options, primary, alternate, fallback) + local value = options[primary] + if value == nil and alternate ~= nil then + value = options[alternate] + end + if value == nil then + return fallback + end + if type(value) ~= "function" then + fail("TextView " .. primary .. " must be a function", 3) + end + return value +end + +local function index_line(text, encoding, splitter, encoder) + if text:find("\n", 1, true) ~= nil then + fail("a text snapshot line must not contain a newline", 3) + end + + local characters = require_character_list(splitter(text)) + if table.concat(characters) ~= text then + fail("editor character splitter must preserve the complete line", 3) + end + + local entries = {} + local starts = {} + local by_start = {} + local encoded_parts = {} + local next_column = 1 + + for index, character in ipairs(characters) do + local encoded = encoder(character, encoding) + if type(encoded) ~= "string" or encoded == "" then + fail("TextView encoder must return a nonempty byte string", 3) + end + + local byte_length = #encoded + local entry = { + character = character, + encoded = encoded, + byte_start = next_column, + byte_end = next_column + byte_length - 1, + byte_length = byte_length, + } + entries[index] = entry + starts[index] = next_column + by_start[next_column] = index + encoded_parts[index] = encoded + next_column = next_column + byte_length + end + + return { + text = text, + encoded = table.concat(encoded_parts), + entries = entries, + starts = starts, + by_start = by_start, + byte_length = next_column - 1, + character_count = #entries, + } +end + +local text_view_metatable = { + __index = function(view, key) + local method = TextView[key] + if method ~= nil then + return method + end + + local record = view_records[view] + if key == "encoding" or key == "effective_encoding" then + return record.encoding + end + if key == "requested_encoding" then + return record.requested_encoding + end + if key == "line_count" then + return record.snapshot.line_count + end + return nil + end, + __newindex = function() + fail("TextView values are immutable", 2) + end, + __tostring = function(view) + local record = view_records[view] + return "text-view:" .. record.encoding .. ":" .. tostring(record.snapshot.line_count) + end, + __metatable = "clever_tee.text_topology.TextView", +} + +function TextView.new(text, effective_encoding, options) + if TextView.is(text) and effective_encoding == nil and options == nil then + return text + end + + local snapshot = snapshot_value(text) + local requested_encoding = require_nonempty_string( + effective_encoding, + "effective encoding" + ) + local encoding = canonical_encoding(requested_encoding) + options = require_options(options) + local splitter = selected_function( + options, + "splitter", + "split_editor_characters", + default_split_editor_characters + ) + local encoder = selected_function(options, "encoder", "encode", default_encode) + + local view = setmetatable({}, text_view_metatable) + view_records[view] = { + snapshot = snapshot, + requested_encoding = requested_encoding, + encoding = encoding, + splitter = splitter, + encoder = encoder, + lines = {}, + } + return view +end + +function TextView.from_host(host, options) + if type(host) ~= "table" + or type(host.read_text) ~= "function" + or type(host.read_encoding) ~= "function" + then + fail("TextView host must provide read_text and read_encoding", 2) + end + local text = host:read_text() + local encoding = host:read_encoding() + return TextView.new(text, encoding, options) +end + +function TextView.is(value) + return type(value) == "table" and view_records[value] ~= nil +end + +local function view_record(view) + if not TextView.is(view) then + fail("value must be a TextView", 3) + end + return view_records[view] +end + +local function line_record(view, line_number) + local record = view_record(view) + if not is_integer(line_number) + or line_number < 1 + or line_number > record.snapshot.line_count + then + fail("line_number must identify a line in the TextView", 3) + end + local line = record.lines[line_number] + if line == nil then + line = index_line( + record.snapshot:line(line_number), + record.encoding, + record.splitter, + record.encoder + ) + record.lines[line_number] = line + end + return line +end + +local function require_character_index(line, character_index) + if not is_integer(character_index) + or character_index < 1 + or character_index > line.character_count + then + fail("character_index must identify an editor character", 3) + end + return character_index +end + +local function require_byte_column(byte_column) + if not is_integer(byte_column) or byte_column < 1 then + fail("byte_column must be a positive one-based integer", 3) + end + return byte_column +end + +local function position_arguments(position_or_line, byte_column, name) + if byte_column == nil then + local position = domain.Position.coerce(position_or_line) + return position.line, position.byte_column + end + if not is_integer(position_or_line) or position_or_line < 1 then + fail((name or "line_number") .. " must be a positive integer", 3) + end + return position_or_line, require_byte_column(byte_column) +end + +function TextView:text_snapshot() + return view_record(self).snapshot +end + +function TextView:line_text(line_number) + return line_record(self, line_number).text +end + +function TextView:line_encoded_text(line_number) + return line_record(self, line_number).encoded +end + +function TextView:text_suffix(position) + position = domain.Position.coerce(position) + local record = view_record(self) + local line = line_record(self, position.line) + local character_index = self:character_index_for_byte_column( + position.line, + position.byte_column + ) + local parts = {} + + for index = character_index, line.character_count do + parts[#parts + 1] = line.entries[index].character + end + for line_number = position.line + 1, record.snapshot.line_count do + parts[#parts + 1] = "\n" + parts[#parts + 1] = record.snapshot:line(line_number) + end + return table.concat(parts) +end + +function TextView:line_byte_length(line_number) + return line_record(self, line_number).byte_length +end + +function TextView:line_character_count(line_number) + return line_record(self, line_number).character_count +end + +function TextView:line_is_empty(line_number) + return self:line_character_count(line_number) == 0 +end + +function TextView:character_at_index(line_number, character_index) + local line = line_record(self, line_number) + require_character_index(line, character_index) + return line.entries[character_index].character +end + +function TextView:encoded_character_at_index(line_number, character_index) + local line = line_record(self, line_number) + require_character_index(line, character_index) + return line.entries[character_index].encoded +end + +function TextView:byte_column_for_character_index(line_number, character_index) + local line = line_record(self, line_number) + require_character_index(line, character_index) + return line.starts[character_index] +end + +function TextView:position_for_character_index(line_number, character_index) + return domain.Position.new( + line_number, + self:byte_column_for_character_index(line_number, character_index) + ) +end + +function TextView:try_character_index_for_byte_column(line_number, byte_column) + local line = line_record(self, line_number) + require_byte_column(byte_column) + return line.by_start[byte_column] +end + +function TextView:character_index_for_byte_column(line_number, byte_column) + local line = line_record(self, line_number) + require_byte_column(byte_column) + local character_index = line.by_start[byte_column] + if character_index == nil then + if byte_column <= line.byte_length then + fail("byte_column points inside an editor character", 2) + end + fail("byte_column does not identify an editor character", 2) + end + return character_index +end + +function TextView:character_index_for_position(position) + position = domain.Position.coerce(position) + return self:character_index_for_byte_column(position.line, position.byte_column) +end + +local function copy_span(line_number, character_index, entry) + local position = domain.Position.new(line_number, entry.byte_start) + return { + line = line_number, + character_index = character_index, + character = entry.character, + encoded = entry.encoded, + position = position, + byte_column = entry.byte_start, + byte_start = entry.byte_start, + byte_end = entry.byte_end, + start_byte_column = entry.byte_start, + end_byte_column = entry.byte_end, + byte_length = entry.byte_length, + } +end + +function TextView:byte_span_for_character_index(line_number, character_index) + local line = line_record(self, line_number) + require_character_index(line, character_index) + return copy_span(line_number, character_index, line.entries[character_index]) +end + +function TextView:byte_span_at(position_or_line, byte_column) + local line_number, column = position_arguments(position_or_line, byte_column) + local character_index = self:character_index_for_byte_column(line_number, column) + return self:byte_span_for_character_index(line_number, character_index) +end + +function TextView:character_at(position_or_line, byte_column) + local line_number, column = position_arguments(position_or_line, byte_column) + local character_index = self:character_index_for_byte_column(line_number, column) + return self:character_at_index(line_number, character_index) +end + +function TextView:is_character_start(position_or_line, byte_column) + local line_number, column = position_arguments(position_or_line, byte_column) + local record = view_record(self) + if line_number > record.snapshot.line_count then + return false + end + return line_record(self, line_number).by_start[column] ~= nil +end + +function TextView:is_valid_cursor_position(position_or_line, byte_column) + local line_number, column = position_arguments(position_or_line, byte_column) + local record = view_record(self) + if line_number > record.snapshot.line_count then + return false + end + local line = line_record(self, line_number) + if line.character_count == 0 then + return column == 1 + end + return line.by_start[column] ~= nil +end + +local function containing_character_index(line, byte_column) + for index = 1, line.character_count do + local entry = line.entries[index] + if byte_column >= entry.byte_start and byte_column <= entry.byte_end then + return index + end + end + return nil +end + +function TextView:normalize_endpoint(position_or_line, byte_column) + local line_number, column = position_arguments(position_or_line, byte_column) + local line = line_record(self, line_number) + if line.character_count == 0 then + return domain.Position.new(line_number, 1) + end + + if column > line.byte_length then + return self:position_for_character_index(line_number, line.character_count) + end + + local character_index = line.by_start[column] + or containing_character_index(line, column) + return self:position_for_character_index(line_number, character_index) +end + +local function first_cursor_position(view, line_number) + local line = line_record(view, line_number) + if line.character_count == 0 then + return domain.Position.new(line_number, 1) + end + return view:position_for_character_index(line_number, 1) +end + +local function last_cursor_position(view, line_number) + local line = line_record(view, line_number) + if line.character_count == 0 then + return domain.Position.new(line_number, 1) + end + return view:position_for_character_index(line_number, line.character_count) +end + +function TextView:first_cursor_position(line_number) + return first_cursor_position(self, line_number) +end + +function TextView:last_cursor_position(line_number) + return last_cursor_position(self, line_number) +end + +function TextView:predecessor(position) + position = domain.Position.coerce(position) + local line = line_record(self, position.line) + + if line.character_count > 0 then + local character_index = self:character_index_for_byte_column( + position.line, + position.byte_column + ) + if character_index > 1 then + return self:position_for_character_index(position.line, character_index - 1) + end + elseif position.byte_column ~= 1 then + fail("an empty line cursor position must use byte column one", 2) + end + + if position.line == 1 then + return nil + end + return last_cursor_position(self, position.line - 1) +end + +function TextView:successor(position) + position = domain.Position.coerce(position) + local record = view_record(self) + local line = line_record(self, position.line) + + if line.character_count > 0 then + local character_index = self:character_index_for_byte_column( + position.line, + position.byte_column + ) + if character_index < line.character_count then + return self:position_for_character_index(position.line, character_index + 1) + end + elseif position.byte_column ~= 1 then + fail("an empty line cursor position must use byte column one", 2) + end + + if position.line == record.snapshot.line_count then + return nil + end + return first_cursor_position(self, position.line + 1) +end + +local bounds_metatable = { + __index = function(bounds, key) + local method = MatchStartBounds[key] + if method ~= nil then + return method + end + return bounds_records[bounds][key] + end, + __newindex = function() + fail("MatchStartBounds values are immutable", 2) + end, + __tostring = function(bounds) + local record = bounds_records[bounds] + if record.empty then + return "match-start-bounds:empty" + end + return "match-start-bounds:" .. tostring(record.first) .. ":" .. tostring(record.last) + end, + __metatable = "clever_tee.text_topology.MatchStartBounds", +} + +local function new_bounds(scope, first_line, last_line, first, last) + local bounds = setmetatable({}, bounds_metatable) + bounds_records[bounds] = { + scope = scope, + first_line = first_line, + last_line = last_line, + first = first, + last = last, + start = first, + finish = last, + empty = first == nil, + } + return bounds +end + +function MatchStartBounds.is(value) + return type(value) == "table" and bounds_records[value] ~= nil +end + +function MatchStartBounds:is_empty() + return bounds_records[self].empty +end + +function MatchStartBounds:contains(position) + position = domain.Position.coerce(position) + local record = bounds_records[self] + if record.empty then + return false + end + return domain.Position.compare(position, record.first) >= 0 + and domain.Position.compare(position, record.last) <= 0 +end + +function MatchStartBounds:to_table() + local record = bounds_records[self] + return { + scope = record.scope.value, + first_line = record.first_line, + last_line = record.last_line, + first = record.first and record.first:to_table() or nil, + last = record.last and record.last:to_table() or nil, + empty = record.empty, + } +end + +function TextView:line_match_start_bounds(line_number) + local line = line_record(self, line_number) + local first + local last + if line.character_count > 0 then + first = self:position_for_character_index(line_number, 1) + last = self:position_for_character_index(line_number, line.character_count) + end + return new_bounds( + domain.SearchScope.CURRENT_LINE, + line_number, + line_number, + first, + last + ) +end + +function TextView:buffer_match_start_bounds() + local record = view_record(self) + local first + local last + + for line_number = 1, record.snapshot.line_count do + local line = line_record(self, line_number) + if line.character_count > 0 then + first = self:position_for_character_index(line_number, 1) + break + end + end + + for line_number = record.snapshot.line_count, 1, -1 do + local line = line_record(self, line_number) + if line.character_count > 0 then + last = self:position_for_character_index(line_number, line.character_count) + break + end + end + + return new_bounds( + domain.SearchScope.BUFFER, + 1, + record.snapshot.line_count, + first, + last + ) +end + +local function scope_value(scope) + if scope == nil then + return domain.SearchScope.BUFFER + end + if scope == "line" then + return domain.SearchScope.CURRENT_LINE + end + return domain.SearchScope.from_string(scope) +end + +function TextView:match_start_bounds(scope, origin) + if domain.Position.is(scope) + or type(scope) == "number" + or (type(scope) == "table" and scope.line ~= nil) + then + scope, origin = origin, scope + end + + scope = scope_value(scope) + if scope == domain.SearchScope.BUFFER then + return self:buffer_match_start_bounds() + end + + if origin == nil then + fail("current-line match bounds require an origin line", 2) + end + local line_number = type(origin) == "number" + and origin + or domain.Position.coerce(origin).line + return self:line_match_start_bounds(line_number) +end + +local function empty_iterator() + return nil +end + +local function iteration_endpoint(view, position, name) + position = domain.Position.coerce(position) + if not view:is_character_start(position) then + fail((name or "iterator endpoint") .. " must start an editor character", 3) + end + return position +end + +local function step_character(view, position, direction) + local record = view_record(view) + local line = line_record(view, position.line) + local character_index = line.by_start[position.byte_column] + + if direction == domain.Direction.FORWARD then + if character_index < line.character_count then + return view:position_for_character_index(position.line, character_index + 1) + end + for line_number = position.line + 1, record.snapshot.line_count do + if line_record(view, line_number).character_count > 0 then + return view:position_for_character_index(line_number, 1) + end + end + return nil + end + + if character_index > 1 then + return view:position_for_character_index(position.line, character_index - 1) + end + for line_number = position.line - 1, 1, -1 do + local previous_line = line_record(view, line_number) + if previous_line.character_count > 0 then + return view:position_for_character_index( + line_number, + previous_line.character_count + ) + end + end + return nil +end + +local function position_iterator(view, direction, start_position, boundary) + if start_position == nil then + return empty_iterator + end + + start_position = iteration_endpoint(view, start_position, "iterator start") + boundary = iteration_endpoint(view, boundary, "iterator boundary") + local comparison = domain.Position.compare(start_position, boundary) + if direction == domain.Direction.FORWARD and comparison > 0 then + fail("a forward iterator start must not follow its boundary", 3) + end + if direction == domain.Direction.BACKWARD and comparison < 0 then + fail("a backward iterator start must not precede its boundary", 3) + end + + local current = start_position + local finished = false + return function() + if finished then + return nil + end + + local position = current + local character_index = view:character_index_for_position(position) + local character = view:character_at_index(position.line, character_index) + local span = view:byte_span_for_character_index(position.line, character_index) + + if position == boundary then + finished = true + else + current = step_character(view, position, direction) + if current == nil then + fail("iterator reached the text boundary before its selected boundary", 2) + end + end + return position, character, span + end +end + +local function iteration_arguments(view, direction, first, second) + if MatchStartBounds.is(first) then + local record = bounds_records[first] + if record.empty then + return nil, nil + end + if direction == domain.Direction.FORWARD then + return record.first, record.last + end + return record.last, record.first + end + + if type(first) == "number" and second == nil then + local bounds = view:line_match_start_bounds(first) + return iteration_arguments(view, direction, bounds) + end + + if first == nil then + local bounds = view:buffer_match_start_bounds() + return iteration_arguments(view, direction, bounds) + end + + first = domain.Position.coerce(first) + if second ~= nil then + return first, domain.Position.coerce(second) + end + + local bounds = view:buffer_match_start_bounds() + if bounds.empty then + return nil, nil + end + return first, direction == domain.Direction.FORWARD and bounds.last or bounds.first +end + +function TextView:iterate(direction, first, second) + direction = domain.Direction.from_string(direction) + local start_position, boundary = iteration_arguments(self, direction, first, second) + return position_iterator(self, direction, start_position, boundary) +end + +function TextView:iter_forward(first, boundary) + return self:iterate(domain.Direction.FORWARD, first, boundary) +end + +function TextView:iter_backward(first, boundary) + return self:iterate(domain.Direction.BACKWARD, first, boundary) +end + +function TextView:iter_line_forward(line_number) + return self:iter_forward(self:line_match_start_bounds(line_number)) +end + +function TextView:iter_line_backward(line_number) + return self:iter_backward(self:line_match_start_bounds(line_number)) +end + +function TextView:iter_buffer_forward() + return self:iter_forward(self:buffer_match_start_bounds()) +end + +function TextView:iter_buffer_backward() + return self:iter_backward(self:buffer_match_start_bounds()) +end + +local function strict_scope_bounds(view, origin, scope_or_bounds) + if MatchStartBounds.is(scope_or_bounds) then + return scope_or_bounds + end + local scope = scope_value(scope_or_bounds) + return view:match_start_bounds(scope, origin) +end + +function TextView:iter_strict(origin, direction, scope_or_bounds) + origin = domain.Position.coerce(origin) + line_record(self, origin.line) + if not self:is_valid_cursor_position(origin) then + fail("strict iterator origin must be a valid editor cursor position", 2) + end + + direction = domain.Direction.from_string(direction) + local bounds = strict_scope_bounds(self, origin, scope_or_bounds) + local candidates = self:iterate(direction, bounds) + + return function() + while true do + local position, character, span = candidates() + if position == nil then + return nil + end + local comparison = domain.Position.compare(position, origin) + if (direction == domain.Direction.FORWARD and comparison > 0) + or (direction == domain.Direction.BACKWARD and comparison < 0) + then + return position, character, span + end + end + end +end + +function TextView:iter_strict_forward(origin, scope_or_bounds) + return self:iter_strict(origin, domain.Direction.FORWARD, scope_or_bounds) +end + +function TextView:iter_strict_backward(origin, scope_or_bounds) + return self:iter_strict(origin, domain.Direction.BACKWARD, scope_or_bounds) +end + +TextView.character_index_to_byte_column = TextView.byte_column_for_character_index +TextView.byte_column_to_character_index = TextView.character_index_for_byte_column +TextView.character_count = TextView.line_character_count +TextView.byte_length = TextView.line_byte_length +TextView.text_from = TextView.text_suffix +TextView.suffix_from = TextView.text_suffix +TextView.character_span = TextView.byte_span_for_character_index +TextView.predecessor_endpoint = TextView.predecessor +TextView.successor_endpoint = TextView.successor +TextView.normalize_boundary_endpoint = TextView.normalize_endpoint +TextView.bounds_for_line = TextView.line_match_start_bounds +TextView.bounds_for_buffer = TextView.buffer_match_start_bounds +TextView.iterate_forward = TextView.iter_forward +TextView.iterate_backward = TextView.iter_backward +TextView.forward = TextView.iter_forward +TextView.backward = TextView.iter_backward +TextView.strict_forward = TextView.iter_strict_forward +TextView.strict_backward = TextView.iter_strict_backward + +function M.new(text, effective_encoding, options) + return TextView.new(text, effective_encoding, options) +end + +function M.from_host(host, options) + return TextView.from_host(host, options) +end + +M.build = M.new +M.build_from_host = M.from_host +M.is = TextView.is + +return M |