Refactor direction

lua/gesture/core/direction_input.lua

@@ -0,0 +1,48 @@
+local Directions = require("gesture.core.directions")
+local UP = Directions.UP
+local DOWN = Directions.DOWN
+local RIGHT = Directions.RIGHT
+local LEFT = Directions.LEFT
+
+local DirectionInput = {}
+
+function DirectionInput.new(direction, length)
+  vim.validate({
+    direction = { direction, "string" },
+    length = { length, "number" },
+  })
+  return {
+    direction = direction,
+    length = length,
+  }
+end
+
+function DirectionInput.from_points(p1, p2)
+  local diff_x = p2.x - p1.x
+  local length_x = math.abs(diff_x)
+
+  local diff_y = p2.y - p1.y
+  local length_y = math.abs(diff_y)
+
+  local direction, length
+  if length_x > length_y then
+    direction = diff_x > 0 and RIGHT or LEFT
+    length = length_x
+  elseif length_y >= length_x and length_y > 0 then
+    direction = diff_y > 0 and DOWN or UP
+    length = length_y
+  else
+    return nil
+  end
+
+  return DirectionInput.new(direction, length)
+end
+
+function DirectionInput.is_short(input, length_thresholds)
+  if input.direction == UP or input.direction == DOWN then
+    return input.length < length_thresholds.y
+  end
+  return input.length < length_thresholds.x
+end
+
+return DirectionInput

lua/gesture/core/direction_input_definition.lua

@@ -0,0 +1,59 @@
+local DirectionInputDefinition = {}
+DirectionInputDefinition.__index = DirectionInputDefinition
+
+local new = function(value, opts)
+  vim.validate({
+    typ = { value, "string" },
+    opts = { opts, "table", true },
+  })
+
+  opts = opts or {}
+
+  vim.validate({
+    max_length = { opts.max_length, "number", true },
+    min_length = { opts.min_length, "number", true },
+  })
+
+  local tbl = {
+    value = value,
+    max_length = opts.max_length,
+    min_length = opts.min_length,
+  }
+  return setmetatable(tbl, DirectionInputDefinition)
+end
+
+local Directions = require("gesture.core.directions")
+
+function DirectionInputDefinition.up(opts)
+  return new(Directions.UP, opts)
+end
+
+function DirectionInputDefinition.down(opts)
+  return new(Directions.DOWN, opts)
+end
+
+function DirectionInputDefinition.right(opts)
+  return new(Directions.RIGHT, opts)
+end
+
+function DirectionInputDefinition.left(opts)
+  return new(Directions.LEFT, opts)
+end
+
+function DirectionInputDefinition.equals(self, input_definition)
+  return self.value == input_definition.value
+    and self.max_length == input_definition.max_length
+    and self.min_length == input_definition.min_length
+end
+
+function DirectionInputDefinition.match(self, input)
+  if self.max_length and self.max_length < input.length then
+    return false
+  end
+  if self.min_length and self.min_length > input.length then
+    return false
+  end
+  return true
+end
+
+return DirectionInputDefinition

lua/gesture/core/directions.lua

@@ -0,0 +1,6 @@
+return {
+  UP = "UP",
+  DOWN = "DOWN",
+  RIGHT = "RIGHT",
+  LEFT = "LEFT",
+}

lua/gesture/core/input_definitions.lua

@@ -1,49 +1,49 @@
 local InputDefinitions = {}
 InputDefinitions.__index = InputDefinitions
 
-function InputDefinitions.new(defs)
-  vim.validate({ defs = { defs, "table" } })
+function InputDefinitions.new(raw_input_definitions)
+  vim.validate({ raw_input_definitions = { raw_input_definitions, "table" } })
   local tbl = {
-    _defs = defs,
+    _definitions = raw_input_definitions,
   }
   return setmetatable(tbl, InputDefinitions)
 end
 
 function InputDefinitions.match(self, inputs)
-  for i, def in ipairs(self._defs) do
+  for i, input_definition in ipairs(self._definitions) do
     local input = inputs[i]
     if not input then
       return false
     end
-    if not def:match(input) then
+    if not input_definition:match(input) then
       return false
     end
   end
   return true
 end
 
 function InputDefinitions.has_forward_match(self, inputs)
-  for i, def in ipairs(self._defs) do
+  for i, definition in ipairs(self._definitions) do
     local input = inputs[i]
     if not input then
       return true
     end
-    if not def:match(input) then
+    if not definition:match(input) then
       return false
     end
   end
   return true
 end
 
 function InputDefinitions.strings(self)
-  return vim.tbl_map(function(def)
-    return def.value
-  end, self._defs)
+  return vim.tbl_map(function(input_definition)
+    return input_definition.value
+  end, self._definitions)
 end
 
-function InputDefinitions.equals(self, input_defs)
-  for i, def in ipairs(self._defs) do
-    if not def:equals(input_defs._defs[i]) then
+function InputDefinitions.equals(self, nonself)
+  for i, definition in ipairs(self._definitions) do
+    if not definition:equals(nonself._definitions[i]) then
       return false
     end
   end

lua/gesture/core/inputs.lua

@@ -2,11 +2,7 @@ local vim = vim
 
 local M = {}
 
-function M.add_direction(inputs, direction, length, suspended)
-  local input = {
-    direction = direction,
-    length = length,
-  }
+function M.add_direction(inputs, input, suspended)
   local last = inputs[#inputs]
   if not last or last.direction ~= input.direction or suspended then
     table.insert(inputs, input)

lua/gesture/core/point.lua

@@ -1,36 +1,8 @@
-local Line = require("gesture.core.line")
 local listlib = require("gesture.lib.list")
 
-local Direction = require("gesture.core.direction")
-local UP = Direction.up().value
-local DOWN = Direction.down().value
-local RIGHT = Direction.right().value
-local LEFT = Direction.left().value
-
 local Point = {}
 Point.__index = Point
 
-function Point.line_to(self, point)
-  local diff_x = point.x - self.x
-  local length_x = math.abs(diff_x)
-
-  local diff_y = point.y - self.y
-  local length_y = math.abs(diff_y)
-
-  local direction, length
-  if length_x > length_y then
-    direction = diff_x > 0 and RIGHT or LEFT
-    length = length_x
-  elseif length_y >= length_x and length_y > 0 then
-    direction = diff_y > 0 and DOWN or UP
-    length = length_y
-  else
-    return nil
-  end
-
-  return Line.new(direction, length)
-end
-
 local Y = function(p1, p2)
   local b = (p1.x * p2.y - p2.x * p1.y) / (p1.x - p2.x)
   local a = (p1.y - b) / p1.x
@@ -98,7 +70,10 @@ function Point.interpolate(self, point)
 end
 
 function Point.new(x, y)
-  local tbl = { x = x, y = y }
+  local tbl = {
+    x = x,
+    y = y,
+  }
   return setmetatable(tbl, Point)
 end
 

lua/gesture/core/state.lua

@@ -1,6 +1,7 @@
 local _states = {}
 
 local Inputs = require("gesture.core.inputs")
+local DirectionInput = require("gesture.core.direction_input")
 local windowlib = require("gesture.lib.window")
 
 local State = {}
@@ -56,13 +57,13 @@ function State.update(self, length_thresholds)
     table.insert(self._window_ids, window_id)
   end
 
-  local line = self._last_point:line_to(point)
-  if not line or line:is_short(length_thresholds) then
+  local input = DirectionInput.from_points(self._last_point, point)
+  if not input or DirectionInput.is_short(input, length_thresholds) then
     return true
   end
 
   self._last_point = point
-  Inputs.add_direction(self._inputs, line.direction, line.length, self._suspended)
+  Inputs.add_direction(self._inputs, input, self._suspended)
   self._suspended = false
 
   return true

lua/gesture/init.lua

@@ -71,28 +71,28 @@ end
 --- @param opts GestureInputOption?: |GestureInputOption|
 --- @return GestureInputDefinition # used as an element of |GestureInfo|'s inputs
 function M.up(opts)
-  return require("gesture.core.direction").up(opts)
+  return require("gesture.core.direction_input_definition").up(opts)
 end
 
 --- Down input
 --- @param opts GestureInputOption?: |GestureInputOption|
 --- @return GestureInputDefinition # used as an element of |GestureInfo|'s inputs
 function M.down(opts)
-  return require("gesture.core.direction").down(opts)
+  return require("gesture.core.direction_input_definition").down(opts)
 end
 
 --- Right input
 --- @param opts GestureInputOption?: |GestureInputOption|
 --- @return GestureInputDefinition # used as an element of |GestureInfo|'s inputs
 function M.right(opts)
-  return require("gesture.core.direction").right(opts)
+  return require("gesture.core.direction_input_definition").right(opts)
 end
 
 --- Left input
 --- @param opts GestureInputOption?: |GestureInputOption|
 --- @return GestureInputDefinition # used as an element of |GestureInfo|'s inputs
 function M.left(opts)
-  return require("gesture.core.direction").left(opts)
+  return require("gesture.core.direction_input_definition").left(opts)
 end
 
 return M