refactor(jump): simplify the main jump function

Details:
- Instead of always checking if target exists in text, only do so if
  there was no jump. Additional benefit: the code using the cursor to
  check if a jump occurred can be replaced by a more direct check.

- Rearrange code for a lower LOC and more clarity.

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

Author: abeldekat

lua/mini/jump.lua

@@ -181,74 +181,58 @@ MiniJump.state = {
 MiniJump.jump = function(target, backward, till, n_times)
   if H.is_disabled() then return end
 
-  -- Ensure to undo "consuming a character" effect if there is no target found
-  -- Do it here to act on dot-repeat
-  local has_changed_cursor = false
-  local undo_no_move = function()
-    if not has_changed_cursor then vim.cmd('undo!') end
-  end
-  if MiniJump._is_expr then vim.schedule(undo_no_move) 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
+  local is_expr, is_dot_repeat = MiniJump._is_expr, 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)
 
-  if MiniJump.state.target == nil then
-    H.message('Can not jump because there is no recent `target`.')
-    return
-  end
-
-  -- Determine if target is present anywhere in order to correctly enter
-  -- jumping mode. If not, jumping mode is not possible.
-  local search_pattern = [[\V]] .. vim.fn.escape(MiniJump.state.target, [[\]])
-  local target_is_present = vim.fn.search(search_pattern, 'wn') ~= 0
-  if not target_is_present then return end
+  if MiniJump.state.target == nil then return H.message('Can not jump because there is no recent `target`.') end
 
   -- Construct search and highlight pattern data
   local pattern, hl_pattern, flags = H.make_search_data()
 
   -- Delay highlighting after stopping previous one
+  -- Update highlighting immediately if any highlighting is already present
   local config = H.get_config()
   H.timers.highlight:stop()
-  H.timers.highlight:start(
-    -- Update highlighting immediately if any highlighting is already present
-    H.is_highlighting() and 0 or config.delay.highlight,
-    0,
-    vim.schedule_wrap(function() H.highlight(hl_pattern) end)
-  )
+  local hl = vim.schedule_wrap(function() H.highlight(hl_pattern) end)
+  H.timers.highlight:start(H.is_highlighting() and 0 or config.delay.highlight, 0, hl)
 
   -- Start idle timer after stopping previous one
   H.timers.idle_stop:stop()
   H.timers.idle_stop:start(config.delay.idle_stop, 0, vim.schedule_wrap(function() MiniJump.stop_jumping() end))
 
   -- Make jump(s)
   H.cache.n_cursor_moved = 0
-  local init_cursor_data = H.get_cursor_data()
   local was_jumping = MiniJump.state.jumping
   MiniJump.state.jumping = true
   if not was_jumping then H.trigger_event('MiniJumpStart') end
   H.trigger_event('MiniJumpJump')
 
+  local has_jumped = false
   for _ = 1, MiniJump.state.n_times do
-    vim.fn.search(pattern, flags)
+    local row = vim.fn.search(pattern, flags)
+    has_jumped = has_jumped or row > 0
   end
 
   -- Open enough folds to show jump
-  vim.cmd('normal! zv')
+  if has_jumped then vim.cmd('normal! zv') end
 
   -- Track cursor position to account for movement not caught by `CursorMoved`
   H.cache.latest_cursor = H.get_cursor_data()
-  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
+  -- Restore the state if needed. It should a jumping state if there was jump
+  -- or if it is possible to jump in other direction (i.e. target is present).
+  MiniJump.state = is_dot_repeat and state_snapshot or MiniJump.state
+  local search_pattern = '\\V' .. vim.fn.escape(MiniJump.state.target, '\\')
+  MiniJump.state.jumping = has_jumped or vim.fn.search(search_pattern, 'wn') ~= 0
+
+  -- Ensure to undo "consume a character" effect in Operator-pending expression
+  -- mapping if there is no target found. Do it here to also act on dot-repeat.
+  if is_expr and not has_jumped then vim.schedule(function() vim.cmd('undo!') end) end
 end
 
 --- Make smart jump