870 lines
27 KiB
Plaintext
870 lines
27 KiB
Plaintext
*yanky.txt* Improved Yank an Put functionalities for Neovim
|
||
|
||
==============================================================================
|
||
Table of Contents *yanky-table-of-contents*
|
||
|
||
1. 🍃 yanky.nvim |yanky-🍃-yanky.nvim|
|
||
- ✨ Features |yanky-🍃-yanky.nvim-✨-features|
|
||
- ⚡️ Requirements |yanky-🍃-yanky.nvim-⚡️-requirements|
|
||
- 📦 Installation |yanky-🍃-yanky.nvim-📦-installation|
|
||
- ⚙️ Configuration |yanky-🍃-yanky.nvim-⚙️-configuration|
|
||
- 🖇️ Yank-ring |yanky-🍃-yanky.nvim-🖇️-yank-ring|
|
||
- 📜 Yank history picker |yanky-🍃-yanky.nvim-📜-yank-history-picker|
|
||
- 💡 Highlight put and yanked text|yanky-🍃-yanky.nvim-💡-highlight-put-and-yanked-text|
|
||
- ⤵️ Preserve cursor position on yank|yanky-🍃-yanky.nvim-⤵️-preserve-cursor-position-on-yank|
|
||
- ⭐ Special put |yanky-🍃-yanky.nvim-⭐-special-put|
|
||
- ⚓ Text object |yanky-🍃-yanky.nvim-⚓-text-object|
|
||
- 🎨 Colors |yanky-🍃-yanky.nvim-🎨-colors|
|
||
- 🤝 Integrations |yanky-🍃-yanky.nvim-🤝-integrations|
|
||
- 🎉 Credits |yanky-🍃-yanky.nvim-🎉-credits|
|
||
2. Links |yanky-links|
|
||
|
||
==============================================================================
|
||
1. 🍃 yanky.nvim *yanky-🍃-yanky.nvim*
|
||
|
||
<https://github.com/gbprod/yanky.nvim/actions/workflows/integration.yml>
|
||
|
||
The aim of `yanky.nvim` is to improve yank and put functionalities for Neovim.
|
||
|
||
French slogan:
|
||
|
||
|
||
"Vas-y Yanky, c’est bon !" - Yanky Vincent
|
||
Or in English:
|
||
|
||
|
||
"Yanky-ki-yay, motherf*cker" - John McYanky
|
||
|
||
✨ FEATURES *yanky-🍃-yanky.nvim-✨-features*
|
||
|
||
- 🖇️ Yank-ring
|
||
- 📜 Yank history picker
|
||
- 💡 Highlight put and yanked text
|
||
- ⤵️ Preserve cursor position on yank
|
||
- ⭐ Special put
|
||
- ⚓ Text object
|
||
|
||
|
||
⚡️ REQUIREMENTS *yanky-🍃-yanky.nvim-⚡️-requirements*
|
||
|
||
Requires neovim > `0.9.0`.
|
||
|
||
|
||
📦 INSTALLATION *yanky-🍃-yanky.nvim-📦-installation*
|
||
|
||
Install the plugin with your preferred package manager:
|
||
|
||
|
||
LAZY.NVIM ~
|
||
|
||
>lua
|
||
{
|
||
"gbprod/yanky.nvim",
|
||
opts = {
|
||
-- your configuration comes here
|
||
-- or leave it empty to use the default settings
|
||
-- refer to the configuration section below
|
||
},
|
||
}
|
||
<
|
||
|
||
More complete setup ~
|
||
|
||
>lua
|
||
{
|
||
"gbprod/yanky.nvim",
|
||
dependencies = {
|
||
{ "kkharji/sqlite.lua" }
|
||
},
|
||
opts = {
|
||
ring = { storage = "sqlite" },
|
||
},
|
||
keys = {
|
||
{ "<leader>p", function() require("telescope").extensions.yank_history.yank_history({ }) end, desc = "Open Yank History" },
|
||
{ "y", "<Plug>(YankyYank)", mode = { "n", "x" }, desc = "Yank text" },
|
||
{ "p", "<Plug>(YankyPutAfter)", mode = { "n", "x" }, desc = "Put yanked text after cursor" },
|
||
{ "P", "<Plug>(YankyPutBefore)", mode = { "n", "x" }, desc = "Put yanked text before cursor" },
|
||
{ "gp", "<Plug>(YankyGPutAfter)", mode = { "n", "x" }, desc = "Put yanked text after selection" },
|
||
{ "gP", "<Plug>(YankyGPutBefore)", mode = { "n", "x" }, desc = "Put yanked text before selection" },
|
||
{ "<c-p>", "<Plug>(YankyPreviousEntry)", desc = "Select previous entry through yank history" },
|
||
{ "<c-n>", "<Plug>(YankyNextEntry)", desc = "Select next entry through yank history" },
|
||
{ "]p", "<Plug>(YankyPutIndentAfterLinewise)", desc = "Put indented after cursor (linewise)" },
|
||
{ "[p", "<Plug>(YankyPutIndentBeforeLinewise)", desc = "Put indented before cursor (linewise)" },
|
||
{ "]P", "<Plug>(YankyPutIndentAfterLinewise)", desc = "Put indented after cursor (linewise)" },
|
||
{ "[P", "<Plug>(YankyPutIndentBeforeLinewise)", desc = "Put indented before cursor (linewise)" },
|
||
{ ">p", "<Plug>(YankyPutIndentAfterShiftRight)", desc = "Put and indent right" },
|
||
{ "<p", "<Plug>(YankyPutIndentAfterShiftLeft)", desc = "Put and indent left" },
|
||
{ ">P", "<Plug>(YankyPutIndentBeforeShiftRight)", desc = "Put before and indent right" },
|
||
{ "<P", "<Plug>(YankyPutIndentBeforeShiftLeft)", desc = "Put before and indent left" },
|
||
{ "=p", "<Plug>(YankyPutAfterFilter)", desc = "Put after applying a filter" },
|
||
{ "=P", "<Plug>(YankyPutBeforeFilter)", desc = "Put before applying a filter" },
|
||
},
|
||
}
|
||
<
|
||
|
||
|
||
PACKER ~
|
||
|
||
>lua
|
||
-- Lua
|
||
use("gbprod/yanky.nvim")
|
||
require("yanky").setup({
|
||
-- your configuration comes here
|
||
-- or leave it empty to use the default settings
|
||
-- refer to the configuration section below
|
||
})
|
||
<
|
||
|
||
|
||
⚙️ CONFIGURATION *yanky-🍃-yanky.nvim-⚙️-configuration*
|
||
|
||
Yanky comes with the following defaults:
|
||
|
||
>lua
|
||
{
|
||
ring = {
|
||
history_length = 100,
|
||
storage = "shada",
|
||
storage_path = vim.fn.stdpath("data") .. "/databases/yanky.db", -- Only for sqlite storage
|
||
sync_with_numbered_registers = true,
|
||
cancel_event = "update",
|
||
ignore_registers = { "_" },
|
||
update_register_on_cycle = false,
|
||
},
|
||
picker = {
|
||
select = {
|
||
action = nil, -- nil to use default put action
|
||
},
|
||
telescope = {
|
||
use_default_mappings = true, -- if default mappings should be used
|
||
mappings = nil, -- nil to use default mappings or no mappings (see `use_default_mappings`)
|
||
},
|
||
},
|
||
system_clipboard = {
|
||
sync_with_ring = true,
|
||
clipboard_register = nil,
|
||
},
|
||
highlight = {
|
||
on_put = true,
|
||
on_yank = true,
|
||
timer = 500,
|
||
},
|
||
preserve_cursor_position = {
|
||
enabled = true,
|
||
},
|
||
textobj = {
|
||
enabled = true,
|
||
},
|
||
}
|
||
<
|
||
|
||
|
||
⌨️ MAPPINGS ~
|
||
|
||
**This plugin contains no default mappings and will have no effect until you
|
||
add your own maps to it.** You should at least set those keymaps for yank ring
|
||
usage:
|
||
|
||
>lua
|
||
vim.keymap.set({"n","x"}, "p", "<Plug>(YankyPutAfter)")
|
||
vim.keymap.set({"n","x"}, "P", "<Plug>(YankyPutBefore)")
|
||
vim.keymap.set({"n","x"}, "gp", "<Plug>(YankyGPutAfter)")
|
||
vim.keymap.set({"n","x"}, "gP", "<Plug>(YankyGPutBefore)")
|
||
|
||
vim.keymap.set("n", "<c-p>", "<Plug>(YankyPreviousEntry)")
|
||
vim.keymap.set("n", "<c-n>", "<Plug>(YankyNextEntry)")
|
||
<
|
||
|
||
And those keymaps for `tpope/vim-unimpaired` like usage:
|
||
|
||
>lua
|
||
vim.keymap.set("n", "]p", "<Plug>(YankyPutIndentAfterLinewise)")
|
||
vim.keymap.set("n", "[p", "<Plug>(YankyPutIndentBeforeLinewise)")
|
||
vim.keymap.set("n", "]P", "<Plug>(YankyPutIndentAfterLinewise)")
|
||
vim.keymap.set("n", "[P", "<Plug>(YankyPutIndentBeforeLinewise)")
|
||
|
||
vim.keymap.set("n", ">p", "<Plug>(YankyPutIndentAfterShiftRight)")
|
||
vim.keymap.set("n", "<p", "<Plug>(YankyPutIndentAfterShiftLeft)")
|
||
vim.keymap.set("n", ">P", "<Plug>(YankyPutIndentBeforeShiftRight)")
|
||
vim.keymap.set("n", "<P", "<Plug>(YankyPutIndentBeforeShiftLeft)")
|
||
|
||
vim.keymap.set("n", "=p", "<Plug>(YankyPutAfterFilter)")
|
||
vim.keymap.set("n", "=P", "<Plug>(YankyPutBeforeFilter)")
|
||
<
|
||
|
||
Some features requires specific mappings, refer to feature documentation
|
||
section.
|
||
|
||
|
||
🖇️ YANK-RING *yanky-🍃-yanky.nvim-🖇️-yank-ring*
|
||
|
||
Yank-ring allows cycling throught yank history when putting text (like the
|
||
Emacs "kill-ring" feature). Yanky automatically maintain a history of yanks
|
||
that you can choose between when pasting.
|
||
|
||
|
||
⌨️ MAPPINGS ~
|
||
|
||
>lua
|
||
vim.keymap.set("n", "<c-p>", "<Plug>(YankyPreviousEntry)")
|
||
vim.keymap.set("n", "<c-n>", "<Plug>(YankyNextEntry)")
|
||
<
|
||
|
||
With these mappings, after performing a paste, you can cycle through the
|
||
history by hitting `<c-n>` and `<c-p>`. Any modifications done after pasting
|
||
will cancel the possibility to cycle.
|
||
|
||
Note that the swap operations above will only affect the current paste and the
|
||
history will be unchanged.
|
||
|
||
|
||
⚙️ CONFIGURATION ~
|
||
|
||
>lua
|
||
require("yanky").setup({
|
||
ring = {
|
||
history_length = 100,
|
||
storage = "shada",
|
||
sync_with_numbered_registers = true,
|
||
cancel_event = "update",
|
||
ignore_registers = { "_" },
|
||
update_register_on_cycle = false,
|
||
},
|
||
system_clipboard = {
|
||
sync_with_ring = true,
|
||
},
|
||
})
|
||
<
|
||
|
||
|
||
RING.HISTORY_LENGTH
|
||
|
||
Default : `100`
|
||
|
||
Define the number of yanked items that will be saved and used for ring.
|
||
|
||
|
||
RING.STORAGE
|
||
|
||
Default : `shada`
|
||
|
||
Available : `shada`, `sqlite` or `memory`
|
||
|
||
Define the storage mode for ring values.
|
||
|
||
Using `shada`, this will save pesistantly using Neovim ShaDa feature. This
|
||
means that history will be persisted between each session of Neovim.
|
||
|
||
You can also use this feature to sync the yank history across multiple running
|
||
instances of Neovim by updating shada file. If you execute `:wshada` in the
|
||
first instance and then `:rshada` in the second instance, the second instance
|
||
will be synced with the yank history in the first instance.
|
||
|
||
Using `memory`, each Neovim instance will have his own history and il will be
|
||
lost between sessions.
|
||
|
||
If you want to use `sqlite` as storage, you must add `kkharji/sqlite.lua`
|
||
<https://github.com/kkharji/sqlite.lua> as dependency:
|
||
|
||
>lua
|
||
use({
|
||
"gbprod/yanky.nvim",
|
||
requires = { "kkharji/sqlite.lua" }
|
||
})
|
||
<
|
||
|
||
Sqlite is more reliable than ShaDa but requires more dependencies. You can
|
||
change the storage path using `ring.storage_path` option.
|
||
|
||
|
||
RING.SYNC_WITH_NUMBERED_REGISTERS ~
|
||
|
||
Default : `true`
|
||
|
||
History can also be synchronized with numbered registers. Every time the yank
|
||
history changes the numbered registers 1 - 9 will be updated to sync with the
|
||
first 9 entries in the yank history. See here
|
||
<http://vimcasts.org/blog/2013/11/registers-the-good-the-bad-and-the-ugly-parts/>
|
||
for an explanation of why we would want do do this.
|
||
|
||
|
||
RING.CANCEL_EVENT ~
|
||
|
||
Default: `update`
|
||
|
||
Define the event used to cancel ring activation. `update` will cancel ring on
|
||
next buffer update, `move` will cancel ring when moving cursor or content
|
||
changed.
|
||
|
||
|
||
RING.IGNORE_REGISTERS ~
|
||
|
||
Default: `{ "_" }`
|
||
|
||
Define registeres to be ignored. By default the black hole register is ignored.
|
||
|
||
|
||
SYSTEM_CLIPBOARD.SYNC_WITH_RING ~
|
||
|
||
Default: `true`
|
||
|
||
Yanky can automatically adds to ring history yanks that occurs outside of
|
||
Neovim. This works regardless to your `&clipboard` setting.
|
||
|
||
This means, if `&clipboard` is set to `unnamed` and/or `unnamedplus`, if you
|
||
yank something outside of Neovim, you can put it immediatly using `p` and it
|
||
will be added to your yank ring.
|
||
|
||
If `&clipboard` is empty, if you yank something outside of Neovim, this will be
|
||
the first value you’ll have when cycling through the ring. Basicly, you can
|
||
do `p` and then `<c-p>` to paste yanked text.
|
||
|
||
Note that `clipboard == unnamed` uses the primary selection of the system (see
|
||
|clipbard| for more details) which is updated on selection, not on copy/yank.
|
||
Also note that the syncing happens when neovim gains focus.
|
||
|
||
|
||
SYSTEM_CLIPBOARD.CLIPBOARD_REGISTER ~
|
||
|
||
Default: `nil` use `&clipboard`
|
||
|
||
Choose the register that is synced with ring (from above). If `&clipboard` is
|
||
empty then `*` is used.
|
||
|
||
|
||
RING.UPDATE_REGISTER_ON_CYCLE ~
|
||
|
||
Default: `false`
|
||
|
||
Using the `update_register_on_cycle` option, when you cycle through the ring,
|
||
the contents of the register used to update will be updated with the last
|
||
content cycled.
|
||
|
||
|
||
COMMANDS ~
|
||
|
||
You can clear yank history using `YankyClearHistory` command.
|
||
|
||
|
||
📜 YANK HISTORY PICKER *yanky-🍃-yanky.nvim-📜-yank-history-picker*
|
||
|
||
This allows you to select an entry in your recorded yank history using default
|
||
`vim.ui.select` neovim prompt (you can use stevearc/dressing.nvim
|
||
<https://github.com/stevearc/dressing.nvim/> to customize this) or the awesome
|
||
telescope.nvim <https://github.com/nvim-telescope/telescope.nvim>.
|
||
|
||
It uses the same history as yank ring, so, if you want to increase history
|
||
size, just use |yanky-`ring.history_length`-option|.
|
||
|
||
See |yanky-integrations| to have a completion with nvim-cmp
|
||
<https://github.com/hrsh7th/nvim-cmp>.
|
||
|
||
|
||
YANK HISTORY COMPLETIONS ~
|
||
|
||
Using nvim-cmp <https://github.com/hrsh7th/nvim-cmp> and cmp_yanky
|
||
<https://github.com/chrisgrieser/cmp_yanky>, you can also get suggestions from
|
||
your yank history as you type in insert mode.
|
||
|
||
demonstration ~
|
||
|
||
|
||
⚙️ CONFIGURATION ~
|
||
|
||
To use `vim.ui.select` picker, just call `YankyRingHistory` command.
|
||
|
||
To use the `yank_history` Telescope picker, register `yank_history` as a
|
||
Telescope extension in your Neovim config file.
|
||
|
||
>lua
|
||
:lua require("telescope").load_extension("yank_history")
|
||
<
|
||
|
||
After loading the extension, you can access the picker by running:
|
||
|
||
>vim
|
||
:Telescope yank_history
|
||
<
|
||
|
||
Or:
|
||
|
||
>lua
|
||
:lua require("telescope").extensions.yank_history.yank_history()
|
||
<
|
||
|
||
Set the Telescope option `dynamic_preview_title`
|
||
<https://github.com/nvim-telescope/telescope.nvim/blob/master/doc/telescope.txt>
|
||
to `true` if you want your Telescope preview window to have a dynamic title
|
||
showing the register’s type.
|
||
|
||
Default configuration :
|
||
|
||
>lua
|
||
require("yanky").setup({
|
||
picker = {
|
||
select = {
|
||
action = nil, -- nil to use default put action
|
||
},
|
||
telescope = {
|
||
mappings = nil, -- nil to use default mappings
|
||
},
|
||
},
|
||
})
|
||
<
|
||
|
||
|
||
PICKER.SELECT.ACTION
|
||
|
||
Default : `nil`
|
||
|
||
This define the action that should be done when selecting an item in the
|
||
`vim.ui.select` prompt. If you let this option to `nil`, this will use the
|
||
default action : put selected item after cursor.
|
||
|
||
Available actions:
|
||
|
||
>lua
|
||
require("yanky.picker").actions.put("p") -- put after cursor
|
||
require("yanky.picker").actions.put("P") -- put before cursor
|
||
require("yanky.picker").actions.put("gp") -- put after cursor and leave the cursor after
|
||
require("yanky.picker").actions.put("gP") -- put before cursor and leave the cursor after
|
||
require("yanky.picker").actions.delete() -- delete entry from yank history
|
||
require("yanky.picker").actions.set_register(regname) -- fill register with selected value
|
||
require("yanky.picker").actions.put_and_set_register("p", regname) -- put and fill register with selected value
|
||
<
|
||
|
||
|
||
PICKER.TELESCOPE.USE_DEFAULT_MAPPINGS
|
||
|
||
Default : `true`
|
||
|
||
This define if default Telescope mappings should be use.
|
||
|
||
If you let this option to `true`, this will use the default mappings :
|
||
|
||
>lua
|
||
local utils = require("yanky.utils")
|
||
local mapping = require("yanky.telescope.mapping")
|
||
|
||
require("yanky").setup({
|
||
picker = {
|
||
telescope = {
|
||
mappings = {
|
||
default = mapping.put("p"),
|
||
i = {
|
||
["<c-g>"] = mapping.put("p"),
|
||
["<c-k>"] = mapping.put("P"),
|
||
["<c-x>"] = mapping.delete(),
|
||
["<c-r>"] = mapping.set_register(utils.get_default_register()),
|
||
},
|
||
n = {
|
||
p = mapping.put("p"),
|
||
P = mapping.put("P"),
|
||
d = mapping.delete(),
|
||
r = mapping.set_register(utils.get_default_register())
|
||
},
|
||
}
|
||
}
|
||
}
|
||
})
|
||
<
|
||
|
||
|
||
PICKER.TELESCOPE.MAPPINGS
|
||
|
||
Default : `nil`
|
||
|
||
This define or overrides the mappings available in Telescope.
|
||
|
||
If you set `use_default_mappings` to `true`, mappings will be merged with
|
||
default mappings.
|
||
|
||
**Available actions:**
|
||
|
||
>lua
|
||
require("yanky.telescope.mapping").put("p") -- put after cursor
|
||
require("yanky.telescope.mapping").put("P") -- put before cursor
|
||
require("yanky.telescope.mapping").put("gp") -- put after cursor and leave the cursor after
|
||
require("yanky.telescope.mapping").put("gP") -- put before cursor and leave the cursor after
|
||
require("yanky.telescope.mapping").delete() -- delete entry from yank history
|
||
require("yanky.telescope.mapping").set_register(regname) -- fill register {regname} with selected value
|
||
<
|
||
|
||
You can also use any of available special puts
|
||
<https://github.com/gbprod/yanky.nvim#%EF%B8%8F-special-put> like this:
|
||
|
||
>lua
|
||
require("yanky.telescope.mapping").special_put("{{ name of the special put }}")
|
||
|
||
-- eg.
|
||
require("yanky.telescope.mapping").special_put("YankyPutAfterCharwiseJoined")
|
||
<
|
||
|
||
|
||
💡 HIGHLIGHT PUT AND YANKED TEXT*yanky-🍃-yanky.nvim-💡-highlight-put-and-yanked-text*
|
||
|
||
This will give you a visual feedback on put and yank text by highlighting this.
|
||
|
||
### Configuration
|
||
|
||
>lua
|
||
require("yanky").setup({
|
||
highlight = {
|
||
on_put = true,
|
||
on_yank = true,
|
||
timer = 500,
|
||
},
|
||
})
|
||
<
|
||
|
||
You can override `YankyPut` highlight to change colors.
|
||
|
||
|
||
HIGHLIGHT.ON_PUT
|
||
|
||
Default : `true`
|
||
|
||
Define if highlight put text feature is enabled.
|
||
|
||
|
||
HIGHLIGHT.ON_YANK
|
||
|
||
Default : `true`
|
||
|
||
Define if highlight yanked text feature is enabled.
|
||
|
||
|
||
HIGHLIGHT.TIMER
|
||
|
||
Default : `500`
|
||
|
||
Define the duration of highlight.
|
||
|
||
|
||
⤵️ PRESERVE CURSOR POSITION ON YANK*yanky-🍃-yanky.nvim-⤵️-preserve-cursor-position-on-yank*
|
||
|
||
By default in Neovim, when yanking text, cursor moves to the start of the
|
||
yanked text. Could be annoying especially when yanking a large text object such
|
||
as a paragraph or a large text object.
|
||
|
||
With this feature, yank will function exactly the same as previously with the
|
||
one difference being that the cursor position will not change after performing
|
||
a yank.
|
||
|
||
|
||
⌨️ MAPPINGS ~
|
||
|
||
>lua
|
||
vim.keymap.set({"n","x"}, "y", "<Plug>(YankyYank)")
|
||
<
|
||
|
||
|
||
⚙️ CONFIGURATION ~
|
||
|
||
>lua
|
||
require("yanky").setup({
|
||
preserve_cursor_position = {
|
||
enabled = true,
|
||
},
|
||
})
|
||
<
|
||
|
||
|
||
PRESERVE_CURSOR_POSITION.ENABLED
|
||
|
||
Default : `true`
|
||
|
||
Define if cursor position should be preserved on yank. This works only if
|
||
mappings has been defined.
|
||
|
||
|
||
⭐ SPECIAL PUT *yanky-🍃-yanky.nvim-⭐-special-put*
|
||
|
||
Yanky comes with special put moves (inspired by tpope/vim-unimpaired
|
||
<https://github.com/tpope/vim-unimpaired/blob/master/doc/unimpaired.txt#L100>):
|
||
|
||
- Linewise put: this will force put above or below the current line ;
|
||
- Shift right/left put: will put above or below the current line and increasing
|
||
or decreasing indent ;
|
||
- Filter put: will put above or below the current line and reindenting.
|
||
|
||
|
||
⌨️ MAPPINGS ~
|
||
|
||
For basic usage (like with tpope/vim-unimpaired
|
||
<https://github.com/tpope/vim-unimpaired/blob/master/doc/unimpaired.txt#L100>),
|
||
you can use those bindings:
|
||
|
||
>lua
|
||
vim.keymap.set("n", "]p", "<Plug>(YankyPutIndentAfterLinewise)")
|
||
vim.keymap.set("n", "[p", "<Plug>(YankyPutIndentBeforeLinewise)")
|
||
vim.keymap.set("n", "]P", "<Plug>(YankyPutIndentAfterLinewise)")
|
||
vim.keymap.set("n", "[P", "<Plug>(YankyPutIndentBeforeLinewise)")
|
||
|
||
vim.keymap.set("n", ">p", "<Plug>(YankyPutIndentAfterShiftRight)")
|
||
vim.keymap.set("n", "<p", "<Plug>(YankyPutIndentAfterShiftLeft)")
|
||
vim.keymap.set("n", ">P", "<Plug>(YankyPutIndentBeforeShiftRight)")
|
||
vim.keymap.set("n", "<P", "<Plug>(YankyPutIndentBeforeShiftLeft)")
|
||
|
||
vim.keymap.set("n", "=p", "<Plug>(YankyPutAfterFilter)")
|
||
vim.keymap.set("n", "=P", "<Plug>(YankyPutBeforeFilter)")
|
||
<
|
||
|
||
To go further, Plug mappings are constructed like this:
|
||
`Yanky(put-type)(modifier)(rewriter)`.
|
||
|
||
`put-type` can be:
|
||
|
||
- `PutAfter`: put after your cursor (as |`p`| key) ;
|
||
- `PutBefore`: put before your cursor (as |`P`| key) ;
|
||
- `GPutAfter`: like `PutAfter` but leave the cursor after the new text (as |`gp`| key) ;
|
||
- `GPutBefore`: like `PutBefore` but leave the cursor after the new text (as |`gP`| key) ;
|
||
- `PutIndentAfter`: like `PutAfter` but adjust the indent to the current line (as |`]p`| key) ;
|
||
- `PutIndentBefore`: like `PutBefore` but adjust the indent to the current line (as |`[p`| key) ;
|
||
|
||
`modifier` (optional) can be:
|
||
|
||
- `Linewise`: put in linewise mode ;
|
||
- `Charwise`: put in charwise mode ;
|
||
- `Blockwise`: put in blockwise mode ;
|
||
- `ShiftRight`: increase indent ;
|
||
- `ShiftLeft`: decrease indent.
|
||
|
||
`rewriter` (optional) can be:
|
||
|
||
- `Joined`: put lines trimed and joined.
|
||
|
||
All special puts ~
|
||
|
||
>vim
|
||
<Plug>(YankyPutAfter)
|
||
<Plug>(YankyPutAfterBlockwise)
|
||
<Plug>(YankyPutAfterBlockwiseJoined)
|
||
<Plug>(YankyPutAfterCharwise)
|
||
<Plug>(YankyPutAfterCharwiseJoined)
|
||
<Plug>(YankyPutAfterFilter)
|
||
<Plug>(YankyPutAfterFilterJoined)
|
||
<Plug>(YankyPutAfterJoined)
|
||
<Plug>(YankyPutAfterLinewise)
|
||
<Plug>(YankyPutAfterLinewiseJoined)
|
||
<Plug>(YankyPutAfterShiftLeft)
|
||
<Plug>(YankyPutAfterShiftLeftJoined)
|
||
<Plug>(YankyPutAfterShiftRight)
|
||
<Plug>(YankyPutAfterShiftRightJoined)
|
||
<Plug>(YankyPutBefore)
|
||
<Plug>(YankyPutBeforeBlockwise)
|
||
<Plug>(YankyPutBeforeBlockwiseJoined)
|
||
<Plug>(YankyPutBeforeCharwise)
|
||
<Plug>(YankyPutBeforeCharwiseJoined)
|
||
<Plug>(YankyPutBeforeFilter)
|
||
<Plug>(YankyPutBeforeFilterJoined)
|
||
<Plug>(YankyPutBeforeJoined)
|
||
<Plug>(YankyPutBeforeLinewise)
|
||
<Plug>(YankyPutBeforeLinewiseJoined)
|
||
<Plug>(YankyPutBeforeShiftLeft)
|
||
<Plug>(YankyPutBeforeShiftLeftJoined)
|
||
<Plug>(YankyPutBeforeShiftRight)
|
||
<Plug>(YankyPutBeforeShiftRightJoined)
|
||
<Plug>(YankyGPutAfter)
|
||
<Plug>(YankyGPutAfterBlockwise)
|
||
<Plug>(YankyGPutAfterBlockwiseJoined)
|
||
<Plug>(YankyGPutAfterCharwise)
|
||
<Plug>(YankyGPutAfterCharwiseJoined)
|
||
<Plug>(YankyGPutAfterFilter)
|
||
<Plug>(YankyGPutAfterFilterJoined)
|
||
<Plug>(YankyGPutAfterJoined)
|
||
<Plug>(YankyGPutAfterLinewise)
|
||
<Plug>(YankyGPutAfterLinewiseJoined)
|
||
<Plug>(YankyGPutAfterShiftLeft)
|
||
<Plug>(YankyGPutAfterShiftLeftJoined)
|
||
<Plug>(YankyGPutAfterShiftRight)
|
||
<Plug>(YankyGPutAfterShiftRightJoined)
|
||
<Plug>(YankyGPutBefore)
|
||
<Plug>(YankyGPutBeforeBlockwise)
|
||
<Plug>(YankyGPutBeforeBlockwiseJoined)
|
||
<Plug>(YankyGPutBeforeCharwise)
|
||
<Plug>(YankyGPutBeforeCharwiseJoined)
|
||
<Plug>(YankyGPutBeforeFilter)
|
||
<Plug>(YankyGPutBeforeFilterJoined)
|
||
<Plug>(YankyGPutBeforeJoined)
|
||
<Plug>(YankyGPutBeforeLinewise)
|
||
<Plug>(YankyGPutBeforeLinewiseJoined)
|
||
<Plug>(YankyGPutBeforeShiftLeft)
|
||
<Plug>(YankyGPutBeforeShiftLeftJoined)
|
||
<Plug>(YankyGPutBeforeShiftRight)
|
||
<Plug>(YankyGPutBeforeShiftRightJoined)
|
||
<Plug>(YankyPutIndentAfter)
|
||
<Plug>(YankyPutIndentAfterBlockwise)
|
||
<Plug>(YankyPutIndentAfterBlockwiseJoined)
|
||
<Plug>(YankyPutIndentAfterCharwise)
|
||
<Plug>(YankyPutIndentAfterCharwiseJoined)
|
||
<Plug>(YankyPutIndentAfterFilter)
|
||
<Plug>(YankyPutIndentAfterFilterJoined)
|
||
<Plug>(YankyPutIndentAfterJoined)
|
||
<Plug>(YankyPutIndentAfterLinewise)
|
||
<Plug>(YankyPutIndentAfterLinewiseJoined)
|
||
<Plug>(YankyPutIndentAfterShiftLeft)
|
||
<Plug>(YankyPutIndentAfterShiftLeftJoined)
|
||
<Plug>(YankyPutIndentAfterShiftRight)
|
||
<Plug>(YankyPutIndentAfterShiftRightJoined)
|
||
<Plug>(YankyPutIndentBefore)
|
||
<Plug>(YankyPutIndentBeforeBlockwise)
|
||
<Plug>(YankyPutIndentBeforeBlockwiseJoined)
|
||
<Plug>(YankyPutIndentBeforeCharwise)
|
||
<Plug>(YankyPutIndentBeforeCharwiseJoined)
|
||
<Plug>(YankyPutIndentBeforeFilter)
|
||
<Plug>(YankyPutIndentBeforeFilterJoined)
|
||
<Plug>(YankyPutIndentBeforeJoined)
|
||
<Plug>(YankyPutIndentBeforeLinewise)
|
||
<Plug>(YankyPutIndentBeforeLinewiseJoined)
|
||
<Plug>(YankyPutIndentBeforeShiftLeft)
|
||
<Plug>(YankyPutIndentBeforeShiftLeftJoined)
|
||
<Plug>(YankyPutIndentBeforeShiftRight)
|
||
<Plug>(YankyPutIndentBeforeShiftRightJoined)
|
||
<
|
||
|
||
|
||
⚓ TEXT OBJECT *yanky-🍃-yanky.nvim-⚓-text-object*
|
||
|
||
Yanky comes with a text object corresponding to last put text. To use it, you
|
||
have to enable it in settings and set a keymap.
|
||
|
||
|
||
⚙️ CONFIGURATION ~
|
||
|
||
>lua
|
||
require("yanky").setup({
|
||
textobj = {
|
||
enabled = true,
|
||
},
|
||
})
|
||
<
|
||
|
||
|
||
⌨️ MAPPINGS ~
|
||
|
||
>lua
|
||
vim.keymap.set({ "o", "x" }, "lp", function()
|
||
require("yanky.textobj").last_put()
|
||
end, {})
|
||
<
|
||
|
||
|
||
🎨 COLORS *yanky-🍃-yanky.nvim-🎨-colors*
|
||
|
||
Description Group Default
|
||
--------------------------------- ------------- ----------------
|
||
Highlight color for put text YankyPut link to Search
|
||
Highlight color for yanked text YankyYanked link to Search
|
||
|
||
🤝 INTEGRATIONS *yanky-🍃-yanky.nvim-🤝-integrations*
|
||
|
||
gbprod/substitute.nvim ~
|
||
|
||
To enable gbprod/substitute.nvim <https://github.com/gbprod/substitute.nvim>
|
||
swap when performing a substitution, you can add this to your setup:
|
||
|
||
>lua
|
||
require("substitute").setup({
|
||
on_substitute = require("yanky.integration").substitute(),
|
||
})
|
||
<
|
||
|
||
or
|
||
|
||
>lua
|
||
opts = {
|
||
on_substitute = function() require("yanky.integration").substitute() end,
|
||
}
|
||
<
|
||
|
||
hrsh7th/nvim-cmp ~
|
||
|
||
Using hrsh7th/nvim-cmp <https://github.com/hrsh7th/nvim-cmp> and
|
||
chrisgrieser/cmp_yanky <https://github.com/chrisgrieser/cmp_yanky>, you can
|
||
also get suggestions from your yank history as you type in insert mode.
|
||
|
||
anuvyklack/hydra.nvim ~
|
||
|
||
To work with anuvyklack/hydra.nvim <https://github.com/anuvyklack/hydra.nvim>
|
||
only setup / mapping when yanky is activated, you can add this to your setup:
|
||
|
||
>lua
|
||
local Hydra = require("hydra")
|
||
|
||
local function t(str)
|
||
return api.nvim_replace_termcodes(str, true, true, true)
|
||
end
|
||
|
||
local yanky_hydra = Hydra({
|
||
name = "Yank ring",
|
||
mode = "n",
|
||
heads = {
|
||
{ "p", "<Plug>(YankyPutAfter)", { desc = "After" } },
|
||
{ "P", "<Plug>(YankyPutBefore)", { desc = "Before" } },
|
||
{ "<c-p>", "<Plug>(YankyPreviousEntry)", { private = true, desc = "↑" } },
|
||
{ "<c-n>", "<Plug>(YankyNextEntry)", { private = true, desc = "↓" } },
|
||
},
|
||
})
|
||
|
||
-- choose/change the mappings if you want
|
||
for key, putAction in pairs({
|
||
["p"] = "<Plug>(YankyPutAfter)",
|
||
["P"] = "<Plug>(YankyPutBefore)",
|
||
["gp"] = "<Plug>(YankyGPutAfter)",
|
||
["gP"] = "<Plug>(YankyGPutBefore)",
|
||
}) do
|
||
vim.keymap.set({ "n", "x" }, key, function()
|
||
vim.fn.feedkeys(t(putAction))
|
||
yanky_hydra:activate()
|
||
end)
|
||
end
|
||
|
||
-- choose/change the mappings if you want
|
||
for key, putAction in pairs({
|
||
["]p"] = "<Plug>(YankyPutIndentAfterLinewise)",
|
||
["[p"] = "<Plug>(YankyPutIndentBeforeLinewise)",
|
||
["]P"] = "<Plug>(YankyPutIndentAfterLinewise)",
|
||
["[P"] = "<Plug>(YankyPutIndentBeforeLinewise)",
|
||
|
||
[">p"] = "<Plug>(YankyPutIndentAfterShiftRight)",
|
||
["<p"] = "<Plug>(YankyPutIndentAfterShiftLeft)",
|
||
[">P"] = "<Plug>(YankyPutIndentBeforeShiftRight)",
|
||
["<P"] = "<Plug>(YankyPutIndentBeforeShiftLeft)",
|
||
|
||
["=p"] = "<Plug>(YankyPutAfterFilter)",
|
||
["=P"] = "<Plug>(YankyPutBeforeFilter)",
|
||
}) do
|
||
vim.keymap.set("n", key, function()
|
||
vim.fn.feedkeys(t(putAction))
|
||
yanky_hydra:activate()
|
||
end)
|
||
end
|
||
<
|
||
|
||
|
||
🎉 CREDITS *yanky-🍃-yanky.nvim-🎉-credits*
|
||
|
||
This plugin is mostly a lua version of svermeulen/vim-yoink
|
||
<https://github.com/svermeulen/vim-yoink> awesome plugin.
|
||
|
||
Other inspiration :
|
||
|
||
- bfredl/nvim-miniyank <https://github.com/bfredl/nvim-miniyank>
|
||
- maxbrunsfeld/vim-yankstack <https://github.com/maxbrunsfeld/vim-yankstack>
|
||
- svermeulen/vim-easyclip <https://github.com/svermeulen/vim-easyclip>
|
||
- bkoropoff/yankee.vim <https://github.com/bkoropoff/yankee.vim>
|
||
- svban/YankAssassin.vim <https://github.com/svban/YankAssassin.vim>
|
||
- tpope/vim-unimpaired <https://github.com/tpope/vim-unimpaired>
|
||
- inkarkat/vim-UnconditionalPaste <https://github.com/inkarkat/vim-UnconditionalPaste>
|
||
|
||
==============================================================================
|
||
2. Links *yanky-links*
|
||
|
||
1. *Lua*: https://img.shields.io/badge/Made%20with%20Lua-blueviolet.svg?style=for-the-badge&logo=lua
|
||
2. *GitHub Workflow Status*: https://img.shields.io/github/actions/workflow/status/gbprod/yanky.nvim/integration.yml?branch=main&style=for-the-badge
|
||
|
||
Generated by panvimdoc <https://github.com/kdheepak/panvimdoc>
|
||
|
||
vim:tw=78:ts=8:noet:ft=help:norl:
|