Something went wrong. Try again.
Library of 45+ independent Lua modules improving Neovim experience with minimal effort nvim-mini.org/mini.nvim
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658--- *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 its `# Helpful 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) -- TODO: Remove after Neovim=0.9 support is dropped if vim.fn.has('nvim-0.10') == 0 then vim.notify( '(mini.pairs) Neovim<0.10 is soft deprecated (module works but is not supported).' .. " It will be deprecated after the next 'mini.nvim' release (module might not work)." .. ' Please update your Neovim version.' ) end
-- 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 the 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 passed to an action function.--- Can contain multibyte characters.--- - <neigh_pattern> - optional neighborhood pattern to be passed to an action--- function. Will be matched against two character neighborhood (might--- contain multibyte 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_pairMiniPairs.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_pairMiniPairs.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 closeend
--- 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 resend
--- 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.aboveend
-- Helper data ================================================================-- Module default configH.default_config = vim.deepcopy(MiniPairs.config)
-- Default value of `pair_info` for mapping functionsH.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 startlocal function escape(s) return vim.api.nvim_replace_termcodes(s, true, true, true) endH.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 optionsH.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 configend
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 endend
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 nilend
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, nilend
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] == trueend
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) endend
-- 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 xend
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) endH.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] = nilend)
return MiniPairs