feat(jump)!: make dot-repeat jumping less intefere with regular jumping

Resolve #2054

Co-authored-by: Evgeni Chasnovski <evgeni.chasnovski@gmail.com>

Author: abeldekat

CHANGELOG.md

@@ -34,6 +34,12 @@ There are following change types:
 - Add new plugin integrations:
     - 'folke/snacks.nvim'
 
+## mini.jump
+
+### Evolve
+
+- Make dot-repeat behave exactly as in clean Neovim, i.e. make it less interfere with regular jumping. This allows doing something like `dte` -> `fx` -> `.` to perform `dte` again and not `dfx` (which is the latest regular jumping state). By @abeldekat, PR #2284.
+
 ## mini.misc
 
 ### Evolve

doc/mini-jump.txt

@@ -14,8 +14,8 @@ Features:
 - Highlight (after customizable delay) all possible target characters and
   stop it after some (customizable) idle time.
 
-- Normal, Visual, and Operator-pending (with full dot-repeat) modes are
-  supported.
+- Normal, Visual, and Operator-pending (with dot-repeat as in clean Neovim)
+  modes are supported.
 
 This module follows vim's 'ignorecase' and 'smartcase' options. When
 'ignorecase' is set, f, F, t, T will match case-insensitively. When

lua/mini/jump.lua

@@ -12,8 +12,8 @@
 --- - Highlight (after customizable delay) all possible target characters and
 ---   stop it after some (customizable) idle time.
 ---
---- - Normal, Visual, and Operator-pending (with full dot-repeat) modes are
----   supported.
+--- - Normal, Visual, and Operator-pending (with dot-repeat as in clean Neovim)
+---   modes are supported.
 ---
 --- This module follows vim's 'ignorecase' and 'smartcase' options. When
 --- 'ignorecase' is set, f, F, t, T will match case-insensitively. When
@@ -181,6 +181,11 @@ MiniJump.state = {
 MiniJump.jump = function(target, backward, till, n_times)
   if H.is_disabled() then return end
 
+  -- Dot-repeat should not change the state, so save it to later restore
+  local is_dot_repeat = MiniJump._is_expr and not MiniJump._is_expr_init
+  MiniJump._is_expr, MiniJump._is_expr_init = nil, nil
+  local state_snapshot = is_dot_repeat and vim.deepcopy(MiniJump.state) or nil
+
   -- Cache inputs for future use
   H.update_state(target, backward, till, n_times)
 
@@ -230,6 +235,12 @@ MiniJump.jump = function(target, backward, till, n_times)
   -- Track cursor position to account for movement not caught by `CursorMoved`
   H.cache.latest_cursor = H.get_cursor_data()
   H.cache.has_changed_cursor = not vim.deep_equal(H.cache.latest_cursor, init_cursor_data)
+
+  -- Restore the state if needed
+  if is_dot_repeat then
+    state_snapshot.jumping = true
+    MiniJump.state = state_snapshot
+  end
 end
 
 --- Make smart jump
@@ -383,22 +394,29 @@ H.make_expr_jump = function(backward, till)
   return function()
     if H.is_disabled() then return '' end
 
-    H.update_state(nil, backward, till, vim.v.count1)
+    local count = vim.v.count1
+    H.update_state(nil, backward, till, count)
 
     -- Ask for `target` for non-repeating jump as this will be used only in
     -- operator-pending mode. Dot-repeat is supported via expression-mapping.
-    local is_repeat_jump = backward == nil or till == nil
-    local target = is_repeat_jump and MiniJump.state.target or H.get_target()
-
-    -- Stop if user supplied invalid target
-    if target == nil then return '<Esc>' end
+    local isnt_repeat_jump = backward ~= nil and till ~= nil
+    local target = isnt_repeat_jump and H.get_target() or nil
+    if isnt_repeat_jump and target == nil then return '<Esc>' end
     H.update_state(target)
 
     vim.schedule(function()
       if H.cache.has_changed_cursor then return end
       vim.cmd('undo!')
     end)
-    return 'v<Cmd>lua MiniJump.jump()<CR>'
+
+    -- Set a flag to distinguish first call from dot-repeat
+    MiniJump._is_expr_init = true
+
+    -- Encode state in expression for dot-repeat. Important to use `target=nil`
+    -- for `repeat_jump` case to have it using latest jumping state during
+    -- dot-repeat also (as does `nvim --clean`).
+    local args = string.format('%s,%s,%s,%s', vim.inspect(target), backward, till, count)
+    return 'v<Cmd>lua MiniJump._is_expr=true; MiniJump.jump(' .. args .. ')<CR>'
   end
 end
 

readmes/mini-jump.md

@@ -33,7 +33,7 @@ https://user-images.githubusercontent.com/24854248/173044762-f0f50a73-02df-4432-
 - Extend f, F, t, T to work on multiple lines.
 - Repeat jump by pressing f, F, t, T again. It is reset when cursor moved as a result of not jumping or timeout after idle time (duration customizable).
 - Highlight (after customizable delay) all possible target characters and stop it after some (customizable) idle time.
-- Normal, Visual, and Operator-pending (with full dot-repeat) modes are supported.
+- Normal, Visual, and Operator-pending (with dot-repeat as in clean Neovim) modes are supported.
 
 ## Installation
 

tests/test_jump.lua

@@ -183,7 +183,13 @@ T['state']['updates `mode`'] = function()
 
   type_keys('d', 't', 'e')
   eq(get_state().mode, 'nov')
-  child.lua('MiniJump.stop_jumping()')
+
+  -- Ensure dot-repeat does not update mode after the jump
+  type_keys('V', 't', 'e')
+  eq(get_state().mode, 'V')
+  child.ensure_normal_mode()
+  type_keys('.')
+  eq(get_state().mode, 'V')
 end
 
 T['state']['updates `jumping`'] = function()
@@ -402,7 +408,7 @@ T['Jumping with f/t/F/T']['works in Operator-pending mode'] = new_set({
     type_keys('d', '2', key, 'e')
     eq(get_lines(), { line_seq[3] })
 
-    -- Just typing `key` shouldn't repeat action
+    -- Just typing `key` shouldn't repeat motion
     local cur_pos = get_cursor()
     type_keys(key)
     eq(get_cursor(), cur_pos)
@@ -582,6 +588,31 @@ T['Jumping with f/t/F/T']['can be dot-repeated if did not jump at first'] = func
   validate('dT', 1, 5, 'abcdg')
 end
 
+T['Jumping with f/t/F/T']['inside dot-repeat is not affected by regular jumping'] = function()
+  local validate = function(keys, key_antagonist, result)
+    local line = '_xdxdx1x1xdxdx_'
+    local tests_forward = key_antagonist == string.upper(key_antagonist)
+
+    set_lines({ line })
+    set_cursor(1, tests_forward and 0 or (string.len(line) - 1))
+
+    type_keys(keys)
+    type_keys(tests_forward and '$' or '^')
+    type_keys(key_antagonist, '1')
+    type_keys('.')
+    eq(get_lines(), { result })
+
+    -- Ensure there is no jumping
+    child.lua('MiniJump.stop_jumping()')
+    child.ensure_normal_mode()
+  end
+
+  validate('2dfd', 'T', 'x1x1x_')
+  validate('2dtd', 'F', 'dx1xdx_')
+  validate('2dFd', 't', '_x1x1x')
+  validate('2dTd', 'f', '_xdx1xd')
+end
+
 T['Jumping with f/t/F/T']['stops prompting for target if hit `<Esc>` or `<C-c>`'] = new_set({
   parametrize = {
     { 'f', '<Esc>' },
@@ -878,16 +909,49 @@ T['Repeat jump with ;']['works after jump in Operator-pending mode'] = function(
   type_keys('d', '2f', 'e', ';')
   eq(get_lines(), { '3e4e5e' })
   eq(get_cursor(), { 1, 3 })
+
+  -- Should not use the latest dot repeat (like in `nvim --clean`)
+  set_lines({ '1e2e__3e4e5e6e' })
+  set_cursor(1, 0)
+
+  type_keys('d', '2f', 'e')
+  eq(get_lines(), { '__3e4e5e6e' })
+  eq(get_cursor(), { 1, 0 })
+
+  type_keys('$', 'T', '_')
+  eq(get_lines(), { '__3e4e5e6e' })
+  eq(get_cursor(), { 1, 2 })
+
+  -- - Should reuse initial Operator-pending mode state and not the latest one
+  type_keys('.')
+  eq(get_lines(), { '__5e6e' })
+  eq(get_cursor(), { 1, 2 })
+
+  -- - The latest one should still be preserved for regular jumping
+  type_keys(';')
+  eq(get_lines(), { '__5e6e' })
+  eq(get_cursor(), { 1, 1 })
 end
 
 T['Repeat jump with ;']['works in Operator-pending mode'] = function()
-  set_lines({ '1e2e3e4e5e' })
+  set_lines({ '1e2e3e4e5e_' })
   set_cursor(1, 0)
 
   -- Should repeat without asking for target
   type_keys('f', 'e', 'd', ';')
-  eq(get_lines(), { '13e4e5e' })
+  eq(get_lines(), { '13e4e5e_' })
   eq(get_cursor(), { 1, 1 })
+
+  -- Should work with dot-repeat as in `nvim --clean`, i.e. use target from the
+  -- latest jump, as `;` is exactly for that
+  type_keys('.')
+  eq(get_lines(), { '14e5e_' })
+  eq(get_cursor(), { 1, 1 })
+
+  type_keys('f', '_', '^')
+  type_keys('.')
+  eq(get_lines(), { '' })
+  eq(get_cursor(), { 1, 0 })
 end
 
 T['Repeat jump with ;']['works with different mapping'] = function()