Yank/Delete remote lines + Remote undo

[al-ce]

Wanted to replicate leap-spooky's "line object" style remote actions, just works with yank + delete.

  local function remote_line_op(operator)
    local api = vim.api
    local win = api.nvim_get_current_win()
    local pos = api.nvim_win_get_cursor(win)
    require("leap").leap({
      target_windows = require("leap.user").get_focusable_windows(),
      action = function(target)
        local winid = target.wininfo.winid
        local lnum, _ = unpack(target.pos)
        api.nvim_set_current_win(winid)
        vim.cmd(lnum .. operator)
      end,
    })
    api.nvim_set_current_win(win)
    api.nvim_win_set_cursor(win, pos)

    if operator == "y" then
      vim.cmd("normal! p")
    end
  end

  vim.keymap.set({ "o" }, "rr", function()
    local op = vim.v.operator
    remote_line_op(op)
  end, { desc = "Leap: remote line op" })
end

Also wanted to take a shot at undoing remote operations while keeping the cursor still. I tried this a few months ago with leap-spooky, but it didn't really work out. This works well at the moment:

vim.api.nvim_create_augroup("LeapRemoteRewind", {})

vim.api.nvim_create_autocmd("User", {
  pattern = "LeapLeave",
  group = "LeapRemoteRewind",
  callback = function()
    vim.g.leap_destination_win = vim.api.nvim_get_current_win()
  end,
})

vim.api.nvim_create_autocmd("User", {
  pattern = "RemoteOperationDone",
  group = "LeapRemote",
  callback = function()
    local api = vim.api
    local map = vim.keymap.set
    local win = vim.api.nvim_get_current_win()

    -- store initial cursor pos
    vim.g.leap_remote_rewind_pos = vim.api.nvim_win_get_cursor(win)

    map("n", "u", function()
      -- Move to previous remote target window
      api.nvim_set_current_win(vim.g.leap_destination_win or 0)
      vim.cmd("normal! u")

      -- Move back to our last cursor position
      api.nvim_set_current_win(win)
      api.nvim_win_set_cursor(win, vim.g.leap_remote_rewind_pos)
      vim.g.leap_remote_rewind_pos = nil

      -- reset undo
      map("n", "u", "<cmd>normal! u<cr>")
    end, { desc = "Leap Remote Undo" })

    api.nvim_create_autocmd("CursorMoved", {
      group = "LeapRemoteRewind",
      callback = function()
        win = api.nvim_get_current_win()
        if vim.g.leap_remote_rewind_pos ~= nil then
          vim.g.leap_remote_rewind_pos = api.nvim_win_get_cursor(win)
        end
      end,
      desc = "Update Leap remote rewind position",
    })
  end,
})

Unfortunately neither of these work with the c operator.

[ggandor]

With the new remote module, a "remote line" object can be implemented like:

vim.keymap.set({'x', 'o'}, 'aa', function ()
  local mode = vim.fn.mode(true)
  require('leap.remote').action {
    input =
      -- Force linewise selection.
      (mode:match('V') and '' or 'V') ..
      -- In O-p mode, move to any direction on the line, to trigger the operation.
      (mode:match('o') and 'h' or '')
  }
end)

Caveat: this cannot take count though. I haven't found a way to make it select count, and not count+1 lines. (Unfortunately, we cannot use j/k, because the count value is automatically applied on them. If count=2, then any j becomes 2j, and so on.)