refactor(actions): simplify and improve navigate_buf_mark

Rewrite navigate_buf_mark to collect all marks into a sorted list then
do a single linear scan, eliminating duplicated closure logic and
redundant getmarklist() calls.

Additional behavioural improvements:
- wrap now defaults to true (opt out with wrap = false)
- Navigation is now column-aware: multiple marks on the same line are
  visited in column order instead of being skipped
- Fix off-by-one: getmarklist() returns 1-indexed columns but
  nvim_win_set_cursor expects 0-indexed, so subtract 1 from pos[3]

Tests updated to assert full {line, col} cursor positions, add a new
case for same-line mark navigation, and reflect the new wrap default.

Author: dimtion

lua/guttermarks/actions.lua

@@ -93,81 +93,61 @@ local function navigate_buf_mark(direction, opts)
   opts = opts or {}
   local local_mark = opts.local_mark ~= false
   local global_mark = opts.global_mark ~= false
-  local wrap = opts.wrap == true
+  local wrap = opts.wrap ~= false
 
   local bufnr = vim.api.nvim_get_current_buf()
-  local current_line = vim.api.nvim_win_get_cursor(0)[1]
+  local cursor = vim.api.nvim_win_get_cursor(0)
+  local current_line = cursor[1]
+  local current_col = cursor[2]
 
-  local target_mark = nil
-  local compare_fn = direction == "forward" and function(mark_line)
-    return mark_line > current_line
-  end or function(mark_line)
-    return mark_line < current_line
-  end
-
-  local select_fn = direction == "forward"
-      and function(new_mark, current_best)
-        return not current_best or new_mark.line < current_best.line
-      end
-    or function(new_mark, current_best)
-      return not current_best or new_mark.line > current_best.line
-    end
+  -- Collect all relevant marks into one list
+  local all_marks = {}
 
-  -- Check local marks
   if local_mark then
     for _, m in ipairs(vim.fn.getmarklist(bufnr)) do
-      if m.mark:match("^'[a-z]") and compare_fn(m.pos[2]) then
-        local mark_data = { line = m.pos[2], col = m.pos[3], mark = m.mark:sub(2) }
-        if select_fn(mark_data, target_mark) then
-          target_mark = mark_data
-        end
+      if m.mark:match("^'[a-z]") then
+        table.insert(all_marks, { line = m.pos[2], col = m.pos[3] - 1, mark = m.mark:sub(2) })
       end
     end
   end
 
-  -- Check global marks
   if global_mark then
     for _, m in ipairs(vim.fn.getmarklist()) do
-      if m.pos[1] == bufnr and m.mark:match("^'[A-Z]") and compare_fn(m.pos[2]) then
-        local mark_data = { line = m.pos[2], col = m.pos[3], mark = m.mark:sub(2) }
-        if select_fn(mark_data, target_mark) then
-          target_mark = mark_data
-        end
+      if m.pos[1] == bufnr and m.mark:match("^'[A-Z]") then
+        table.insert(all_marks, { line = m.pos[2], col = m.pos[3] - 1, mark = m.mark:sub(2) })
       end
     end
   end
 
-  -- Wrap around: find the first/last mark in the buffer when no mark in direction
-  if not target_mark and wrap then
-    local wrap_select_fn = direction == "forward"
-        and function(new_mark, current_best)
-          return not current_best or new_mark.line < current_best.line
-        end
-      or function(new_mark, current_best)
-        return not current_best or new_mark.line > current_best.line
-      end
+  table.sort(all_marks, function(a, b)
+    if a.line ~= b.line then
+      return a.line < b.line
+    end
+    return a.col < b.col
+  end)
 
-    if local_mark then
-      for _, m in ipairs(vim.fn.getmarklist(bufnr)) do
-        if m.mark:match("^'[a-z]") then
-          local mark_data = { line = m.pos[2], col = m.pos[3], mark = m.mark:sub(2) }
-          if wrap_select_fn(mark_data, target_mark) then
-            target_mark = mark_data
-          end
-        end
+  -- Scan sorted list for the nearest mark in the requested direction
+  local target_mark = nil
+  if direction == "forward" then
+    for _, m in ipairs(all_marks) do
+      if m.line > current_line or (m.line == current_line and m.col > current_col) then
+        target_mark = m
+        break
       end
     end
-
-    if global_mark then
-      for _, m in ipairs(vim.fn.getmarklist()) do
-        if m.pos[1] == bufnr and m.mark:match("^'[A-Z]") then
-          local mark_data = { line = m.pos[2], col = m.pos[3], mark = m.mark:sub(2) }
-          if wrap_select_fn(mark_data, target_mark) then
-            target_mark = mark_data
-          end
-        end
+    if not target_mark and wrap then
+      target_mark = all_marks[1]
+    end
+  else
+    for i = #all_marks, 1, -1 do
+      if all_marks[i].line < current_line or (all_marks[i].line == current_line and all_marks[i].col < current_col) then
+        target_mark = all_marks[i]
+        break
       end
     end
+    if not target_mark and wrap then
+      target_mark = all_marks[#all_marks]
+    end
   end
 
   if target_mark then

test/test_action_navigation.lua

@@ -24,20 +24,21 @@ T["prev_buf_mark"] = MiniTest.new_set()
 
 T["next_buf_mark"]["navigates forward"] = function()
   new_buf()
-  child.type_keys({ "gg", "ma", "j", "mb", "j", "mc", "gg" })
+  -- marks on lines 2 and 3; cursor starts at line 1 so no same-line ambiguity
+  child.type_keys({ "gg", "0", "j", "0", "llll", "ma", "j", "0", "l", "mb", "gg", "0" })
 
   child.lua([[ M.next_buf_mark() ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 2)
+  eq(child.api.nvim_win_get_cursor(0), { 2, 4 })
 
   child.lua([[ M.next_buf_mark() ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 3)
+  eq(child.api.nvim_win_get_cursor(0), { 3, 1 })
 end
 
 T["next_buf_mark"]["no marks ahead"] = function()
   new_buf()
   child.type_keys({ "gg", "ma", "j" })
 
-  child.lua([[ M.next_buf_mark() ]])
+  child.lua([[ M.next_buf_mark({ wrap = false }) ]])
   eq(child.api.nvim_win_get_cursor(0)[1], 2)
 end
 
@@ -51,24 +52,25 @@ end
 
 T["next_buf_mark"]["skips global marks with opts"] = function()
   new_buf()
-  child.type_keys({ "gg", "ma", "j", "mb", "j", "mC", "j", "md", "gg" })
+  -- marks on lines 2-4; cursor starts at line 1 so no same-line ambiguity
+  child.type_keys({ "gg", "0", "j", "0", "lll", "ma", "j", "0", "mC", "j", "0", "l", "mb", "gg", "0" })
 
   child.lua([[ M.next_buf_mark({ global_mark = false }) ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 2)
+  eq(child.api.nvim_win_get_cursor(0), { 2, 3 })
 
   child.lua([[ M.next_buf_mark({ global_mark = false }) ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 4)
+  eq(child.api.nvim_win_get_cursor(0), { 4, 1 })
 end
 
 T["prev_buf_mark"]["navigates backward"] = function()
   new_buf()
-  child.type_keys({ "gg", "ma", "j", "mb", "j", "mc", "G" })
+  child.type_keys({ "gg", "ll", "ma", "j", "0", "llll", "mb", "j", "0", "l", "mc", "G" })
 
   child.lua([[ M.prev_buf_mark() ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 3)
+  eq(child.api.nvim_win_get_cursor(0), { 3, 1 })
 
   child.lua([[ M.prev_buf_mark() ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 2)
+  eq(child.api.nvim_win_get_cursor(0), { 2, 4 })
 end
 
 T["prev_buf_mark"]["no marks behind"] = function()
@@ -89,40 +91,58 @@ end
 
 T["prev_buf_mark"]["skips local marks with opts"] = function()
   new_buf()
-  child.type_keys({ "gg", "ma", "jj", "mB", "jj", "mc", "G" })
+  child.type_keys({ "gg", "ll", "ma", "jj", "0", "lll", "mB", "jj", "0", "l", "mc", "G" })
 
   child.lua([[ M.prev_buf_mark({ local_mark = false }) ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 3)
+  eq(child.api.nvim_win_get_cursor(0), { 3, 3 })
+end
+
+T["Multiple marks on the same line"] = function()
+  new_buf()
+  -- mark a at line 2 col 1, mark b at line 2 col 3
+  child.type_keys({ "gg", "0", "j", "0", "l", "ma", "ll", "mb", "gg", "0" })
+
+  child.lua([[ M.next_buf_mark() ]])
+  eq(child.api.nvim_win_get_cursor(0), { 2, 1 })
+
+  child.lua([[ M.next_buf_mark() ]])
+  eq(child.api.nvim_win_get_cursor(0), { 2, 3 })
+
+  -- navigate backward through same-line marks
+  child.lua([[ M.prev_buf_mark() ]])
+  eq(child.api.nvim_win_get_cursor(0), { 2, 1 })
 end
 
 T["Mixed local and global marks"] = function()
   new_buf()
-  child.type_keys({ "gg", "ma", "j", "mB", "j", "mc", "gg" })
+  -- mark a at cursor start position so it is not "ahead"; B and c are on later lines
+  child.type_keys({ "gg", "0", "ma", "j", "0", "lll", "mB", "j", "0", "l", "mc", "gg", "0" })
 
   child.lua([[ M.next_buf_mark() ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 2)
+  eq(child.api.nvim_win_get_cursor(0), { 2, 3 })
 
   child.lua([[ M.next_buf_mark() ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 3)
+  eq(child.api.nvim_win_get_cursor(0), { 3, 1 })
 end
 
 T["next_buf_mark wrap"] = MiniTest.new_set()
 T["prev_buf_mark wrap"] = MiniTest.new_set()
 
 T["next_buf_mark wrap"]["wraps from last mark to first"] = function()
   new_buf()
-  child.type_keys({ "gg", "ma", "j", "mb", "j", "mc", "G" })
+  child.type_keys({ "gg", "0", "ll", "ma", "j", "0", "mb", "j", "0", "mc", "jj" })
 
   child.lua([[ M.next_buf_mark({ wrap = true }) ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 1)
+  eq(child.api.nvim_win_get_cursor(0), { 1, 2 })
 end
 
 T["next_buf_mark wrap"]["does not wrap when mark found ahead"] = function()
   new_buf()
-  child.type_keys({ "gg", "ma", "j", "mb", "gg" })
+  -- mark a at col 0, cursor ends at col 3 after gg (preserved), so a is behind
+  child.type_keys({ "gg", "0", "ma", "j", "0", "lll", "mb", "gg" })
 
   child.lua([[ M.next_buf_mark({ wrap = true }) ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 2)
+  eq(child.api.nvim_win_get_cursor(0), { 2, 3 })
 end
 
 T["next_buf_mark wrap"]["no marks present stays put"] = function()
@@ -137,24 +157,24 @@ T["next_buf_mark wrap"]["no wrap without opt"] = function()
   new_buf()
   child.type_keys({ "gg", "ma", "j", "mb", "G" })
 
-  child.lua([[ M.next_buf_mark() ]])
+  child.lua([[ M.next_buf_mark({ wrap = false }) ]])
   eq(child.api.nvim_win_get_cursor(0)[1], 5)
 end
 
 T["prev_buf_mark wrap"]["wraps from first mark to last"] = function()
   new_buf()
-  child.type_keys({ "gg", "ma", "j", "mb", "j", "mc", "gg" })
+  child.type_keys({ "gg", "ma", "j", "0", "mb", "j", "0", "l", "mc", "gg" })
 
   child.lua([[ M.prev_buf_mark({ wrap = true }) ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 3)
+  eq(child.api.nvim_win_get_cursor(0), { 3, 1 })
 end
 
 T["prev_buf_mark wrap"]["does not wrap when mark found behind"] = function()
   new_buf()
-  child.type_keys({ "gg", "ma", "j", "mb", "G" })
+  child.type_keys({ "gg", "ma", "j", "0", "lll", "mb", "G" })
 
   child.lua([[ M.prev_buf_mark({ wrap = true }) ]])
-  eq(child.api.nvim_win_get_cursor(0)[1], 2)
+  eq(child.api.nvim_win_get_cursor(0), { 2, 3 })
 end
 
 T["prev_buf_mark wrap"]["no marks present stays put"] = function()
@@ -169,7 +189,7 @@ T["prev_buf_mark wrap"]["no wrap without opt"] = function()
   new_buf()
   child.type_keys({ "gg", "ma", "j", "mb", "gg" })
 
-  child.lua([[ M.prev_buf_mark() ]])
+  child.lua([[ M.prev_buf_mark({ wrap = false }) ]])
   eq(child.api.nvim_win_get_cursor(0)[1], 1)
 end