615 lines
23 KiB
Lua
615 lines
23 KiB
Lua
--- *mini.pairs* Autopairs
|
|
--- *MiniPairs*
|
|
---
|
|
--- MIT License Copyright (c) 2021 Evgeni Chasnovski
|
|
---
|
|
--- ==============================================================================
|
|
---
|
|
--- Features:
|
|
--- - Functionality to work with 'paired' characters conditional on cursor's
|
|
--- neighborhood (two characters to its left and right).
|
|
---
|
|
--- - Usage should be through making appropriate mappings using |MiniPairs.map|
|
|
--- or in |MiniPairs.setup| (for global mapping), |MiniPairs.map_buf| (for
|
|
--- buffer mapping).
|
|
---
|
|
--- - Pairs get automatically registered to be recognized by `<BS>` and `<CR>`.
|
|
---
|
|
--- What it doesn't do:
|
|
--- - It doesn't support multiple characters as "open" and "close" symbols. Use
|
|
--- snippets for that.
|
|
---
|
|
--- - It doesn't support dependency on filetype. Use |i_CTRL-V| to insert
|
|
--- single symbol or `autocmd` command or 'after/ftplugin' approach to:
|
|
--- - `lua MiniPairs.map_buf(0, 'i', <*>, <pair_info>)` : make new mapping
|
|
--- for '<*>' in current buffer.
|
|
--- - `lua MiniPairs.unmap_buf(0, 'i', <*>, <pair>)`: unmap key `<*>` while
|
|
--- unregistering `<pair>` pair in current buffer. Note: this reverts
|
|
--- mapping done by |MiniPairs.map_buf|. If mapping was done with
|
|
--- |MiniPairs.map|, unmap for buffer in usual Neovim manner:
|
|
--- `inoremap <buffer> <*> <*>` (this maps `<*>` key to do the same it
|
|
--- does by default).
|
|
--- - Disable module for buffer (see 'Disabling' section).
|
|
---
|
|
--- # Setup~
|
|
---
|
|
--- This module needs a setup with `require('mini.pairs').setup({})`
|
|
--- (replace `{}` with your `config` table). It will create global Lua table
|
|
--- `MiniPairs` which you can use for scripting or manually (with
|
|
--- `:lua MiniPairs.*`).
|
|
---
|
|
--- See |MiniPairs.config| for `config` structure and default values.
|
|
---
|
|
--- This module doesn't have runtime options, so using `vim.b.minipairs_config`
|
|
--- will have no effect here.
|
|
---
|
|
--- # Example mappings~
|
|
---
|
|
--- - Register quotes inside `config` of |MiniPairs.setup|: >
|
|
--- mappings = {
|
|
--- ['"'] = { register = { cr = true } },
|
|
--- ["'"] = { register = { cr = true } },
|
|
--- }
|
|
--- <
|
|
--- - Insert `<>` pair if `<` is typed at line start, don't register for `<CR>`: >
|
|
--- lua MiniPairs.map('i', '<', { action = 'open', pair = '<>', neigh_pattern = '\r.', register = { cr = false } })
|
|
--- lua MiniPairs.map('i', '>', { action = 'close', pair = '<>', register = { cr = false } })
|
|
--- <
|
|
--- - Create symmetrical `$$` pair only in Tex files: >
|
|
--- au FileType tex lua MiniPairs.map_buf(0, 'i', '$', {action = 'closeopen', pair = '$$'})
|
|
--- <
|
|
--- # Notes~
|
|
---
|
|
--- - Make sure to make proper mapping of `<CR>` in order to support completion
|
|
--- plugin of your choice:
|
|
--- - For |MiniCompletion| see 'Helpful key mappings' section.
|
|
--- - For current implementation of "hrsh7th/nvim-cmp" there is no need to
|
|
--- make custom mapping. You can use default setup, which will confirm
|
|
--- completion selection if popup is visible and expand pair otherwise.
|
|
--- - Having mapping in terminal mode can conflict with:
|
|
--- - Autopairing capabilities of interpretators (`ipython`, `radian`).
|
|
--- - Vim mode of terminal itself.
|
|
---
|
|
--- # Disabling~
|
|
---
|
|
--- To disable, set `vim.g.minipairs_disable` (globally) or `vim.b.minipairs_disable`
|
|
--- (for a buffer) to `true`. Considering high number of different scenarios
|
|
--- and customization intentions, writing exact rules for disabling module's
|
|
--- functionality is left to user. See |mini.nvim-disabling-recipes| for common
|
|
--- recipes.
|
|
|
|
---@alias __pairs_neigh_pattern string|nil Pattern for two neighborhood characters.
|
|
--- Character "\r" indicates line start, "\n" - line end.
|
|
---@alias __pairs_pair string String with two characters representing pair.
|
|
---@alias __pairs_unregistered_pair string Pair which should be unregistered from both
|
|
--- `<BS>` and `<CR>`. Should be explicitly supplied to avoid confusion.
|
|
--- Supply `''` to not unregister pair.
|
|
|
|
-- Module definition ==========================================================
|
|
local MiniPairs = {}
|
|
local H = {}
|
|
|
|
--- Module setup
|
|
---
|
|
---@param config table|nil Module config table. See |MiniPairs.config|.
|
|
---
|
|
---@usage `require('mini.completion').setup({})` (replace `{}` with your `config` table)
|
|
MiniPairs.setup = function(config)
|
|
-- Export module
|
|
_G.MiniPairs = MiniPairs
|
|
|
|
-- Setup config
|
|
config = H.setup_config(config)
|
|
|
|
-- Apply config
|
|
H.apply_config(config)
|
|
|
|
-- Define behavior
|
|
H.create_autocommands()
|
|
end
|
|
|
|
--- Module config
|
|
---
|
|
--- Default values:
|
|
---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)
|
|
MiniPairs.config = {
|
|
-- In which modes mappings from this `config` should be created
|
|
modes = { insert = true, command = false, terminal = false },
|
|
|
|
-- Global mappings. Each right hand side should be a pair information, a
|
|
-- table with at least these fields (see more in |MiniPairs.map|):
|
|
-- - <action> - one of "open", "close", "closeopen".
|
|
-- - <pair> - two character string for pair to be used.
|
|
-- By default pair is not inserted after `\`, quotes are not recognized by
|
|
-- `<CR>`, `'` does not insert pair after a letter.
|
|
-- Only parts of tables can be tweaked (others will use these defaults).
|
|
-- Supply `false` instead of table to not map particular key.
|
|
mappings = {
|
|
['('] = { action = 'open', pair = '()', neigh_pattern = '[^\\].' },
|
|
['['] = { action = 'open', pair = '[]', neigh_pattern = '[^\\].' },
|
|
['{'] = { action = 'open', pair = '{}', neigh_pattern = '[^\\].' },
|
|
|
|
[')'] = { action = 'close', pair = '()', neigh_pattern = '[^\\].' },
|
|
[']'] = { action = 'close', pair = '[]', neigh_pattern = '[^\\].' },
|
|
['}'] = { action = 'close', pair = '{}', neigh_pattern = '[^\\].' },
|
|
|
|
['"'] = { action = 'closeopen', pair = '""', neigh_pattern = '[^\\].', register = { cr = false } },
|
|
["'"] = { action = 'closeopen', pair = "''", neigh_pattern = '[^%a\\].', register = { cr = false } },
|
|
['`'] = { action = 'closeopen', pair = '``', neigh_pattern = '[^\\].', register = { cr = false } },
|
|
},
|
|
}
|
|
--minidoc_afterlines_end
|
|
|
|
-- Module functionality =======================================================
|
|
--- Make global mapping
|
|
---
|
|
--- This is a wrapper for |nvim_set_keymap()| but instead of right hand side of
|
|
--- mapping (as string) it expects table with pair information:
|
|
--- - `action` - one of "open" (for |MiniPairs.open|), "close" (for
|
|
--- |MiniPairs.close|), or "closeopen" (for |MiniPairs.closeopen|).
|
|
--- - `pair` - two character string to be used as argument for action function.
|
|
--- - `neigh_pattern` - optional 'two character' neighborhood pattern to be
|
|
--- used as argument for action function. Default: '..' (no restriction from
|
|
--- neighborhood).
|
|
--- - `register` - optional table with information about whether this pair
|
|
--- should be recognized by `<BS>` (in |MiniPairs.bs|) and/or `<CR>` (in
|
|
--- |MiniPairs.cr|). Should have boolean elements `bs` and `cr` which are
|
|
--- both `true` by default (if not overridden explicitly).
|
|
---
|
|
--- Using this function instead of |nvim_set_keymap()| allows automatic
|
|
--- registration of pairs which will be recognized by `<BS>` and `<CR>`.
|
|
--- For Neovim>=0.7 it also infers mapping description from `pair_info`.
|
|
---
|
|
---@param mode string `mode` for |nvim_set_keymap()|.
|
|
---@param lhs string `lhs` for |nvim_set_keymap()|.
|
|
---@param pair_info table Table with pair information.
|
|
---@param opts table|nil Optional table `opts` for |nvim_set_keymap()|. Elements
|
|
--- `expr` and `noremap` won't be recognized (`true` by default).
|
|
MiniPairs.map = function(mode, lhs, pair_info, opts)
|
|
pair_info = H.validate_pair_info(pair_info)
|
|
opts = vim.tbl_deep_extend('force', opts or {}, { expr = true, noremap = true })
|
|
opts.desc = H.infer_mapping_description(pair_info)
|
|
|
|
vim.api.nvim_set_keymap(mode, lhs, H.pair_info_to_map_rhs(pair_info), opts)
|
|
H.register_pair(pair_info, mode, 'all')
|
|
|
|
-- Ensure that `<BS>` and `<CR>` are mapped for input mode
|
|
H.ensure_cr_bs(mode)
|
|
end
|
|
|
|
--- Make buffer mapping
|
|
---
|
|
--- This is a wrapper for |nvim_buf_set_keymap()| but instead of string right
|
|
--- hand side of mapping it expects table with pair information similar to one
|
|
--- in |MiniPairs.map|.
|
|
---
|
|
--- Using this function instead of |nvim_buf_set_keymap()| allows automatic
|
|
--- registration of pairs which will be recognized by `<BS>` and `<CR>`.
|
|
--- For Neovim>=0.7 it also infers mapping description from `pair_info`.
|
|
---
|
|
---@param buffer number `buffer` for |nvim_buf_set_keymap()|.
|
|
---@param mode string `mode` for |nvim_buf_set_keymap()|.
|
|
---@param lhs string `lhs` for |nvim_buf_set_keymap()|.
|
|
---@param pair_info table Table with pair information.
|
|
---@param opts table|nil Optional table `opts` for |nvim_buf_set_keymap()|.
|
|
--- Elements `expr` and `noremap` won't be recognized (`true` by default).
|
|
MiniPairs.map_buf = function(buffer, mode, lhs, pair_info, opts)
|
|
pair_info = H.validate_pair_info(pair_info)
|
|
opts = vim.tbl_deep_extend('force', opts or {}, { expr = true, noremap = true })
|
|
opts.desc = H.infer_mapping_description(pair_info)
|
|
|
|
vim.api.nvim_buf_set_keymap(buffer, mode, lhs, H.pair_info_to_map_rhs(pair_info), opts)
|
|
H.register_pair(pair_info, mode, buffer == 0 and vim.api.nvim_get_current_buf() or buffer)
|
|
|
|
-- Ensure that `<BS>` and `<CR>` are mapped for input mode
|
|
H.ensure_cr_bs(mode)
|
|
end
|
|
|
|
--- Remove global mapping
|
|
---
|
|
--- A wrapper for |nvim_del_keymap()| which registers supplied `pair`.
|
|
---
|
|
---@param mode string `mode` for |nvim_del_keymap()|.
|
|
---@param lhs string `lhs` for |nvim_del_keymap()|.
|
|
---@param pair __pairs_unregistered_pair
|
|
MiniPairs.unmap = function(mode, lhs, pair)
|
|
-- `pair` should be supplied explicitly
|
|
vim.validate({ pair = { pair, 'string' } })
|
|
|
|
-- Use `pcall` to allow 'deleting' already deleted mapping
|
|
pcall(vim.api.nvim_del_keymap, mode, lhs)
|
|
if pair == '' then return end
|
|
H.unregister_pair(pair, mode, 'all')
|
|
end
|
|
|
|
--- Remove buffer mapping
|
|
---
|
|
--- Wrapper for |nvim_buf_del_keymap()| which also unregisters supplied `pair`.
|
|
---
|
|
--- Note: this only reverts mapping done by |MiniPairs.map_buf|. If mapping was
|
|
--- done with |MiniPairs.map|, unmap for buffer in usual Neovim manner:
|
|
--- `inoremap <buffer> <*> <*>` (this maps `<*>` key to do the same it does by
|
|
--- default).
|
|
---
|
|
---@param buffer number `buffer` for |nvim_buf_del_keymap()|.
|
|
---@param mode string `mode` for |nvim_buf_del_keymap()|.
|
|
---@param lhs string `lhs` for |nvim_buf_del_keymap()|.
|
|
---@param pair __pairs_unregistered_pair
|
|
MiniPairs.unmap_buf = function(buffer, mode, lhs, pair)
|
|
-- `pair` should be supplied explicitly
|
|
vim.validate({ pair = { pair, 'string' } })
|
|
|
|
-- Use `pcall` to allow 'deleting' already deleted mapping
|
|
pcall(vim.api.nvim_buf_del_keymap, buffer, mode, lhs)
|
|
if pair == '' then return end
|
|
H.unregister_pair(pair, mode, buffer == 0 and vim.api.nvim_get_current_buf() or buffer)
|
|
end
|
|
|
|
--- Process "open" symbols
|
|
---
|
|
--- Used as |map-expr| mapping for "open" symbols in asymmetric pair ('(', '[',
|
|
--- etc.). If neighborhood doesn't match supplied pattern, function results
|
|
--- into "open" symbol. Otherwise, it pastes whole pair and moves inside pair
|
|
--- with |<Left>|.
|
|
---
|
|
--- Used inside |MiniPairs.map| and |MiniPairs.map_buf| for an actual mapping.
|
|
---
|
|
---@param pair __pairs_pair
|
|
---@param neigh_pattern __pairs_neigh_pattern
|
|
---
|
|
---@return string Keys performing "open" action.
|
|
MiniPairs.open = function(pair, neigh_pattern)
|
|
if H.is_disabled() or not H.neigh_match(neigh_pattern) then return pair:sub(1, 1) end
|
|
|
|
return ('%s%s'):format(pair, H.get_arrow_key('left'))
|
|
end
|
|
|
|
--- Process "close" symbols
|
|
---
|
|
--- Used as |map-expr| mapping for "close" symbols in asymmetric pair (')',
|
|
--- ']', etc.). If neighborhood doesn't match supplied pattern, function
|
|
--- results into "close" symbol. Otherwise it jumps over symbol to the right of
|
|
--- cursor (with |<Right>|) if it is equal to "close" one and inserts it
|
|
--- otherwise.
|
|
---
|
|
--- Used inside |MiniPairs.map| and |MiniPairs.map_buf| for an actual mapping.
|
|
---
|
|
---@param pair __pairs_pair
|
|
---@param neigh_pattern __pairs_neigh_pattern
|
|
---
|
|
---@return string Keys performing "close" action.
|
|
MiniPairs.close = function(pair, neigh_pattern)
|
|
if H.is_disabled() or not H.neigh_match(neigh_pattern) then return pair:sub(2, 2) end
|
|
|
|
local close = pair:sub(2, 2)
|
|
if H.get_cursor_neigh(1, 1) == close then
|
|
return H.get_arrow_key('right')
|
|
else
|
|
return close
|
|
end
|
|
end
|
|
|
|
--- Process "closeopen" symbols
|
|
---
|
|
--- Used as |map-expr| mapping for 'symmetrical' symbols (from pairs '""',
|
|
--- '\'\'', '``'). It tries to perform 'closeopen action': move over right
|
|
--- character (with |<Right>|) if it is equal to second character from pair or
|
|
--- conditionally paste pair otherwise (with |MiniPairs.open()|).
|
|
---
|
|
--- Used inside |MiniPairs.map| and |MiniPairs.map_buf| for an actual mapping.
|
|
---
|
|
---@param pair __pairs_pair
|
|
---@param neigh_pattern __pairs_neigh_pattern
|
|
---
|
|
---@return string Keys performing "closeopen" action.
|
|
MiniPairs.closeopen = function(pair, neigh_pattern)
|
|
if H.is_disabled() or H.get_cursor_neigh(1, 1) ~= pair:sub(2, 2) then
|
|
return MiniPairs.open(pair, neigh_pattern)
|
|
else
|
|
return H.get_arrow_key('right')
|
|
end
|
|
end
|
|
|
|
--- Process |<BS>|
|
|
---
|
|
--- Used as |map-expr| mapping for `<BS>` in Insert mode. It removes whole pair
|
|
--- (via executing `<Del>` after input key) if neighborhood is equal to a whole
|
|
--- pair recognized for current buffer. Pair is recognized for current buffer
|
|
--- if it is registered for global or current buffer mapping. Pair is
|
|
--- registered as a result of calling |MiniPairs.map| or |MiniPairs.map_buf|.
|
|
---
|
|
--- Mapped by default inside |MiniPairs.setup|.
|
|
---
|
|
--- This can be used to modify other Insert mode keys to respect neighborhood
|
|
--- pair. Examples: >
|
|
---
|
|
--- local map_bs = function(lhs, rhs)
|
|
--- vim.keymap.set('i', lhs, rhs, { expr = true, replace_keycodes = false })
|
|
--- end
|
|
---
|
|
--- map_bs('<C-h>', 'v:lua.MiniPairs.bs()')
|
|
--- map_bs('<C-w>', 'v:lua.MiniPairs.bs("\23")')
|
|
--- map_bs('<C-u>', 'v:lua.MiniPairs.bs("\21")')
|
|
---
|
|
---@param key string|nil Key to use. Default: `<BS>`.
|
|
---
|
|
---@return string Keys performing "backspace" action.
|
|
MiniPairs.bs = function(key)
|
|
local res = key or H.keys.bs
|
|
|
|
local neigh = H.get_cursor_neigh(0, 1)
|
|
if not H.is_disabled() and H.is_pair_registered(neigh, vim.fn.mode(), 0, 'bs') then
|
|
res = ('%s%s'):format(res, H.keys.del)
|
|
end
|
|
|
|
return res
|
|
end
|
|
|
|
--- Process |i_<CR>|
|
|
---
|
|
--- Used as |map-expr| mapping for `<CR>` in insert mode. It puts "close"
|
|
--- symbol on next line (via `<CR><C-o>O`) if neighborhood is equal to a whole
|
|
--- pair recognized for current buffer. Pair is recognized for current buffer
|
|
--- if it is registered for global or current buffer mapping. Pair is
|
|
--- registered as a result of calling |MiniPairs.map| or |MiniPairs.map_buf|.
|
|
---
|
|
--- Mapped by default inside |MiniPairs.setup|.
|
|
---
|
|
---@param key string|nil Key to use. Default: `<CR>`.
|
|
---
|
|
---@return string Keys performing "new line" action.
|
|
MiniPairs.cr = function(key)
|
|
local res = key or H.keys.cr
|
|
|
|
local neigh = H.get_cursor_neigh(0, 1)
|
|
if not H.is_disabled() and H.is_pair_registered(neigh, vim.fn.mode(), 0, 'cr') then
|
|
res = ('%s%s'):format(res, H.keys.above)
|
|
end
|
|
|
|
return res
|
|
end
|
|
|
|
-- Helper data ================================================================
|
|
-- Module default config
|
|
H.default_config = vim.deepcopy(MiniPairs.config)
|
|
|
|
-- Default value of `pair_info` for mapping functions
|
|
H.default_pair_info = { neigh_pattern = '..', register = { bs = true, cr = true } }
|
|
|
|
-- Pair sets registered *per mode-buffer-key*. Buffer `'all'` contains pairs
|
|
-- registered for all buffers.
|
|
H.registered_pairs = {
|
|
i = { all = { bs = {}, cr = {} } },
|
|
c = { all = { bs = {}, cr = {} } },
|
|
t = { all = { bs = {}, cr = {} } },
|
|
}
|
|
|
|
-- Precomputed keys to increase speed
|
|
-- stylua: ignore start
|
|
local function escape(s) return vim.api.nvim_replace_termcodes(s, true, true, true) end
|
|
H.keys = {
|
|
above = escape('<C-o>O'),
|
|
bs = escape('<bs>'),
|
|
cr = escape('<cr>'),
|
|
del = escape('<del>'),
|
|
keep_undo = escape('<C-g>U'),
|
|
-- NOTE: use `get_arrow_key()` instead of `H.keys.left` or `H.keys.right`
|
|
left = escape('<left>'),
|
|
right = escape('<right>')
|
|
}
|
|
-- stylua: ignore end
|
|
|
|
-- Helper functionality =======================================================
|
|
-- Settings -------------------------------------------------------------------
|
|
H.setup_config = function(config)
|
|
-- General idea: if some table elements are not present in user-supplied
|
|
-- `config`, take them from default config
|
|
vim.validate({ config = { config, 'table', true } })
|
|
config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})
|
|
|
|
-- Validate per nesting level to produce correct error message
|
|
vim.validate({
|
|
modes = { config.modes, 'table' },
|
|
mappings = { config.mappings, 'table' },
|
|
})
|
|
|
|
vim.validate({
|
|
['modes.insert'] = { config.modes.insert, 'boolean' },
|
|
['modes.command'] = { config.modes.command, 'boolean' },
|
|
['modes.terminal'] = { config.modes.terminal, 'boolean' },
|
|
})
|
|
|
|
local validate_mapping = function(pair_info, prefix)
|
|
-- Allow `false` to not create mapping
|
|
if pair_info == false then return end
|
|
H.validate_pair_info(pair_info, prefix)
|
|
end
|
|
|
|
validate_mapping(config.mappings['('], "mappings['(']")
|
|
validate_mapping(config.mappings['['], "mappings['[']")
|
|
validate_mapping(config.mappings['{'], "mappings['{']")
|
|
validate_mapping(config.mappings[')'], "mappings[')']")
|
|
validate_mapping(config.mappings[']'], "mappings[']']")
|
|
validate_mapping(config.mappings['}'], "mappings['}']")
|
|
validate_mapping(config.mappings['"'], "mappings['\"']")
|
|
validate_mapping(config.mappings["'"], 'mappings["\'"]')
|
|
validate_mapping(config.mappings['`'], "mappings['`']")
|
|
|
|
return config
|
|
end
|
|
|
|
H.apply_config = function(config)
|
|
MiniPairs.config = config
|
|
|
|
-- Setup mappings in supplied modes
|
|
local mode_ids = { insert = 'i', command = 'c', terminal = 't' }
|
|
-- Compute in which modes mapping should be set up
|
|
local mode_array = {}
|
|
for name, to_set in pairs(config.modes) do
|
|
if to_set then table.insert(mode_array, mode_ids[name]) end
|
|
end
|
|
|
|
local map_conditionally = function(mode, key, pair_info)
|
|
-- Allow `false` to not create mapping
|
|
if pair_info == false then return end
|
|
|
|
-- This also should take care of mapping `<BS>` and `<CR>`
|
|
MiniPairs.map(mode, key, pair_info)
|
|
end
|
|
|
|
for _, mode in pairs(mode_array) do
|
|
for key, pair_info in pairs(config.mappings) do
|
|
map_conditionally(mode, key, pair_info)
|
|
end
|
|
end
|
|
end
|
|
|
|
H.create_autocommands = function()
|
|
local augroup = vim.api.nvim_create_augroup('MiniPairs', {})
|
|
|
|
local au = function(event, pattern, callback, desc)
|
|
vim.api.nvim_create_autocmd(event, { group = augroup, pattern = pattern, callback = callback, desc = desc })
|
|
end
|
|
|
|
au('FileType', { 'TelescopePrompt', 'fzf' }, function() vim.b.minipairs_disable = true end, 'Disable locally')
|
|
end
|
|
|
|
H.is_disabled = function() return vim.g.minipairs_disable == true or vim.b.minipairs_disable == true end
|
|
|
|
-- Pair registration ----------------------------------------------------------
|
|
H.register_pair = function(pair_info, mode, buffer)
|
|
-- Process new mode
|
|
H.registered_pairs[mode] = H.registered_pairs[mode] or { all = { bs = {}, cr = {} } }
|
|
local mode_pairs = H.registered_pairs[mode]
|
|
|
|
-- Process new buffer
|
|
mode_pairs[buffer] = mode_pairs[buffer] or { bs = {}, cr = {} }
|
|
|
|
-- Register pair if it is not already registered
|
|
local register, pair = pair_info.register, pair_info.pair
|
|
if register.bs and not vim.tbl_contains(mode_pairs[buffer].bs, pair) then
|
|
table.insert(mode_pairs[buffer].bs, pair)
|
|
end
|
|
if register.cr and not vim.tbl_contains(mode_pairs[buffer].cr, pair) then
|
|
table.insert(mode_pairs[buffer].cr, pair)
|
|
end
|
|
end
|
|
|
|
H.unregister_pair = function(pair, mode, buffer)
|
|
local mode_pairs = H.registered_pairs[mode]
|
|
if not (mode_pairs and mode_pairs[buffer]) then return end
|
|
|
|
local buf_pairs = mode_pairs[buffer]
|
|
for _, key in ipairs({ 'bs', 'cr' }) do
|
|
for i, p in ipairs(buf_pairs[key]) do
|
|
if p == pair then table.remove(buf_pairs[key], i) end
|
|
end
|
|
end
|
|
end
|
|
|
|
H.is_pair_registered = function(pair, mode, buffer, key)
|
|
local mode_pairs = H.registered_pairs[mode]
|
|
if not mode_pairs then return false end
|
|
|
|
if vim.tbl_contains(mode_pairs['all'][key], pair) then return true end
|
|
|
|
buffer = buffer == 0 and vim.api.nvim_get_current_buf() or buffer
|
|
local buf_pairs = mode_pairs[buffer]
|
|
if not buf_pairs then return false end
|
|
|
|
return vim.tbl_contains(buf_pairs[key], pair)
|
|
end
|
|
|
|
H.ensure_cr_bs = function(mode)
|
|
local has_any_cr_pair, has_any_bs_pair = false, false
|
|
for _, pair_tbl in pairs(H.registered_pairs[mode]) do
|
|
has_any_cr_pair = has_any_cr_pair or not vim.tbl_isempty(pair_tbl.cr)
|
|
has_any_bs_pair = has_any_bs_pair or not vim.tbl_isempty(pair_tbl.bs)
|
|
end
|
|
|
|
-- NOTE: this doesn't distinguish between global and buffer mappings. Both
|
|
-- `<BS>` and `<CR>` should work as normal even if no pairs are registered
|
|
if has_any_bs_pair then
|
|
-- Use not `silent` in Command mode to make it redraw
|
|
local opts = { silent = mode ~= 'c', expr = true, replace_keycodes = false, desc = 'MiniPairs <BS>' }
|
|
H.map(mode, '<BS>', 'v:lua.MiniPairs.bs()', opts)
|
|
end
|
|
if mode == 'i' and has_any_cr_pair then
|
|
local opts = { expr = true, replace_keycodes = false, desc = 'MiniPairs <CR>' }
|
|
H.map(mode, '<CR>', 'v:lua.MiniPairs.cr()', opts)
|
|
end
|
|
end
|
|
|
|
-- Work with pair_info --------------------------------------------------------
|
|
H.validate_pair_info = function(pair_info, prefix)
|
|
prefix = prefix or 'pair_info'
|
|
vim.validate({ [prefix] = { pair_info, 'table' } })
|
|
pair_info = vim.tbl_deep_extend('force', H.default_pair_info, pair_info)
|
|
|
|
vim.validate({
|
|
[prefix .. '.action'] = { pair_info.action, 'string' },
|
|
[prefix .. '.pair'] = { pair_info.pair, 'string' },
|
|
[prefix .. '.neigh_pattern'] = { pair_info.neigh_pattern, 'string' },
|
|
[prefix .. '.register'] = { pair_info.register, 'table' },
|
|
})
|
|
|
|
vim.validate({
|
|
[prefix .. '.register.bs'] = { pair_info.register.bs, 'boolean' },
|
|
[prefix .. '.register.cr'] = { pair_info.register.cr, 'boolean' },
|
|
})
|
|
|
|
return pair_info
|
|
end
|
|
|
|
H.pair_info_to_map_rhs = function(pair_info)
|
|
return ('v:lua.MiniPairs.%s(%s, %s)'):format(
|
|
pair_info.action,
|
|
vim.inspect(pair_info.pair),
|
|
vim.inspect(pair_info.neigh_pattern)
|
|
)
|
|
end
|
|
|
|
H.infer_mapping_description = function(pair_info)
|
|
local action_name = pair_info.action:sub(1, 1):upper() .. pair_info.action:sub(2)
|
|
return ('%s action for %s pair'):format(action_name, vim.inspect(pair_info.pair))
|
|
end
|
|
|
|
-- Utilities ------------------------------------------------------------------
|
|
H.get_cursor_neigh = function(start, finish)
|
|
local line, col
|
|
if vim.fn.mode() == 'c' then
|
|
line = vim.fn.getcmdline()
|
|
col = vim.fn.getcmdpos()
|
|
-- Adjust start and finish because output of `getcmdpos()` starts counting
|
|
-- columns from 1
|
|
start = start - 1
|
|
finish = finish - 1
|
|
else
|
|
line = vim.api.nvim_get_current_line()
|
|
col = vim.api.nvim_win_get_cursor(0)[2]
|
|
end
|
|
|
|
-- Add '\r' and '\n' to always return 2 characters
|
|
return string.sub(('%s%s%s'):format('\r', line, '\n'), col + 1 + start, col + 1 + finish)
|
|
end
|
|
|
|
H.neigh_match = function(pattern) return (pattern == nil) or (H.get_cursor_neigh(0, 1):find(pattern) ~= nil) end
|
|
|
|
H.get_arrow_key = function(key)
|
|
if vim.fn.mode() == 'i' then
|
|
-- Using left/right keys in insert mode breaks undo sequence and, more
|
|
-- importantly, dot-repeat. To avoid this, use 'i_CTRL-G_U' mapping.
|
|
return H.keys.keep_undo .. H.keys[key]
|
|
else
|
|
return H.keys[key]
|
|
end
|
|
end
|
|
|
|
H.map = function(mode, lhs, rhs, opts)
|
|
if lhs == '' then return end
|
|
opts = vim.tbl_deep_extend('force', { silent = true }, opts or {})
|
|
vim.keymap.set(mode, lhs, rhs, opts)
|
|
end
|
|
|
|
return MiniPairs
|