Rename plugin to clever-tee

1 files changed, 0 insertions, 493 deletions

diff --git a/lua/clever_f/state_transitions.lua b/lua/clever_f/state_transitions.lua
deleted file mode 100644
index 426bddb..0000000
--- a/lua/clever_f/state_transitions.lua
+++ /dev/null
@@ -1,493 +0,0 @@
-local domain = require("clever_f.domain")
-local sequence_state = require("clever_f.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 = "CleverFChar",
-    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 "CleverFCursor"
-  if group ~= "CleverFCursor" and group ~= "CleverFDirect" then
-    fail("temporary overlay group must be CleverFCursor or CleverFDirect", 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