mini.nvim/lua/mini/cmdline.lua at main · JanValiska/mini.nvim

Repository navigation

--- *mini.cmdline* Command line tweaks
--- MIT License Copyright (c) 2025 Evgeni Chasnovski
--- Features:
--- - Autocomplete with customizable delay. Enhances |cmdline-completion| and
---   manual |'wildchar'| pressing experience.
---   Requires Neovim>=0.11, though Neovim>=0.12 is recommended.
--- - Autocorrect words as-you-type. Only words that must come from a fixed set of
---   candidates (like commands and options) are autocorrected by default.
--- - Autopeek command range as-you-type. Shows a floating window with range lines
---   along with customizable context lines.
--- What it doesn't do:
--- - Customization of command line UI. Use |vim._extui| (on Neovim>=0.12).
--- - Customization of autocompletion candidates. They are computed
---   via |cmdline-completion|.
--- # Setup ~
--- This module needs a setup with `require('mini.cmdline').setup({})` (replace `{}`
--- with your `config` table). It will create global Lua table `MiniCmdline` which
--- you can use for scripting or manually (with `:lua MiniCmdline.*`).
--- See |MiniCmdline.config| for `config` structure and default values.
--- You can override runtime config settings locally to buffer inside
--- `vim.b.minicmdline_config` which should have same structure as
--- `MiniCmdline.config`. See |mini.nvim-buffer-local-config| for more details.
--- # Suggested option values ~
--- Some options are set automatically (if not set before |MiniCmdline.setup()|):
--- - |'wildmode'| is set to "noselect,full" for less intrusive autocompletion.
---   Requires Neovim>=0.11 and enabled `config.autocomplete`.
--- - |'wildoptions'| is set to "pum,fuzzy" to enable fuzzy matching.
--- # Comparisons ~
--- - [folke/noice.nvim](https://github.com/folke/noice.nvim):
---     - Mostly focuses on visual aspects of the Command line.
---       This modules is aimed to improve its workflow without changing UI.
--- - [nacro90/numb.nvim](https://github.com/nacro90/numb.nvim):
---     - Designed to preview only a single line range defined by numbers.
---       This module handles any form of |:range| and |:range-offset| for both
---       one and two line ranges.
---     - Shows target line directly in the normal window.
---       This module uses a dedicated floating window.
--- - Built-in |cmdline-autocompletion| (on Neovim>=0.12):
---     - This module on Neovim>=0.12 uses that as its base for autocompletion.
---       Ont top of that it also provides customizable delay and predicate.
--- - Built-in |vim._extui| (on Neovim>=0.12):
---     - Mostly focuses on visual aspects of the Command line.
---       This modules is aimed to improve its workflow without changing UI.
--- # Highlight groups ~
--- - `MiniCmdlinePeekBorder` - border of autopeek window.
--- - `MiniCmdlinePeekLineNr` - line numbers in autopeek window.
--- - `MiniCmdlinePeekNormal` - basic foreground/background of autopeek window.
--- - `MiniCmdlinePeekSep` - statuscolumn separator in autopeek window.
--- - `MiniCmdlinePeekSign` - signs in autopeek window.
--- - `MiniCmdlinePeekTitle` - title of autopeek window.
--- # Disabling ~
--- To disable acting in mappings, set `vim.g.minicmdline_disable` (globally) or
--- `vim.b.minicmdline_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 MiniCmdline
---@diagnostic disable:undefined-field
---@diagnostic disable:discard-returns
---@diagnostic disable:unused-local
-- Module definition ==========================================================
local MiniCmdline = {}
local H = {}
--- Module setup
---@param config table|nil Module config table. See |MiniCmdline.config|.
---@usage >lua
---   require('mini.cmdline').setup() -- use default config
---   -- OR
---   require('mini.cmdline').setup({}) -- replace {} with your config table
MiniCmdline.setup = function(config)
  -- TODO: Remove after Neovim=0.9 support is dropped
  if vim.fn.has('nvim-0.10') == 0 then
    vim.notify(
      '(mini.cmdline) 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.'
  -- Export module
  _G.MiniCmdline = MiniCmdline
  -- Setup config
  config = H.setup_config(config)
  -- Apply config
  H.apply_config(config)
  -- Define behavior
  H.create_autocommands()
  -- Create default highlighting
  H.create_default_hl()
--- Defaults ~
---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)
---@text # General ~
--- - Each feature is configured via separate table.
--- - Use `enable = false` to disable a feature.
---# Autocomplete ~
--- `config.autocomplete` is used to configure autocompletion: automatic show
--- of |'wildmenu'|.
--- `autocomplete.delay` defines a (debounce style) delay after which |'wildchar'|
--- is triggered to show wildmenu.
--- Default: 0. Note: Neovim>=0.12 is recommended for positive values if you
--- want to reduce flicker (thanks to |wildtrigger()|).
--- `autocomplete.predicate` defines a condition of whether to trigger completion
--- at the current command line state. Takes a table with input data and should
--- return `true` to show completion and `false` otherwise. Will be called before
--- the possible delay at current command line state.
--- Default: |MiniCmdline.default_autocomplete_predicate()|.
--- Input data fields:
--- - <line> `(string)` - current command line text. See |getcmdline()|.
--- - <pos> `(number)` - current command line column. See |getcmdpos()|.
--- - <line_prev> `(string)` - command line text before the latest change.
--- - <pos_prev> `(number)` - command line column before the latest cursor move.
--- Example of blocking completion based on completion type (as some may be slow): >lua
---   local block_compltype = { shellcmd = true }
---   require('mini.cmdline').setup({
---     autocomplete = {
---       predicate = function()
---         return not block_compltype[vim.fn.getcmdcompltype()]
---       end,
--- Similar approach can be used to enable completion only for normal Ex commands.
--- Use `return vim.fn.getcmdtype() == ':'` as a predicate output.
---# Autocorrect ~
--- `config.autocorrect` is used to configure autocorrection: automatic adjustment
--- of bad words as you type them. This works only when appending single character
--- at the end of the command line. Editing already typed words does not trigger
--- autocorrect (allows correcting the autocorrection).
--- When to autocorrect is computed automatically based on |getcmdcomplpat()| after
--- every key press: if it doesn't add the character to completion pattern, then
--- the pattern before the key press is attempted to be corrected.
--- There is also an autocorrection attempt for the last word just before
--- executing the command.
--- - This is intended mostly for fixing typos and not as a shortcut for fuzzy
---   matching. Performing the latter automatically is too intrusive. Explicitly
---   use fuzzy completion for that (set up by default).
--- - Default autocorrection is done only for words that must come from a fixed
---   set of candidates (like commands and options) by choosing the one with
---   the lowest string distance.
---   See |MiniCmdline.default_autocorrect_func()| for details.
--- - Word that matches some Command-line |abbreviation| is not autocorrected.
--- - If current command expects only a single argument (like |:colorscheme|), then
---   autocorrection will happen only just before executing the command.
--- `autocorrect.func` is a function that can be used to customize autocorrection.
--- Takes a table with input data and should return a string with the correct word
--- or `nil` for no autocorrection. Default: |MiniCmdline.default_autocorrect_func()|.
--- Input data fields:
--- - <word> `(string)` - word to be autocorrected. Never empty string.
--- - <type> `(string)` - word type. Output of |getcmdcompltype()|.
---# Autopeek ~
--- `config.autopeek` is used to configure automatic peeking: show command's target
--- range in a floating window. The window will appear above command line and show
--- current buffer with the focus on left and right (if present and differs from
--- left) range lines.
--- `autopeek.n_context` defines how many lines to show above and below the target.
--- The range itself is visualized by default with the statuscolumn signs.
--- Default: 1.
--- `autopeek.predicate` defines a condition of whether to show peek window at
--- the current command line state. Takes a table with input data and should
--- return `true` to peek and `false` otherwise.
--- Will be called only if it is possible to parse range from the current command
--- line text and it is for buffer lines (no command or |:command-addr| is `lines`)
--- Default: |MiniCmdline.default_autopeek_predicate()|.
--- Input data fields:
--- - <left> `(number)` - left range edge. Not necessarily smallest.
--- - <right> `(number)` - right range edge. Same as `left` for a single line range.
--- - <cmd> `(string)` - full command name. Can be empty string if no valid
---   command is (yet) entered.
--- `autopeek.window` defines behavior of a peek window.
--- `autopeek.window.config` is a table defining floating window characteristics
--- or a callable returning such table.
--- It should have the same structure as in |nvim_open_win()|.
--- `autopeek.window.statuscolumn` is a special function that can be used to
--- customize |'statuscolumn'| value for the peek window. Takes a table with input
--- data and should return a string to display for line |v:lnum|.
--- Default: |MiniCmdline.default_autopeek_statuscolumn()|.
--- Input data fields are the same as for `autopeek.predicate`.
--- Example of showing `<` and `>` signs on range lines: >lua
---   function(data)
---     local n, l, r = vim.v.lnum, data.left, data.right
---     local s = n == l and (n == r and '* ' or '< ') or n == r and '> ' or ''
---     -- Needs explicit highlighting via `:h 'statusline'` syntax
---     return '%#MiniCmdlinePeekSign#' .. s
--- - Peek window directly shows current buffer, which means that all its
---   extmarks, virtual text, virtual lines, etc. are also shown.
--- - Non-zero context might work unreliably if there are virtual lines.
--- - Peeking intentionally hides Visual selection if Command-line mode is entered
---   directly from it. Peeking `'<,'>` range already visualizes the selection.
---   To disable autopeek for this case, add the following code BEFORE
---   executing `require('mini.cmdline').setup()`: >lua
---     local disable = vim.schedule_wrap(function()
---       local is_from_visual = vim.startswith(vim.fn.getcmdline(), "'<,'>")
---       MiniCmdline.config.autopeek.enable = not is_from_visual
---     end)
---     local reenable = function() MiniCmdline.config.autopeek.enable = true end
---     vim.api.nvim_create_autocmd('CmdlineEnter', { callback = disable })
---     vim.api.nvim_create_autocmd('CmdlineLeave', { callback = reenable })
MiniCmdline.config = {
  -- Autocompletion: show `:h 'wildmenu'` as you type
  autocomplete = {
    enable = true,
    -- Delay (in ms) after which to trigger completion
    -- Neovim>=0.12 is recommended for positive values
    delay = 0,
    -- Custom rule of when to trigger completion
    predicate = nil,
    -- Whether to map arrow keys for more consistent wildmenu behavior
    map_arrows = true,
  -- Autocorrection: adjust non-existing words (commands, options, etc.)
  autocorrect = {
    enable = true,
    -- Custom autocorrection rule
    func = nil,
  -- Autopeek: show command's target range in a floating window
  autopeek = {
    enable = true,
    -- Number of lines to show above and below range lines
    n_context = 1,
    -- Custom rule of when to show peek window
    predicate = nil,
    -- Window options
    window = {
      -- Floating window config
      config = {},
      -- Function to render statuscolumn
      statuscolumn = nil,
--minidoc_afterlines_end
--- Default autocompletion predicate
---@param data table Input autocompletion data. As described in |MiniCmdline.config|.
---@param opts table|nil Options. Reserved for future use.
---@return boolean If command line does not (yet) contain a letter - `false`,
---   otherwise - `true`. This makes autopeek easier to use for a numerical range.
MiniCmdline.default_autocomplete_predicate = function(data, opts) return data.line:find('%a') ~= nil end
--- Default autocorrection function
--- - Return input word if `opts.strict_type=true` and input `type` is not proper.
--- - Get candidates via `opts.get_candidates()`.
---   Default: mostly via |getcompletion()| with empty pattern and input `type`.
---   Exceptions are `help` and `option` types: both list all available candidates
---   in their own ways.
--- - Choose the candidate with the lowest Damerau–Levenshtein distance
---   (smallest number of deletion/insertion/substitution/transposition needed
---   to transform one word into another; slightly prefers transposition).
---   Notes:
---     - Type `'command'` also chooses from all valid candidate abbreviations.
---     - Comparison is done both respecting and ignoring case.
---@param data table Input autocorrection data. As described in |MiniCmdline.config|.
---@param opts table|nil Options. Possible fields:
---   - <strict_type> `(boolean)` - whether to restrict output only for types which
---     must have words from a fixed set of candidates (like command or option
---     names). Note: does not include `help` type since |:help| already has
---     "sophisticated algorithm" to handle typos. Default: `true`.
---   - <get_candidates> `(function)` - source of candidates. Will be called
---     with `data` as argument and should return array of string candidates to
---     choose from.
---     Default: for most types -  |getcompletion()| with empty pattern and
---     input `type`; for `help` and `option` type - all available help tags and
---     option names (long and short) respectively.
---@return string Autocorrected word.
MiniCmdline.default_autocorrect_func = function(data, opts)
  H.check_type('data', data, 'table')
  H.check_type('data.word', data.word, 'string')
  H.check_type('data.type', data.type, 'string')
  opts = opts or {}
  local strict_type = opts.strict_type == nil or opts.strict_type
  if strict_type and not H.autocorrect_strict_types[data.type] then return data.word end
  -- Get all valid words
  local all = vim.is_callable(opts.get_candidates) and opts.get_candidates(data) or H.get_autocorrect_candidates(data)
  if vim.tbl_contains(all, data.word) or data.word == '' then return data.word end
  -- Make results stable in case several candidates have the same distance
  table.sort(all)
  -- Handle commands separately: need dedicated abbreviation length
  -- computation and to allow `!`
  if data.type == 'command' then return H.get_nearest_command(data.word, all) end
  -- Fall back to computing nearest string without allowing abbreviations
  local abbr_lens = vim.tbl_map(string.len, all)
  return H.get_nearest_abbr(data.word, all, abbr_lens)
--- Default autopeek predicate
---@param data table Input autopeek data. As described in |MiniCmdline.config|.
---@param opts table|nil Options. Reserved for future use.
---@return boolean If command defines |:command-preview| - `false`, otherwise - `true`.
---   This makes autopeek easier to use for commands like |:substitute|,
---   especially if |'inccommand'| is set to `split`.
MiniCmdline.default_autopeek_predicate = function(data, opts)
  local cmd_preview_map = H.cache.cmd_preview_map or H.get_cmd_preview_map()
  return cmd_preview_map[data.cmd] ~= true
--- Default autopeek statuscolumn
--- - Show signs next to lines depending on their relation to peeked range.
---   Highlighted with `MiniCmdlinePeekSign` group.
--- - Show line numbers for left and right parts of the range.
---   Highlighted with `MiniCmdlinePeekLineNr` group.
--- - Separate statuscolumn and buffer text with dedicated separator character.
---   Highlighted with `MiniCmdlinePeekSep` group.
--- - Intended to only be used as a part of |'statuscolumn'| function, as it
---   uses |v:lnum| and |v:virtnum| to compute the output.
--- Example of adjusting a `mid` sign: >lua
---   local peek_stc_opts = { signs = { mid = '+' } }
---   local peek_stc = function(data)
---     return MiniCmdline.default_autopeek_statuscolumn(data, peek_stc_opts)
---   require('mini.cmdline').setup({
---     autopeek = { window = { statuscolumn = peek_stc } },
---@param data table Input peek data. As described in |MiniCmdline.config|.
---@param opts table|nil Options. Possible fields:
---   - <signs> `(table)` - signs to show. Possible fields:
---       - <same> `(string)` - on range if `left=right`. Default: `'🭬'`.
---       - <left> `(string)`  - on `left` line.  Default: `'┌'`.
---       - <mid> `(string)`   - inside range.  Default: `'┊'`.
---       - <right> `(string)` - on `right` line. Default: `'└'`.
---       - <out> `(string)` - outside of range. Default: `''` (no sign).
---       - <virt> `(string)` - virtual line. Default: `'•'`.
---       - <wrap> `(string)` - wrapped line. Default: `'↳'`.
---   - <sep> `(string)` - string to put at the end to separate statuscolumn and
---     buffer text. Default: `'│'`
---   Note: Any sign and separator should have every `%` escaped as `%%` (due to its
---   special meaning in |'statuscolumn'|).
MiniCmdline.default_autopeek_statuscolumn = function(data, opts)
  opts = opts or {}
  local signs = opts.signs or {}
  local sep_format = opts.sep == nil and '│' or opts.sep:gsub('%%', '%%%%')
  if vim.v.virtnum ~= 0 then
    local sign = (vim.v.virtnum < 0 and (signs.virt or '•') or (signs.wrap or '↳'))
    -- Format as `sign %= sep-hl sep`
    return sign .. '%=%#MiniCmdlinePeekSep#' .. sep_format:gsub('%%%%', '%%')
  local n, l, r = vim.v.lnum, data.left, data.right
  -- Format as `sign-hl sign linenr-hl %= linenr sep-hl sep`
  local fmt = '%%#MiniCmdlinePeekSign#%s%%#MiniCmdlinePeekLineNr#%%=%s%%#MiniCmdlinePeekSep#' .. sep_format
  if n == l and n == r then return string.format(fmt, signs.same or '🭬', n) end
  if n == l then return string.format(fmt, signs.left or '┌', n) end
  if n == r then return string.format(fmt, signs.right or '└', n) end
  if (l < n and n < r) or (r < n and n < l) then return string.format(fmt, signs.mid or '┊', '') end
  return string.format(fmt, signs.out or '', '')
-- Helper data ================================================================
-- Module default config
H.default_config = vim.deepcopy(MiniCmdline.config)
H.timers = {
  autocomplete = vim.loop.new_timer(),
-- Autocomplete requires `noselect` flag of 'wildmode'. Present in Neovim>=0.11
H.can_autocomplete = vim.fn.has('nvim-0.11') == 1
-- Autocorrect types for which words *must* be from some fixed set
-- Basically a subset of `:h :command-complete` which might lead to an error if
-- word is not from a fixed set. Can be adjusted for more nuances.
-- Reasons for not including a type:
-- - The main reason is because type's usage can be done in context when
--   creating a new object. Like `:edit new-file` for `file` type.
-- - No `help` because there already is an autocorrection with a "sophisticated
--   algorithm to decide which match is better than another one".
-- - No `buffer` because completion candidates only include names for listed
--   buffers. So ids of listed buffers and name+ids of unlisted buffers are
--   missing. Also, partial buffer name is enough for `:buffer`, which would
--   be too cumbersome to account for.
--stylua: ignore
H.autocorrect_strict_types = {
  arglist       = true, -- file names in argument list
  -- augroup       = true, -- autocmd groups
  -- breakpoint    = true, -- |:breakadd| suboptions
  -- buffer        = true, -- buffer names
  color         = true, -- color schemes
  command       = true, -- Ex command (and arguments)
  compiler      = true, -- compilers
  diff_buffer   = true, -- diff buffer names
  -- dir           = true, -- directory names
  -- dir_in_path   = true, -- directory names in |'cdpath'|
  -- environment   = true, -- environment variable names
  event         = true, -- autocommand events
  -- expression    = true, -- Vim expression
  -- file          = true, -- file and directory names
  -- file_in_path  = true, -- file and directory names in |'path'|
  filetype      = true, -- filetype names |'filetype'|
  -- ['function']  = true, -- function name
  -- help          = true, -- help subjects
  -- highlight     = true, -- highlight groups
  history       = true, -- |:history| suboptions
  keymap        = true, -- keyboard mappings
  locale        = true, -- locale names (as output of locale -a)
  -- lua           = true, -- Lua expression |:lua|
  mapclear      = true, -- buffer argument
  -- mapping       = true, -- mapping name
  -- menu          = true, -- menus
  messages      = true, -- |:messages| suboptions
  option        = true, -- options
  packadd       = true, -- optional package |pack-add| names
  -- runtime       = true, -- file and directory names in |'runtimepath'|
  -- scriptnames   = true, -- sourced script names
  -- shellcmd      = true, -- Shell command
  -- shellcmdline  = true, -- First is a shell command and subsequent ones are filenames
  sign          = true, -- |:sign| suboptions
  syntax        = true, -- syntax file names |'syntax'|
  syntime       = true, -- |:syntime| suboptions
  -- tag           = true, -- tags
  -- tag_listfiles = true, -- tags, file names are shown when CTRL-D is hit
  -- user          = true, -- user names
  -- var           = true, -- user variables
-- Various cache to use during command line edit
H.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('autocomplete', config.autocomplete, 'table')
  H.check_type('autocomplete.enable', config.autocomplete.enable, 'boolean')
  H.check_type('autocomplete.delay', config.autocomplete.delay, 'number')
  H.check_type('autocomplete.predicate', config.autocomplete.predicate, 'function', true)
  H.check_type('autocomplete.map_arrows', config.autocomplete.map_arrows, 'boolean')
  H.check_type('autocorrect', config.autocorrect, 'table')
  H.check_type('autocorrect.enable', config.autocorrect.enable, 'boolean')
  H.check_type('autocorrect.func', config.autocorrect.func, 'function', true)
  H.check_type('autopeek', config.autopeek, 'table')
  H.check_type('autopeek.enable', config.autopeek.enable, 'boolean')
  H.check_type('autopeek.n_context', config.autopeek.n_context, 'number')
  H.check_type('autopeek.predicate', config.autopeek.predicate, 'callable', true)
  H.check_type('autopeek.window', config.autopeek.window, 'table')
  local autopeek_win_config = config.autopeek.window.config
  if not (type(autopeek_win_config) == 'table' or vim.is_callable(autopeek_win_config)) then
    H.error('`autopeek.window.config` should be table or callable, not ' .. type(autopeek_win_config))
  H.check_type('autopeek.window.statuscolumn', config.autopeek.window.statuscolumn, 'callable', true)
  return config
H.apply_config = function(config)
  MiniCmdline.config = config
  -- Try setting suggested option values
  -- NOTE: This makes it more like 'mini.completion' (with 'noselect')
  local was_set = vim.api.nvim_get_option_info2('wildmode', { scope = 'global' }).was_set
  if not was_set and config.autocomplete.enable and H.can_autocomplete then vim.o.wildmode = 'noselect,full' end
  was_set = vim.api.nvim_get_option_info2('wildoptions', { scope = 'global' }).was_set
  if not was_set then vim.o.wildoptions = 'pum,fuzzy' end
  -- Set useful mappings
  if config.autocomplete.map_arrows then
    local map_arrow = function(dir, wildmenu_prefix, desc)
      local rhs = function() return (vim.fn.wildmenumode() == 1 and wildmenu_prefix or '') .. dir end
      vim.keymap.set('c', dir, rhs, { expr = true, desc = desc })
    map_arrow('<Left>', '<Space><BS>', 'Move cursor left')
    map_arrow('<Right>', '<Space><BS>', 'Move cursor right')
    -- NOTE: All tests seem to pass without these mappings. But it is mentioned
    -- in `:h cmdline-autocompletion`, so probably worth adding
    map_arrow('<Up>', '<C-e>', 'Go to earlier history')
    map_arrow('<Down>', '<C-e>', 'Go to newer history')
H.create_autocommands = function()
  local gr = vim.api.nvim_create_augroup('MiniCmdline', {})
  local au = function(event, pattern, callback, desc)
    vim.api.nvim_create_autocmd(event, { group = gr, pattern = pattern, callback = callback, desc = desc })
  -- Act on command line events. Notes:
  -- - Schedule for 'CmdlineEnter' to not act on mappings like `:...`
  --   (like `:<C-u>...` popular for Visual mode).
  -- - Prefer 'CursorMovedC' to track command line change as it is triggered
  --   both after only position change and after text change. Schedule its
  --   callback to work around autcompletion issues with mocking wildchar.
  -- - Do not schedule 'CmdlineLeave' to be able to set command text before
  --   executing it.
  au('CmdlineEnter', '*', vim.schedule_wrap(H.on_cmdline_enter), 'Act on command line enter')
  local update_event = vim.fn.has('nvim-0.11') == 1 and 'CursorMovedC' or 'CmdlineChanged'
  au(update_event, '*', vim.schedule_wrap(H.on_cmdline_update), 'Act on command line update')
  au('CmdlineLeave', '*', H.on_cmdline_leave, 'Act on command line leave')
  au('VimResized', '*', function() H.autopeek(true) end, 'Adjust peek window')
  au('CmdwinEnter', '*', function() H.peek_hide() end, 'Hide peek window')
  au('ColorScheme', '*', H.create_default_hl, 'Ensure colors')
H.create_default_hl = function()
  local hi = function(name, opts)
    opts.default = true
    vim.api.nvim_set_hl(0, name, opts)
  hi('MiniCmdlinePeekBorder', { link = 'FloatBorder' })
  hi('MiniCmdlinePeekLineNr', { link = 'DiagnosticSignWarn' })
  hi('MiniCmdlinePeekNormal', { link = 'NormalFloat' })
  hi('MiniCmdlinePeekSep', { link = 'SignColumn' })
  hi('MiniCmdlinePeekSign', { link = 'DiagnosticSignHint' })
  hi('MiniCmdlinePeekTitle', { link = 'FloatTitle' })
H.is_disabled = function() return vim.g.minicmdline_disable == true or vim.b.minicmdline_disable == true end
H.get_config = function() return vim.tbl_deep_extend('force', MiniCmdline.config, vim.b.minicmdline_config or {}) end
-- Autocommands ---------------------------------------------------------------
H.on_cmdline_enter = function()
  -- Check for Command-line mode to not act on `:...` mappings
  if H.is_disabled() or vim.fn.mode() ~= 'c' then return end
  -- Act only on "not nested" command line (for simplicity). It can nest after
  -- `c_CTRL-R_=`, since there are CmdlineEnter-CmdlineChanged-CmdlineLeave for
  -- it without explicit leave-enter for the initial normal Ex command mode.
  -- There doesn't seem to be a way to have `n_nested > 1`, but use counter of
  -- nested levels instead of a boolean `is_nested` just in case.
  if H.cache.state ~= nil then
    H.cache.n_nested = (H.cache.n_nested or 0) + 1
  H.cache = {
    buf_id = vim.api.nvim_get_current_buf(),
    cmd_preview_map = H.get_cmd_preview_map(),
    cmd_type = vim.fn.getcmdtype(),
    config = H.get_config(),
    peek = {},
    state = H.get_cmd_state(),
    state_prev = H.get_cmd_state(true),
  H.cache.autocomplete_predicate = H.cache.config.autocomplete.predicate or MiniCmdline.default_autocomplete_predicate
  H.cache.buf_is_cmdwin = vim.fn.getbufinfo(H.cache.buf_id)[1].command == 1
  H.cache.autopeek_predicate = H.cache.config.autopeek.predicate or MiniCmdline.default_autopeek_predicate
  MiniCmdline._peek_statuscolumn = H.make_peek_statuscolumn()
  if H.cache.config.autopeek.enable then H.autopeek() end
H.on_cmdline_update = function()
  if H.cache.state == nil or H.cache.n_nested ~= nil then return end
  -- Track state only if there was an actual change (line or position)
  local state = H.get_cmd_state()
  local is_same_line = state.line == H.cache.state.line
  if is_same_line and state.pos == H.cache.state.pos then return end
  -- Update state accounting for some edge cases
  if H.cache.state_prev.compltype == 'option' then H.adjust_option_cmd_state(state) end
  H.cache.state_prev, H.cache.state = H.cache.state, state
  -- Act only on text change
  if is_same_line then return end
  local config = H.cache.config
  if config.autocomplete.enable and H.can_autocomplete then H.autocomplete() end
  if config.autocorrect.enable then H.autocorrect(false) end
  if config.autopeek.enable then H.autopeek() end
H.on_cmdline_leave = function()
  if H.cache.state == nil then return end
  if H.cache.n_nested ~= nil then
    H.cache.n_nested = H.cache.n_nested > 1 and (H.cache.n_nested - 1) or nil
  if H.cache.config.autocorrect.enable and not vim.v.event.abort then H.autocorrect(true) end
  H.peek_hide()
  H.cache = {}
  MiniCmdline._peek_statuscolumn = nil
H.get_cmd_state = function(is_init)
  local compltype = vim.fn.getcmdcompltype()
  if is_init then return { complpat = '', compltype = compltype, line = '', pos = 1, cmd = {} } end
  return { complpat = H.getcmdcomplpat(), compltype = compltype, line = vim.fn.getcmdline(), pos = vim.fn.getcmdpos() }
H.adjust_option_cmd_state = function(state)
  -- Cases like `set nowrap invmagic` are completed specially. After `no`/`inv`
  -- there is a specialized completion only for boolean options. In practice it
  -- results into `compltype=''` and `complpat=<text after no/inv>`.
  -- This interferes with how autocorrection is detected, as it relies on whole
  -- `nowrap` / `invmagic` to be a single complpat *with compltype=option*.
  -- The solution is to detect cases "it was compltype=option but now it isn't"
  -- and try to expand complpat to match the whole word on cursor's left.
  if state.compltype == 'option' then return end
  state.complpat = state.line:sub(1, state.pos - 1):match(' (%w+)$') or ''
  state.compltype = state.complpat ~= '' and 'option' or state.compltype
-- Autocomplete ---------------------------------------------------------------
H.autocomplete = function()
  H.timers.autocomplete:stop()
  -- Do not complete if predicate says so
  local state, state_prev = H.cache.state, H.cache.state_prev
  local data = { line = state.line, pos = state.pos, line_prev = state_prev.line, pos_prev = state_prev.pos }
  if not H.cache.autocomplete_predicate(data) then return H.hide_wild() end
  -- Do nothing in some problematic cases (when wildmenu does not work)
  -- TODO: Remove after compatibility with Neovim=0.11 is dropped
  if H.block_autocomplete() then return end
  local delay = H.cache.config.autocomplete.delay
  if delay == 0 then return H.trigger_complete() end
  H.timers.autocomplete:start(delay, 0, H.trigger_complete_scheduled)
H.block_autocomplete = function() return false end
if vim.fn.has('nvim-0.12') == 0 then
  H.block_autocomplete = function()
    -- Block for non-interactive command type
    if H.cache.cmd_type ~= ':' then return true end
    -- Block for cases when there is no completion candidates. This affects
    -- performance (completion candidates are computed twice), but it is
    -- the most robust way of dealing with problematic situations:
    -- - Some commands don't have completion defined: `:s`, `:g`, etc.
    -- - Some cases result in verbatim `^I` inserted. Like after bang (`:q!`).
    -- The `vim.fn.getcmdcompltype() == ''` condition is too wide as it denies
    -- legitimate cases of when there are available completion candidates.
    -- Like in user commands created with `vim.api.nvim_create_user_command()`.
    local line_before_pos = H.cache.state.line:sub(1, H.cache.state.pos - 1)
    -- `getcompletion` may result in error, like after `:ltag `
    local ok, candidates = pcall(vim.fn.getcompletion, line_before_pos, 'cmdline')
    return not (ok and #candidates > 0)
H.trigger_complete = function()
  if vim.fn.mode() ~= 'c' then return end
  H.trigger_wild()
H.trigger_complete_scheduled = vim.schedule_wrap(H.trigger_complete)
H.trigger_wild = function() vim.fn.wildtrigger() end
if vim.fn.has('nvim-0.12') == 0 then
  H.trigger_wild = function()
    -- Not triggerring when wildmenu is shown helps avoiding trigger after
    -- manually pressing wildchar (as text is also changes).
    if vim.fn.wildmenumode() == 1 then return end
    -- Type `<C-z>` which is "Trigger 'wildmode', but always available."
    vim.api.nvim_feedkeys('\26', 'nt', false)
H.hide_wild = function()
  -- Ensure that there is no outdated pmenu after `wildtrigger()`
  vim.cmd('redraw')
  -- This works, but it triggers wildmenu, which is not usable when the point
  -- is to hide pmenu if `autocomplete.predicate()` returned `false` ()
  -- local keys = (vim.fn.wildmenumode() == 0 and '\26' or '') .. '\5'
  -- vim.api.nvim_feedkeys(keys, 'nt', false)
if vim.fn.has('nvim-0.12') == 0 then H.hide_wild = function() end end
-- Autocorrect ----------------------------------------------------------------
H.autocorrect = function(is_final)
  -- Act only for normal Ex commands after a word is just finished typing
  if not (H.cache.cmd_type == ':' and H.cache.state.line:find('%S') ~= nil) then return end
  local state, state_prev = H.cache.state, H.cache.state_prev
  local line, line_prev = state.line, state_prev.line
  local pos, pos_prev = state.pos, state_prev.pos
  -- Act only when a char is appended. It makes tweaking autocorrected text
  -- easier by going back and editing it. This is also easier to implement.
  local is_at_end, was_at_end = (pos - 1) == line:len(), (pos_prev - 1) == line_prev:len()
  local new = line:sub(pos_prev)
  local is_char_append = is_at_end and was_at_end and line == (line_prev .. new) and vim.fn.strchars(new) <= 1
  local is_word_finished = not vim.startswith(state.complpat, state_prev.complpat)
  if not (is_char_append and (is_word_finished or is_final)) then return end
  -- Compute autocorrection
  local state_to_use = is_final and state or state_prev
  local word = state_to_use.complpat
  if word == '' or vim.fn.maparg(word, 'c', true) ~= '' then return end
  local func = H.cache.config.autocorrect.func or MiniCmdline.default_autocorrect_func
  local new_word = func({ word = word, type = state_to_use.compltype }) or word
  if word == new_word then return end
  if type(new_word) ~= 'string' then return H.notify('Can not autocorrect for ' .. vim.inspect(word), 'WARN') end
  -- Set corrected word
  local init_pos = state_to_use.pos
  local new_line = line:sub(1, init_pos - word:len() - 1) .. new_word .. line:sub(init_pos)
  -- - Use `noautocmd` to not conflict with `autocomplete` on `CmdlineChanged`
  local cmd = string.format('call setcmdline(%s, %s)', vim.inspect(new_line), new_line:len() + 1)
  vim.cmd('noautocmd ' .. cmd)
H.get_autocorrect_candidates = function(data)
  if data.type == 'help' then
    local help_buf = vim.api.nvim_create_buf(false, true)
    vim.bo[help_buf].buftype = 'help'
    -- - NOTE: no dedicated buffer name because it is immediately wiped out
    local tags = vim.api.nvim_buf_call(help_buf, function() return vim.fn.taglist('.*') end)
    vim.api.nvim_buf_delete(help_buf, { force = true })
    return vim.tbl_map(function(x) return x.name end, tags)
  if data.type == 'option' then
    local all = {}
    for name, info in pairs(vim.api.nvim_get_all_options_info()) do
      table.insert(all, name)
      local is_bool = info.type == 'boolean'
      table.insert(all, is_bool and ('no' .. name) or nil)
      table.insert(all, is_bool and ('inv' .. name) or nil)
      local has_shortname = info.shortname ~= ''
      table.insert(all, has_shortname and info.shortname or nil)
      table.insert(all, (has_shortname and is_bool) and ('no' .. info.shortname) or nil)
      table.insert(all, (has_shortname and is_bool) and ('inv' .. info.shortname) or nil)
    return all
  local ok, all = pcall(vim.fn.getcompletion, '', data.type)
  return ok and all or { data.word }
H.get_nearest_command = function(ref, all)
  -- Do not alter `:=` command, as it is a special Lua shorthand command
  if ref:sub(1, 1) == '=' then return ref end
  -- Allow trailing special punctuation (specific to commands)
  local word, suffix = ref:match('^(.+)([!|]?)$')
  -- Account for the fact that commands can be abbreviated (`:h |20.2|`):
  local cmd_abbr_lens, usr_cmds, usr_max_len = {}, {}, 0
  for _, cmd in ipairs(all) do
    -- User command abbreviation needs to uniquely identify command name
    if cmd:find('^[A-Z]') ~= nil then
      usr_cmds[cmd] = true
      usr_max_len = math.max(usr_max_len, cmd:len())
      -- ANY abbreviation of ANY built-in command is a valid command (may be
      -- different; `wincmd`->`w`==`write`). Its an internal optimization.
      -- EXCEPT: `:def` abbreviation of `:defer` is not allowed.
      cmd_abbr_lens[cmd] = cmd == 'defer' and 4 or 1
  -- Slice user commands with increasing abbreviation length to find which
  -- ones can be uniquely identified by it
  for cur_abbr_len = 1, usr_max_len do
    local cur_abbrs = {}
    for cmd, _ in pairs(usr_cmds) do
      local abbr = cmd:sub(1, cur_abbr_len)
      cur_abbrs[abbr] = cur_abbrs[abbr] or {}
      table.insert(cur_abbrs[abbr], cmd)
    for _, cmd_arr in pairs(cur_abbrs) do
      if #cmd_arr == 1 then
        local cmd = cmd_arr[1]
        cmd_abbr_lens[cmd] = math.min(cur_abbr_len, cmd:len())
        usr_cmds[cmd] = nil
  local abbr_lens = vim.tbl_map(function(x) return cmd_abbr_lens[x] end, all)
  return H.get_nearest_abbr(word, all, abbr_lens) .. suffix
H.get_nearest_abbr = function(word, candidates, abbr_lens)
  local tolower = vim.fn.tolower
  local word_split = vim.split(word, '')
  local word_split_l = vim.split(tolower(word), '')
  -- Prefer closest string respecting case first, then try ignorecase
  local res, res_dist = nil, math.huge
  for i, cand in ipairs(candidates) do
    local min_abbr_len = abbr_lens[i]
    local d, abbr_len = H.string_abbr_dist(word_split, vim.split(cand, ''), min_abbr_len)
    if d < res_dist then
      res, res_dist = cand:sub(1, abbr_len), d
  for i, cand in ipairs(candidates) do
    local min_abbr_len = abbr_lens[i]
    local cand_word_l = tolower(cand)
    local d_l, abbr_len_l = H.string_abbr_dist(word_split_l, vim.split(cand_word_l, ''), min_abbr_len)
    if d_l < res_dist then
      res, res_dist = cand:sub(1, abbr_len_l), d_l
  return res
H.string_abbr_dist = function(ref, cand, min_abbr_len)
  -- Source: https://en.wikipedia.org/wiki/Damerau-Levenshtein_distance
  -- d[i][j] - distance between `ref[1:i]` and `cand[1:j]` abbreviations
  local d = {}
  for i = 0, #ref do
    d[i] = { [0] = i }
  for j = 0, #cand do
    d[0][j] = j
  for i = 1, #ref do
    for j = 1, #cand do
      local cost = ref[i] == cand[j] and 0 or 1
      -- Account for deletion, insertion, substitution
      d[i][j] = math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost)
      -- Account for transposition. Slightly favor them over others, as it is
      -- a common source for autocorrection
      if i > 1 and j > 1 and ref[i] == cand[j - 1] and ref[i - 1] == cand[j] then
        d[i][j] = math.min(d[i][j], d[i - 2][j - 2] + 0.99 * cost)
  -- Find the candidate abbreviation with the smallest distance
  local abbr_d = d[#ref]
  local dist, abbr_len = math.huge, nil
  for j = min_abbr_len, #cand do
    if abbr_d[j] < dist then
      dist, abbr_len = abbr_d[j], j
  return dist, abbr_len
-- Autopeek -------------------------------------------------------------------
H.autopeek = function(force)
  -- Decide if peek needs to be shown or hidden
  if not (H.cache.cmd_type == ':' and not H.cache.buf_is_cmdwin) then return end
  local line = H.cache.state.line
  if line:find('%S') == nil then H.peek_hide() end
  local parsed = H.parse_cmd(line)
  local range, cmd = parsed.range, parsed.cmd
  if range[1] == nil and range[2] == nil then return H.peek_hide() end
  -- Normalize range lines
  local n_lines = vim.api.nvim_buf_line_count(0)
  local left = H.clamp(range[1] or range[2], 1, n_lines)
  local right = H.clamp(range[2] or range[1], 1, n_lines)
  local from = right < left and right or left
  local to = right < left and left or right
  local data = { left = left, right = right, cmd = parsed.cmd }
  -- Do not peek if predicate says so
  if not H.cache.autopeek_predicate(data) then return H.peek_hide() end
  -- Force peek update if command line height has changed when typing
  local cmdheight = math.ceil((vim.fn.strdisplaywidth(line) + 1) / vim.o.columns)
  cmdheight = math.max(cmdheight, vim.o.cmdheight)
  force = force or cmdheight ~= H.cache.peek.cmdheight
  -- Skip peek update if command line state is the same (for performance)
  local cur_data = H.cache.peek.data or {}
  local is_data_same = left == cur_data.left and right == cur_data.right and cmd == cur_data.cmd
  if not force and is_data_same then return end
  H.cache.peek.cmdheight = cmdheight
  H.cache.peek.data = data
  H.cache.peek.win_id = H.peek_show(from, to)
H.peek_show = function(from, to)
  -- Compute height to show union of left and right contexts plus possible fold
  local n_context = math.max(H.cache.config.autopeek.n_context, 0)
  local n_lines = vim.api.nvim_buf_line_count(0)
  local cont_from = H.peek_new_context(from, n_context, n_lines)
  local cont_to = H.peek_new_context(to, n_context, n_lines)
  local height = H.peek_get_height(cont_from, cont_to)
  -- Ensure opened window of enough height.
  -- NOTE: This uses current buffer directly, which means that all its extmarks
  -- are shown. This is both good (for extra text highlighting) and bad
  -- (virtual lines and text) thing. Ideally, extmark "owners" should take care
  -- of where they should be shown. Usually setting something like "only show
  -- inside this particular window" makes sense. Like in 'mini.diff' and
  -- 'mini.indentscope'. This is currently not (robustly) possible. Sources:
  -- - https://github.com/neovim/neovim/issues/19654
  -- - https://github.com/neovim/neovim/pull/27361
  -- - https://github.com/neovim/neovim/pull/28432

View remainder of file in raw view

FilesExpand file tree

cmdline.lua

Latest commit

History

cmdline.lua

File metadata and controls