8000 mini.nvim/lua/mini/pairs.lua at main · marcelmanz/mini.nvim · GitHub
[go: up one dir, main page]
Skip to content

pairs.lua

Latest commit

 

History

History
649 lines (569 loc) · 26.2 KB

pairs.lua

File metadata and controls

649 lines (569 loc) · 26.2 KB
Raw
--- *mini.pairs* Autopairs
---
--- MIT License Copyright (c) 2021 Evgeni Chasnovski
--- Features:
--- - Functionality to work with two "paired" characters conditional on cursor's
--- neighborhood (character to its left and character to its 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 for special <BS> (all configured modes)
--- and <CR> (only Insert mode) mappings. Pressing the key inside pair will
--- delete whole pair and insert extra blank line inside pair respectively.
--- Note: these mappings are autocreated if they do not override existing ones.
---
--- What it doesn't do:
--- - Provide smart behavior, like based on bracket balance. The default behavior
--- is to almost always perform an action (insert pair, jump over). Manually
--- press |i_CTRL-V| before a character to explicitly insert it (and only it).
---
--- - 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 ~
--- >lua
--- -- 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>
--- local lt_opts = {
--- action = 'open',
--- pair = '<>',
--- neigh_pattern = '\r.',
--- register = { cr = false },
--- }
--- MiniPairs.map('i', '<', lt_opts)
---
--- local gt_opts = { action = 'close', pair = '<>', register = { cr = false } }
--- MiniPairs.map('i', '>', gt_opts)
---
--- -- Create symmetrical `$$` pair only in Tex files
--- local map_tex = function()
--- MiniPairs.map_buf(0, 'i', '$', { action = 'closeopen', pair = '$$' })
--- end
--- vim.api.nvim_create_autocmd(
--- 'FileType',
--- { pattern = 'tex', callback = map_tex }
--- )
--- <
--- # Notes ~
---
--- - Make sure to make proper mapping of <CR> in order to support completion
--- plugin of your choice:
--- - For |mini.completion| 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.
---@tag MiniPairs
---@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 >lua
--- require('mini.pairs').setup() -- use default config
--- -- OR
--- require('mini.pairs').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
--stylua: ignore
--- Defaults ~
---@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.
---
--- Using this function instead of |nvim_set_keymap()| allows automatic
--- registration of pairs which will be recognized by <BS> and <CR>.
--- 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. Fields:
--- - <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.
--- Can contain multibyte characters.
--- - <neigh_pattern> - optional 'two character' neighborhood pattern to be
--- used as argument for action function. Note: neighborhood might contain
--- multiple characters.
--- Default: `'..'` (no restriction from neighborhood).
--- - <register> - optional table with information about whether this pair will
--- be recognized by <BS> (in |MiniPairs.bs()|) and/or <CR> (in |MiniPairs.cr()|).
--- Should have boolean fields <bs> and <cr> (both `true` by default).
---@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>.
--- 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
H.check_type('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()|, revert to default behavior for buffer: >lua
---
--- -- Map `X` key to do the same it does by default
--- vim.keymap.set('i', 'X', 'X', { buffer = true })
--- <
---@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
H.check_type('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 H.get_open_char(pair) end
-- Temporarily redraw lazily for no cursor flicker due to `<Left>`.
-- This can happen in a big file with tree-sitter highlighting enabled.
H.with_temp_option('lazyredraw', true)
-- NOTE: Do not ensure no wildmenu because by the time arrow is executed
-- wildmenu should already (usually) be hidden due to inserting `pair`
return 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)
local close = H.get_close_char(pair)
local move_right = not H.is_disabled() and H.neigh_match(neigh_pattern) and H.get_neigh('right') == close
return move_right and H.get_arrow_key('right', true) or close
end
--- Process "closeopen" symbols
---
--- Used as |:map-<expr>| mapping for 'symmetrical' symbols (like " and ')
--- 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)
local move_right = not H.is_disabled() and H.get_neigh('right') == H.get_close_char(pair)
return move_right and H.get_arrow_key('right', true) or MiniPairs.open(pair, neigh_pattern)
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: >lua
---
--- 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, neigh = key or H.keys.bs, H.get_neigh('whole')
local do_extra = not H.is_disabled() and H.is_pair_registered(neigh, vim.fn.mode(), 'bs')
return do_extra and (res .. H.keys.del) or 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()|.
---
--- Note: some relevant mode changing events are temporarily ignored
--- (with |'eventignore'|) to counter effect of using |i_CTRL-O|.
---
--- 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_neigh('whole')
if H.is_disabled() or not H.is_pair_registered(neigh, vim.fn.mode(), 'cr') then return res end
-- Temporarily ignore mode change to not trigger some common expensive
-- autocommands (like diagnostic check, etc.)
H.with_temp_option('eventignore', 'InsertLeave,InsertLeavePre,InsertEnter,TextChanged,ModeChanged')
-- Temporarily redraw lazily for no cursor flicker due to `<C-o>O`.
-- This can happen in a big file with tree-sitter highlighting enabled.
H.with_temp_option('lazyredraw', true)
return res .. H.keys.above
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>'),
ctrl_y = escape('<C-y>'),
-- Using left/right keys in insert mode breaks undo sequence and, more
-- importantly, dot-repeat. To avoid this, use 'i_CTRL-G_U' mapping.
-- Use `H.get_arrow_key()` for keys instead of direct from this table.
left = escape('<Left>'),
right = escape('<Right>'),
left_undo = escape('<C-g>U<Left>'),
right_undo = escape('<C-g>U<Right>'),
}
-- stylua: ignore end
-- Cache for temporary set options
H.options_cache = {}
-- Helper functionality =======================================================
-- Settings -------------------------------------------------------------------
H.setup_config = function(config)
H.check_type('config', config, 'table', true)
config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})
H.check_type('modes', config.modes, 'table')
H.check_type('modes.insert', config.modes.insert, 'boolean')
H.check_type('modes.command', config.modes.command, 'boolean')
H.check_type('modes.terminal', config.modes.terminal, 'boolean')
H.check_type('mappings', config.mappings, 'table')
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 gr = vim.api.nvim_create_augroup('MiniPairs', {})
local au = function(event, pattern, callback, desc)
vim.api.nvim_create_autocmd(event, { group = gr, 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
local buf_pairs = mode_pairs[buffer] or { bs = {}, cr = {} }
mode_pairs[buffer] = buf_pairs
-- Register pair in a buffer or 'all'. NOTE: ensure to add entry only if
-- `register[key]` is `true` for a faster check in `is_pair_registered`.
local register, pair = pair_info.register, pair_info.pair
buf_pairs.bs[pair] = register.bs == true and true or nil
buf_pairs.cr[pair] = register.cr == true and true or nil
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]
buf_pairs.bs[pair], buf_pairs.cr[pair] = nil, nil
end
H.is_pair_registered = function(pair, mode, key)
local mode_pairs = H.registered_pairs[mode]
if not mode_pairs then return false end
if mode_pairs['all'][key][pair] then return true end
local buf_pairs = mode_pairs[vim.api.nvim_get_current_buf()]
if not buf_pairs then return false end
return buf_pairs[key][pair] == true
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
-- NOTE: do not autocreate mappings if there is already one present. This
-- allows creating more complicated `<CR>`/`<BS>` mappings and not worry
-- about the initialization/setup order.
if has_any_bs_pair and vim.fn.maparg('<BS>', mode) == '' 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 and vim.fn.maparg('<CR>', mode) == '' 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(x, prefix)
prefix = prefix or 'pair_info'
H.check_type(prefix, x, 'table')
x = vim.tbl_deep_extend('force', H.default_pair_info, x)
H.check_type(prefix .. '.action', x.action, 'string')
H.check_type(prefix .. '.pair', x.pair, 'string')
H.check_type(prefix .. '.neigh_pattern', x.neigh_pattern, 'string')
H.check_type(prefix .. '.register', x.register, 'table')
H.check_type(prefix .. '.register.bs', x.register.bs, 'boolean')
H.check_type(prefix .. '.register.cr', x.register.cr, 'boolean')
return x
end
H.pair_info_to_map_rhs = function(x)
return string.format('v:lua.MiniPairs.%s(%s, %s)', x.action, vim.inspect(x.pair), vim.inspect(x.neigh_pattern))
end
H.infer_mapping_description = function(x)
local action_name = x.action:sub(1, 1):upper() .. x.action:sub(2)
return string.format('%s action for %s pair', action_name, vim.inspect(x.pair))
end
-- Utilities ------------------------------------------------------------------
H.error = function(msg) error('(mini.pairs) ' .. msg, 0) end
H.check_type = function(name, val, ref, allow_nil)
if type(val) == ref or (ref == 'callable' and vim.is_callable(val)) or (allow_nil and val == nil) then return end
H.error(string.format('`%s` should be %s, not %s', name, ref, type(val)))
end
H.get_neigh = function(neigh_type)
local is_command_mode = vim.fn.mode() == 'c'
-- Get line and add '\r' and '\n' to always return 2 characters
local line = is_command_mode and vim.fn.getcmdline() or vim.api.nvim_get_current_line()
line = '\r' .. line .. '\n'
-- Get start character index accounting for added '\r' at the start
local start = is_command_mode and vim.fn.charidx(line, vim.fn.getcmdpos()) or vim.fn.charcol('.')
start = start - 1
return vim.fn.strcharpart(line, start + (neigh_type == 'right' and 1 or 0), neigh_type == 'whole' and 2 or 1)
end
H.neigh_match = function(pattern) return H.get_neigh('whole'):find(pattern or '') ~= nil end
H.get_open_char = function(x) return vim.fn.strcharpart(x, 0, 1) end
H.get_close_char = function(x) return vim.fn.strcharpart(x, 1, 1) end
H.get_arrow_key = function(key, ensure_no_wildmenu)
if vim.fn.mode() == 'i' then
-- Take into account that `virtualedit=all` can go into inline virtual text
H.with_temp_option('virtualedit', 'none')
return key == 'right' and H.keys.right_undo or H.keys.left_undo
end
local prefix = ''
-- In Command-line mode <Left> / <Right> act like <C-p> / <C-n> if wildmenu
-- is shown. Make sure that arrow key moves cursor.
if vim.fn.mode() == 'c' and ensure_no_wildmenu then prefix = vim.fn.wildmenumode() == 1 and H.keys.ctrl_y or '' end
return prefix .. (key == 'right' and H.keys.right or H.keys.left)
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
H.with_temp_option = function(name, value)
-- Cache option only once to not override it later with temporary set value
-- Like in case of `nvim_feedkeys('(\r(\r')`
if H.options_cache[name] == nil then H.options_cache[name] = vim.o[name] end
vim.o[name] = value
H.restore_option_later(name)
end
H.restore_option_later = vim.schedule_wrap(function(name)
if H.options_cache[name] == nil then return end
vim.o[name] = H.options_cache[name]
H.options_cache[name] = nil
end)
return MiniPairs
0