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.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014--- *mini.bracketed* Go forward/backward with square brackets------ MIT License Copyright (c) 2023 Evgeni Chasnovski
--- Features:--- - Configurable Lua functions to go forward/backward to a certain target.--- Each function can be customized with:--- - Direction. One of "forward", "backward", "first" (forward starting--- from first one), "last" (backward starting from last one).--- - Number of times to go.--- - Whether to wrap on edges (going forward on last one goes to first).--- - Some other target specific options.------ - Mappings using square brackets. They are created using configurable--- target suffix and can be selectively disabled.------ Each mapping supports |[count]|. Mappings are created in Normal mode; for--- targets which move cursor in current buffer also Visual and--- Operator-pending (with dot-repeat) modes are supported.------ Using `lower-suffix` and `upper-suffix` (lower and upper case suffix) for--- a single target the following mappings are created:--- - `[` + `upper-suffix` : go first.--- - `[` + `lower-suffix` : go backward.--- - `]` + `lower-suffix` : go forward.--- - `]` + `upper-suffix` : go last.------ - Supported targets (for more information see help for corresponding Lua--- function):------ `Target` `Mappings` `Lua function`--- Buffer ......................... `[B` `[b` `]b` `]B` .... |MiniBracketed.buffer()|--- Comment block .................. `[C` `[c` `]c` `]C` .... |MiniBracketed.comment()|--- Conflict marker ................ `[X` `[x` `]x` `]X` .... |MiniBracketed.conflict()|--- Diagnostic ..................... `[D` `[d` `]d` `]D` .... |MiniBracketed.diagnostic()|--- File on disk ................... `[F` `[f` `]f` `]F` .... |MiniBracketed.file()|--- Indent change .................. `[I` `[i` `]i` `]I` .... |MiniBracketed.indent()|--- Jump inside current buffer ..... `[J` `[j` `]j` `]J` .... |MiniBracketed.jump()|--- Location from |location-list| .... `[L` `[l` `]l` `]L` .... |MiniBracketed.location()|--- Old files ...................... `[O` `[o` `]o` `]O` .... |MiniBracketed.oldfile()|--- Quickfix entry from |Quickfix| ... `[Q` `[q` `]q` `]Q` .... |MiniBracketed.quickfix()|--- Tree-sitter node and parents ... `[T` `[t` `]t` `]T` .... |MiniBracketed.treesitter()|--- Undo from linear history ....... `[U` `[u` `]u` `]U` .... |MiniBracketed.undo()|--- Window in current tab .......... `[W` `[w` `]w` `]W` .... |MiniBracketed.window()|--- Yank entry over put region ..... `[Y` `[y` `]y` `]Y` .... |MiniBracketed.yank()|------ Notes:--- - The `undo` target remaps |u| and |CTRL-R| keys to register undo state--- after undo and redo respectively. If this conflicts with your setup,--- either disable `undo` target or make your remaps after calling--- |MiniBracketed.setup()|. To use `undo` target, remap your undo/redo keys--- to call |MiniBracketed.register_undo_state()| after the action.------ # Setup ~------ This module needs a setup with `require('mini.bracketed').setup({})` (replace--- `{}` with your `config` table). It will create global Lua table `MiniBracketed`--- which you can use for scripting or manually (with `:lua MiniBracketed.*`).------ See |MiniBracketed.config| for available config settings.------ You can override runtime config settings (like target options) locally--- to buffer inside `vim.b.minibracketed_config` which should have same structure--- as `MiniBracketed.config`. See |mini.nvim-buffer-local-config| for more details.------ # Comparisons ~------ - [tpope/vim-unimpaired](https://github.com/tpope/vim-unimpaired):--- - Supports buffer, conflict, file, location, and quickfix targets mostly--- via built-in commands (like |:bprevious|, etc.) without configuration.--- - Supports files from argument list and tags. This module does not.--- - Doesn't support most other this module's targets (comment, indent, ...).--- - |mini.indentscope|:--- - Target |MiniBracketed.indent()| target can go to "first" and "last"--- indent change. It also can go not only to line with smaller indent,--- but also bigger or different one.--- - Mappings from |mini.indentscope| have more flexibility in computation of--- indent scope, like how to treat empty lines near border or whether to--- compute indent at cursor.------ # Disabling ~------ To disable, set `vim.g.minibracketed_disable` (globally) or--- `vim.b.minibracketed_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 MiniBracketed
---@diagnostic disable:luadoc-miss-type-name---@alias __bracketed_direction string One of "first", "backward", "forward", "last".---@alias __bracketed_add_to_jumplist - <add_to_jumplist> (`boolean`) - Whether to add current position to jumplist.--- Default: `false`.---@alias __bracketed_opts table|nil Options. A table with fields:--- - <n_times> `(number)` - Number of times to advance. Default: |v:count1|.--- - <wrap> `(boolean)` - Whether to wrap around edges. Default: `true`.
---@diagnostic disable:undefined-field
-- Module definition ==========================================================local MiniBracketed = {}local H = {}
--- Module setup------@param config table|nil Module config table. See |MiniBracketed.config|.------@usage >lua--- require('mini.bracketed').setup() -- use default config--- -- OR--- require('mini.bracketed').setup({}) -- replace {} with your config table--- <MiniBracketed.setup = function(config) -- TODO: Remove after Neovim=0.9 support is dropped if vim.fn.has('nvim-0.10') == 0 then vim.notify( '(mini.bracketed) 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.MiniBracketed = MiniBracketed
-- 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)---@text Options ~------ Each entry configures target with the same name and can have data configuring--- mapping suffix and target options.------ Example of configuration: >lua------ require('mini.bracketed').setup({--- -- Map [N, [n, ]n, ]N for conflict marker like in 'tpope/vim-unimpaired'--- conflict = { suffix = 'n' },------ -- Make diagnostic advance only by errors--- diagnostic = { options = { severity = vim.diagnostic.severity.ERROR } },------ -- Disable creation of mappings for `indent` target (for example,--- -- in favor of ones from |mini.indentscope|)--- indent = { suffix = '' },------ -- Disable mappings for `window` target in favor of custom ones--- window = { suffix = '' },--- })------ -- Create custom `window` mappings--- local map = vim.keymap.set--- map('n', '<Leader>wH', "<Cmd>lua MiniBracketed.window('first')<CR>")--- map('n', '<Leader>wh', "<Cmd>lua MiniBracketed.window('backward')<CR>")--- map('n', '<Leader>wl', "<Cmd>lua MiniBracketed.window('forward')<CR>")--- map('n', '<Leader>wL', "<Cmd>lua MiniBracketed.window('last')<CR>")--- <--- ## Suffix ~------ The `suffix` key is used to create target mappings.------ Supply empty string to disable mapping creation for that particular target.--- To create a completely different mapping (like with |<Leader>|) use target--- function manually.------ Using `lower-suffix` and `upper-suffix` (lower and upper case suffix) for--- a single target the following mappings are created:--- - `[` + `upper-suffix` : go first.--- - `[` + `lower-suffix` : go backward.--- - `]` + `lower-suffix` : go forward.--- - `]` + `upper-suffix` : go last.------ When supplied with a non-letter, only forward/backward mappings are created.------ ## Options ~------ The `options` key is directly forwarded as `opts` to corresponding Lua function.MiniBracketed.config = { -- First-level elements are tables describing behavior of a target: -- -- - <suffix> - single character suffix. Used after `[` / `]` in mappings. -- For example, with `b` creates `[B`, `[b`, `]b`, `]B` mappings. -- Supply empty string `''` to not create mappings. -- -- - <options> - table overriding target options. -- -- See `:h MiniBracketed.config` for more info.
buffer = { suffix = 'b', options = {} }, comment = { suffix = 'c', options = {} }, conflict = { suffix = 'x', options = {} }, diagnostic = { suffix = 'd', options = {} }, file = { suffix = 'f', options = {} }, indent = { suffix = 'i', options = {} }, jump = { suffix = 'j', options = {} }, location = { suffix = 'l', options = {} }, oldfile = { suffix = 'o', options = {} }, quickfix = { suffix = 'q', options = {} }, treesitter = { suffix = 't', options = {} }, undo = { suffix = 'u', options = {} }, window = { suffix = 'w', options = {} }, yank = { suffix = 'y', options = {} },}--minidoc_afterlines_end
--- Listed buffer------ Go to next/previous listed buffer. Order by their number (see |bufnr()|).------ Direction "forward" increases number, "backward" - decreases.------@param direction __bracketed_direction---@param opts __bracketed_optsMiniBracketed.buffer = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'buffer') opts = vim.tbl_deep_extend('force', { n_times = vim.v.count1, wrap = true }, H.get_config().buffer.options, opts or {})
-- Define iterator that traverses all valid listed buffers -- (should be same as `:bnext` / `:bprev`) local buf_list = vim.api.nvim_list_bufs() local is_listed = function(buf_id) return vim.api.nvim_buf_is_valid(buf_id) and vim.bo[buf_id].buflisted end
local iterator = {}
iterator.next = function(buf_id) for id = buf_id + 1, buf_list[#buf_list] do if is_listed(id) then return id end end end
iterator.prev = function(buf_id) for id = buf_id - 1, buf_list[1], -1 do if is_listed(id) then return id end end end
iterator.state = vim.api.nvim_get_current_buf() iterator.start_edge = buf_list[1] - 1 iterator.end_edge = buf_list[#buf_list] + 1
-- Iterate local res_buf_id = MiniBracketed.advance(iterator, direction, opts) if res_buf_id == iterator.state then return end
-- Apply vim.api.nvim_set_current_buf(res_buf_id)end
--- Comment block------ Go to next/previous comment block. Only linewise comments using--- |'commentstring'| are recognized.------ Direction "forward" increases line number, "backward" - decreases.------@param direction __bracketed_direction---@param opts __bracketed_opts--- __bracketed_add_to_jumplist--- - <block_side> `(string)` - which side of comment block to use. One of--- "near" (default; use nearest side), "start" (use first line), "end"--- (use last line), "both" (use both first and last lines).MiniBracketed.comment = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'comment') opts = vim.tbl_deep_extend( 'force', { add_to_jumplist = false, block_side = 'near', n_times = vim.v.count1, wrap = true }, H.get_config().comment.options, opts or {} )
-- Compute loop data to traverse target commented lines in current buffer local is_commented = H.make_comment_checker() if is_commented == nil then return end
local predicate = ({ near = function(_, cur, _, recent) return cur and not recent end, start = function(above, cur, _, _) return cur and not above end, ['end'] = function(_, cur, below, _) return cur and not below end, both = function(above, cur, below, _) return cur and not (above and below) end, })[opts.block_side] if predicate == nil then return end
-- Define iterator local iterator = {}
local n_lines = vim.api.nvim_buf_line_count(0) iterator.next = function(line_num) local above, cur = is_commented(line_num), is_commented(line_num + 1) for lnum = line_num + 1, n_lines do local below = is_commented(lnum + 1) if predicate(above, cur, below, above) then return lnum end above, cur = cur, below end end
iterator.prev = function(line_num) local cur, below = is_commented(line_num - 1), is_commented(line_num) for lnum = line_num - 1, 1, -1 do local above = is_commented(lnum - 1) if predicate(above, cur, below, below) then return lnum end below, cur = cur, above end end
iterator.state = vim.fn.line('.') iterator.start_edge = 0 iterator.end_edge = n_lines + 1
-- Iterate local res_line_num = MiniBracketed.advance(iterator, direction, opts) local is_outside = res_line_num <= 0 or n_lines < res_line_num if res_line_num == nil or res_line_num == iterator.state or is_outside then return end
-- Possibly add current position to jumplist if opts.add_to_jumplist then H.add_to_jumplist() end
-- Apply. Open just enough folds and put cursor on first non-blank. H.set_cursor(res_line_num, 0) vim.cmd('normal! zv^')end
--- Git conflict marker------ Go to next/previous lines containing Git conflict marker. That is, if it--- starts with "<<<<<<< ", ">>>>>>> ", or is "=======".------ Direction "forward" increases line number, "backward" - decreases.------ Notes:--- - Using this target in Operator-pending mode allows the following approach--- at resolving merge conflicts:--- - Place cursor on `=======` line.--- - Execute one of these: `d]x[xdd` (choose upper part) or--- `d[x]xdd` (choose lower part).------@param direction __bracketed_direction---@param opts __bracketed_opts--- __bracketed_add_to_jumplistMiniBracketed.conflict = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'conflict') opts = vim.tbl_deep_extend( 'force', { add_to_jumplist = false, n_times = vim.v.count1, wrap = true }, H.get_config().conflict.options, opts or {} )
-- Define iterator that traverses all conflict markers in current buffer local n_lines = vim.api.nvim_buf_line_count(0)
local iterator = {}
iterator.next = function(line_num) for lnum = line_num + 1, n_lines do if H.is_conflict_mark(lnum) then return lnum end end end
iterator.prev = function(line_num) for lnum = line_num - 1, 1, -1 do if H.is_conflict_mark(lnum) then return lnum end end end
iterator.state = vim.fn.line('.') iterator.start_edge = 0 iterator.end_edge = n_lines + 1
-- Iterate local res_line_num = MiniBracketed.advance(iterator, direction, opts) local is_outside = res_line_num <= 0 or n_lines < res_line_num if res_line_num == nil or res_line_num == iterator.state or is_outside then return end
-- Possibly add current position to jumplist if opts.add_to_jumplist then H.add_to_jumplist() end
-- Apply. Open just enough folds and put cursor on first non-blank. H.set_cursor(res_line_num, 0) vim.cmd('normal! zv^')end
--- Diagnostic------ Go to next/previous diagnostic. This is mostly similar to built-in--- |vim.diagnostic.jump()| (on Neovim<0.11 it is |vim.diagnostic.goto_next()| and--- |vim.diagnostic.goto_prev()|) which has an interface and behavior--- consistent with other methods of the module.------ Direction "forward" increases line number, "backward" - decreases.------ Notes:--- - Using `severity` option, this target can be used in mappings like "go to--- next/previous error" (), etc. Using code similar to this: >lua------ local severity_error = vim.diagnostic.severity.ERROR--- -- Use these inside custom mappings--- MiniBracketed.diagnostic('forward', { severity = severity_error })--- MiniBracketed.diagnostic('backward', { severity = severity_error })--- <---@param direction __bracketed_direction---@param opts __bracketed_opts--- - <float> `(boolean|table)` - control floating window after movement.--- For available values see |vim.diagnostic.goto_next()|.--- - <severity> `(string|table)` - which severity to use.--- For available values see |diagnostic-severity|.MiniBracketed.diagnostic = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'diagnostic') local default_opts = { float = vim.diagnostic.config().float, n_times = vim.v.count1, severity = nil, wrap = true } local buf_id = vim.api.nvim_get_current_buf() if vim.is_callable(default_opts.float) then default_opts.float = default_opts.float(nil, buf_id) end opts = vim.tbl_extend('force', default_opts, H.get_config().diagnostic.options, opts or {})
-- Define iterator that traverses all diagnostic entries in current buffer local to_cursor_pos = function(pos) return { pos[1] + 1, pos[2] } end local pos_field = vim.fn.has('nvim-0.11') == 1 and 'pos' or 'cursor_position' local iterator = {}
iterator.next = function(position) local next_opts = { [pos_field] = to_cursor_pos(position), severity = opts.severity, wrap = false } local next = vim.diagnostic.get_next(next_opts) if next == nil then return end return { next.lnum, next.col } end
iterator.prev = function(position) local prev_opts = { [pos_field] = to_cursor_pos(position), severity = opts.severity, wrap = false } local prev = vim.diagnostic.get_prev(prev_opts) if prev == nil then return end return { prev.lnum, prev.col } end
-- - Define states with zero-based indexing as used in `vim.diagnostic`. -- - Go outside of proper buffer position for `start_edge` and `end_edge` to -- correctly spot diagnostic entry right and start and end of buffer. local cursor_pos = vim.api.nvim_win_get_cursor(0) iterator.state = { cursor_pos[1] - 1, cursor_pos[2] }
iterator.start_edge = { 0, -1 }
local last_line = vim.api.nvim_buf_line_count(0) iterator.end_edge = { last_line - 1, vim.fn.col({ last_line, '$' }) - 1 }
-- Iterate local res_pos = MiniBracketed.advance(iterator, direction, opts) if res_pos == nil or res_pos == iterator.state then return end
-- Apply. Use built-in jump with offsetted cursor position to make it respect -- `vim.diagnostic.config()`. H.diagnostic_jump({ res_pos[1] + 1, res_pos[2] - 1 }, opts.float, opts.severity)end
--- File on disk------ Go to next/previous file on disk alphabetically. Files are taken from--- directory of file in current buffer (or current working directory if buffer--- doesn't contain a readable file). Only first-level files are used, i.e. it--- doesn't go inside subdirectories.------ Direction "forward" goes forward alphabetically, "backward" - backward.------@param direction __bracketed_direction---@param opts __bracketed_optsMiniBracketed.file = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'file') opts = vim.tbl_deep_extend('force', { n_times = vim.v.count1, wrap = true }, H.get_config().file.options, opts or {})
-- Get file data local file_data = H.get_file_data() if file_data == nil then return end local file_basenames, directory = file_data.file_basenames, file_data.directory
-- Define iterator that traverses all found files local iterator = {} local n_files = #file_basenames
iterator.next = function(ind) -- Allow advance in untrackable current buffer if ind == nil then return 1 end if n_files <= ind then return end return ind + 1 end
iterator.prev = function(ind) -- Allow advance in untrackable current buffer if ind == nil then return n_files end if ind <= 1 then return end return ind - 1 end
-- - Find filename array index of current buffer local cur_basename = vim.fn.fnamemodify(vim.api.nvim_buf_get_name(0), ':t') local cur_basename_ind if cur_basename ~= '' then for i, f in ipairs(file_basenames) do if cur_basename == f then cur_basename_ind = i break end end end
iterator.state = cur_basename_ind iterator.start_edge = 0 iterator.end_edge = n_files + 1
-- Iterate local res_ind = MiniBracketed.advance(iterator, direction, opts) if res_ind == iterator.state then return end
-- Apply. Open target_path. local path_sep = package.config:sub(1, 1) local target_path = directory .. path_sep .. file_basenames[res_ind] H.edit(target_path)end
--- Indent change------ Go to next/previous line with different indent (see |indent()|).--- Can be used to go to lines with smaller, bigger, or different indent.------ Notes:--- - Directions "first" and "last" work differently from most other targets--- for performance reasons. They are essentially "backward" and "forward"--- with very big `n_times` option.--- - For similar reasons, `wrap` is not supported.--- - Blank line inherit indent from near non-blank line in direction of movement.------ Direction "forward" increases line number, "backward" - decreases.------@param direction __bracketed_direction---@param opts table|nil Options. A table with fields:--- - <n_times> `(number)` - Number of times to advance. Default: |v:count1|.--- __bracketed_add_to_jumplist--- - <change_type> `(string)` - which type of indent change to use.--- One of "less" (default; smaller indent), "more" (bigger indent),--- "diff" (different indent).MiniBracketed.indent = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'indent') opts = vim.tbl_deep_extend( 'force', { add_to_jumplist = false, change_type = 'less', n_times = vim.v.count1 }, H.get_config().indent.options, opts or {} )
opts.wrap = false
if direction == 'first' then -- For some reason using `n_times = math.huge` leads to infinite loop direction, opts.n_times = 'backward', vim.api.nvim_buf_line_count(0) + 1 end if direction == 'last' then direction, opts.n_times = 'forward', vim.api.nvim_buf_line_count(0) + 1 end
-- Compute loop data to traverse target commented lines in current buffer local predicate = ({ less = function(new, cur) return new < cur or cur == 0 end, more = function(new, cur) return new > cur end, diff = function(new, cur) return new ~= cur end, })[opts.change_type] if predicate == nil then return end
-- Define iterator local iterator = {}
iterator.next = function(cur_lnum) -- Correctly process empty current line cur_lnum = vim.fn.nextnonblank(cur_lnum) local cur_indent = vim.fn.indent(cur_lnum)
local new_lnum, new_indent = cur_lnum, cur_indent -- Check with `new_lnum > 0` because `nextnonblank()` returns -1 if line is -- outside of line range while new_lnum > 0 do new_indent = vim.fn.indent(new_lnum) if predicate(new_indent, cur_indent) then return new_lnum end new_lnum = vim.fn.nextnonblank(new_lnum + 1) end end
iterator.prev = function(cur_lnum) cur_lnum = vim.fn.prevnonblank(cur_lnum) local cur_indent = vim.fn.indent(cur_lnum)
local new_lnum, new_indent = cur_lnum, cur_indent while new_lnum > 0 do new_indent = vim.fn.indent(new_lnum) if predicate(new_indent, cur_indent) then return new_lnum end new_lnum = vim.fn.prevnonblank(new_lnum - 1) end end
-- - Don't add first and last states as there is no wrapping around edges iterator.state = vim.fn.line('.')
-- Iterate local res_line_num = MiniBracketed.advance(iterator, direction, opts) if res_line_num == nil or res_line_num == iterator.state then return end
-- Possibly add current position to jumplist if opts.add_to_jumplist then H.add_to_jumplist() end
-- Apply. Open just enough folds and put cursor on first non-blank. H.set_cursor(res_line_num, 0) vim.cmd('normal! zv^')end
--- Jump inside current buffer------ Go to next/previous jump from |jumplist| which is inside current buffer.------ Notes:--- - There are no Visual mode mappings due to implementation problems.------ Direction "forward" increases jump number, "backward" - decreases.------@param direction __bracketed_direction---@param opts __bracketed_optsMiniBracketed.jump = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'jump') opts = vim.tbl_deep_extend('force', { n_times = vim.v.count1, wrap = true }, H.get_config().jump.options, opts or {})
-- Define iterator that traverses all jumplist entries inside current buffer local cur_buf_id = vim.api.nvim_get_current_buf() local jump_list, cur_jump_num = unpack(vim.fn.getjumplist()) local n_list = #jump_list if n_list == 0 then return end -- - Correct for zero-based indexing cur_jump_num = cur_jump_num + 1
local iterator = {}
local is_jump_num_from_current_buffer = function(jump_num) local jump_entry = jump_list[jump_num] if jump_entry == nil then return end return jump_entry.bufnr == cur_buf_id end
iterator.next = function(jump_num) for num = jump_num + 1, n_list do if is_jump_num_from_current_buffer(num) then return num end end end
iterator.prev = function(jump_num) for num = jump_num - 1, 1, -1 do if is_jump_num_from_current_buffer(num) then return num end end end
iterator.state = cur_jump_num iterator.start_edge = 0 iterator.end_edge = n_list + 1
-- Iterate local res_jump_num = MiniBracketed.advance(iterator, direction, opts) if res_jump_num == nil or jump_list[res_jump_num] == nil then return end
-- Apply. Make jump. Allow jumping to current jump entry as it might be -- different from current cursor position. H.make_jump(jump_list, cur_jump_num, res_jump_num)end
--- Location from location list------ Go to next/previous location from |location-list|. This is similar to--- |:lfirst|, |:lprevious|, |:lnext|, and |:llast| but with support of--- wrapping around edges and |[count]| for "first"/"last" direction.------ Direction "forward" increases location number, "backward" - decreases.------@param direction __bracketed_direction---@param opts __bracketed_optsMiniBracketed.location = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'location') opts = vim.tbl_deep_extend('force', { n_times = vim.v.count1, wrap = true }, H.get_config().location.options, opts or {})
H.qf_loc_implementation('location', direction, opts)end
--- Old files from previous and current sessions------ Go to older/newer readable file either from previous session (see |v:oldfiles|)--- or the current one (updated automatically after |MiniBracketed.setup()| call).------ Direction "forward" goes to more recent files, "backward" - to older.------ Notes:--- - In current session it tracks only normal buffers (see |'buftype'|) for--- some readable file.--- - No new file is tracked when advancing this target. Only after buffer--- change is done not through this target (like with |MiniBracketed.buffer()|),--- it updates recency of last advanced and new buffers.------@param direction __bracketed_direction---@param opts __bracketed_optsMiniBracketed.oldfile = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'oldfile') opts = vim.tbl_deep_extend('force', { n_times = vim.v.count1, wrap = true }, H.get_config().oldfile.options, opts or {})
-- Define iterator that traverses all old files local cur_path = vim.api.nvim_buf_get_name(0)
H.oldfile_normalize() local oldfile_arr = H.oldfile_get_array() local n_oldfiles = #oldfile_arr
local iterator = {}
iterator.next = function(ind) -- Allow advance in untrackable current buffer if ind == nil then return 1 end if n_oldfiles <= ind then return end return ind + 1 end
iterator.prev = function(ind) -- Allow advance in untrackable current buffer if ind == nil then return n_oldfiles end if ind <= 1 then return end return ind - 1 end
iterator.state = H.cache.oldfile.recency[cur_path] iterator.start_edge = 0 iterator.end_edge = n_oldfiles + 1
-- Iterate local res_arr_ind = MiniBracketed.advance(iterator, direction, opts) if res_arr_ind == nil or res_arr_ind == iterator.state then return end
-- Apply. Edit file at path while marking it not for tracking. H.cache.oldfile.is_advancing = true H.edit(oldfile_arr[res_arr_ind])end
--- Quickfix from quickfix list------ Go to next/previous entry from |quickfix| list. This is similar to--- |:cfirst|, |:cprevious|, |:cnext|, and |:clast| but with support of--- wrapping around edges and |[count]| for "first"/"last" direction.------ Direction "forward" increases location number, "backward" - decreases.------@param direction __bracketed_direction---@param opts __bracketed_optsMiniBracketed.quickfix = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'quickfix') opts = vim.tbl_deep_extend('force', { n_times = vim.v.count1, wrap = true }, H.get_config().quickfix.options, opts or {})
H.qf_loc_implementation('quickfix', direction, opts)end
--- Tree-sitter node------ Go to end/start of current tree-sitter node and its parents (except root).------ Notes:--- - Requires loaded tree-sitter parser in the current buffer.--- - Directions "first" and "last" work differently from most other targets--- for performance reasons. They are essentially "backward" and "forward"--- with very big `n_times` option.--- - For similar reasons, `wrap` is not supported.------ Direction "forward" moves cursor forward to node's end, "backward" - backward--- to node's start.------@param direction __bracketed_direction---@param opts table|nil Options. A table with fields:--- - <n_times> `(number)` - Number of times to advance. Default: |v:count1|.--- __bracketed_add_to_jumplistMiniBracketed.treesitter = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'treesitter') opts = vim.tbl_deep_extend( 'force', { add_to_jumplist = false, n_times = vim.v.count1 }, H.get_config().treesitter.options, opts or {} )
opts.wrap = false
if direction == 'first' then direction, opts.n_times = 'backward', math.huge end if direction == 'last' then direction, opts.n_times = 'forward', math.huge end
-- Define iterator that traverses current node and its parents (except root) local is_bad_node = function(node) return node == nil or node:parent() == nil end local is_after = function(row_new, col_new, row_ref, col_ref) return row_ref < row_new or (row_ref == row_new and col_ref < col_new) end local is_before = function(row_new, col_new, row_ref, col_ref) return is_after(row_ref, col_ref, row_new, col_new) end
local iterator = {}
-- Traverse node and parents until node's end is after current position iterator.next = function(node_pos) local node = node_pos.node if is_bad_node(node) then return nil end
local init_row, init_col = node_pos.pos[1], node_pos.pos[2] local cur_row, cur_col, cur_node = init_row, init_col, node
repeat if is_bad_node(cur_node) then break end
cur_row, cur_col = cur_node:end_() -- Correct for end-exclusiveness cur_col = cur_col - 1 cur_node = cur_node:parent() until is_after(cur_row, cur_col, init_row, init_col)
if not is_after(cur_row, cur_col, init_row, init_col) then return end
return { node = cur_node, pos = { cur_row, cur_col } } end
-- Traverse node and parents until node's start is before current position iterator.prev = function(node_pos) local node = node_pos.node if is_bad_node(node) then return nil end
local init_row, init_col = node_pos.pos[1], node_pos.pos[2] local cur_row, cur_col, cur_node = init_row, init_col, node
repeat if is_bad_node(cur_node) then break end
cur_row, cur_col = cur_node:start() cur_node = cur_node:parent() until is_before(cur_row, cur_col, init_row, init_col)
if not is_before(cur_row, cur_col, init_row, init_col) then return end
return { node = cur_node, pos = { cur_row, cur_col } } end
local cur_pos = vim.api.nvim_win_get_cursor(0) local ok, node = pcall(H.get_treesitter_node, cur_pos[1] - 1, cur_pos[2]) if not ok then H.error( 'In `treesitter()` target can not find tree-sitter node under cursor.' .. ' Do you have tree-sitter enabled in current buffer?' ) end iterator.state = { pos = { cur_pos[1] - 1, cur_pos[2] }, node = node }
-- Iterate local res_node_pos = MiniBracketed.advance(iterator, direction, opts) if res_node_pos == nil then return end
-- Possibly add current position to jumplist if opts.add_to_jumplist then H.add_to_jumplist() end
-- Apply H.set_cursor(res_node_pos.pos[1] + 1, res_node_pos.pos[2])end
--- Undo along a tracked linear history------ In a nutshell:--- - Keys |u| and |CTRL-R| (although remapped) can be used as usual, but every--- their execution new state is recorded in this module's linear undo history.--- - Advancing this target goes along linear undo history revealing undo states--- IN ORDER THEY ACTUALLY APPEARED.--- - One big difference with built-in methods is that tracked linear history--- can repeat undo states (not consecutively, though).------ Neovim's default way of managing undo history is through branches (see--- |undo-branches|). Basically it means that if you undo several changes and then--- make new ones, it creates new undo branch while usually (see |'undolevels'|)--- saving previous buffer states in another branch. While there are commands--- to navigate by time of undo state creation (like |:earlier| and |:later|),--- there is no intuitive way to cycle through them. Existing |g-| and |g+|--- cycle through undo states BASED ON THEIR CREATION TIME, which often--- gets confusing really guickly in extensively edited buffer.------ This `undo()` target provides a way to cycle through linear undo history--- IN ORDER STATES ACTUALLY APPEARED. It does so by registering any new undo--- states plus every time |MiniBracketed.register_undo_state()| is called. To have--- more "out of the box" experience, |u| and |CTRL-R| are remapped to call it after--- they perform their undo/redo.------ Example:------ To show more clearly the difference between advancing this target and using--- built-in functionality, here is an example:------ - Create undo history in a new buffer (|:new|):--- - Enter `one two three` text.--- - Delete first word with `daw` and undo the change with `u`.--- - Delete second word with `daw` and undo the change with `u`.--- - Delete third word with `daw` and undo the change with `u`.------ - Now try one of the following (each one after performing previous steps in--- separate new buffer):--- - Press `u`. It goes back to empty buffer. Press `<C-R>` twice and it--- goes to the latest change (`one two`). No way to get to other states--- (like `two three` or `one three`) with these two keys.------ - Press `g-`. It goes to an empty buffer. Press `g+` 4 times. It cycles--- through all available undo states IN ORDER THEY WERE CREATED.------ - Finally, press `[u`. It goes back to `one two` - state which was--- PREVIOUSLY VISITED by the user. Another `[u` restores `one two three`.--- Use `]U` to go to latest visited undo state.------@param direction __bracketed_direction---@param opts __bracketed_optsMiniBracketed.undo = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'undo') opts = vim.tbl_deep_extend('force', { n_times = vim.v.count1, wrap = true }, H.get_config().undo.options, opts or {})
-- Define iterator that traverses undo states in order they appeared local buf_id = vim.api.nvim_get_current_buf() H.undo_sync(buf_id, vim.fn.undotree())
local iterator = {} local buf_history = H.cache.undo[buf_id] local n = #buf_history
iterator.next = function(id) if id == nil or n <= id then return end return id + 1 end
iterator.prev = function(id) if id == nil or id <= 1 then return end return id - 1 end
iterator.state = buf_history.current_id iterator.start_edge = 0 iterator.end_edge = n + 1
-- Iterate local res_id = MiniBracketed.advance(iterator, direction, opts) if res_id == nil or res_id == iterator.state then return end
-- Apply. Move to undo state by number while recording current history id buf_history.is_advancing = true vim.cmd('undo ' .. buf_history[res_id])
buf_history.current_id = res_idend
--- Register state for undo target------ Use this function to add current undo state to this module's linear undo--- history. It is used in |MiniBracketed.setup()| to remap |u| and |CTRL-R| keys--- to add their new state to linear undo history.MiniBracketed.register_undo_state = function() local buf_id = vim.api.nvim_get_current_buf() local tree = vim.fn.undotree()
-- Synchronize undo history and stop advancing H.undo_sync(buf_id, tree, false)
-- Append new undo state to linear history local buf_history = H.cache.undo[buf_id] H.undo_append_state(buf_history, tree.seq_cur) buf_history.current_id = #buf_historyend
--- Normal window------ Go to next/previous normal window. Order by their number (see |winnr()|).------ Direction "forward" increases window number, "backward" - decreases.------ Only normal (non-floating) windows are used.------@param direction __bracketed_direction---@param opts __bracketed_optsMiniBracketed.window = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'window') opts = vim.tbl_deep_extend('force', { n_times = vim.v.count1, wrap = true }, H.get_config().window.options, opts or {})
-- Define iterator that traverses all normal windows in "natural" order local is_normal = function(win_nr) local win_id = vim.fn.win_getid(win_nr) return vim.api.nvim_win_get_config(win_id).relative == '' end
local iterator = {}
iterator.next = function(win_nr) for nr = win_nr + 1, vim.fn.winnr('$') do if is_normal(nr) then return nr end end end
iterator.prev = function(win_nr) for nr = win_nr - 1, 1, -1 do if is_normal(nr) then return nr end end end
iterator.state = vim.fn.winnr() iterator.start_edge = 0 iterator.end_edge = vim.fn.winnr('$') + 1
-- Iterate local res_win_nr = MiniBracketed.advance(iterator, direction, opts) if res_win_nr == iterator.state then return end
-- Apply vim.api.nvim_set_current_win(vim.fn.win_getid(res_win_nr))end
--- Replace "latest put region" with yank history entry------ After |MiniBracketed.setup()| is called, on every yank/delete/change operation--- (technically, every trigger of |TextYankPost| event) the object of operation--- is added to yank history. Advancing this target will replace the region of--- latest put operation with entry from yank history.------ By default works best if called RIGHT AFTER text paste (like with |p| or |P|).------ To better detect "latest put region", use |MiniBracketed.register_put_region()|--- as described later.------ Direction "forward" goes to newer yank history entry, "backward" - to older.------ Example:------ - Type `one two three`.--- - Yank each word with `yiw`.--- - Create new line and press `p`. This should paste `three`.--- - Type `[y`. This should replace latest `three` with `two`.------ # Latest put region ~------ "Latest put region" is (in order of decreasing priority):--- - The one from latest advance of this target.--- - The one registered by user with |MiniBracketed.register_put_region()|.--- - The one taken from |'[| and |']| marks.------ For users there are these approaches to manage which region will be used:--- - Do nothing. In this case region between `[` / `]` marks will always be used--- for first `yank` advance.--- Although doable, this has several drawbacks: it will use latest yanked or--- changed region or the entire buffer if marks are not set.--- If remember to advance this target only after recent put operation, this--- should work as expected.------ - Remap common put operations to use |MiniBracketed.register_put_region()|.--- After that, only regions from mapped put operations will be used for first--- advance. Example of custom mappings (note use of |:map-expression|): >lua------ local put_keys = { 'p', 'P' }--- for _, lhs in ipairs(put_keys) do--- local rhs = 'v:lua.MiniBracketed.register_put_region("' .. lhs .. '")'--- vim.keymap.set({ 'n', 'x' }, lhs, rhs, { expr = true })--- end--- <---@param direction __bracketed_direction---@param opts __bracketed_opts--- - <operators> `(table)` - array of operator names ("c", "d", or "y") for--- which yank entry should be used to advance. For example, use `{ "y" }`--- to advance only by entries actually resulted from yank operation with |y|.--- Default: `{ 'c', 'd', 'y' }`.MiniBracketed.yank = function(direction, opts) if H.is_disabled() then return end
H.validate_direction(direction, { 'first', 'backward', 'forward', 'last' }, 'yank') -- NOTE: Don't use `tbl_deep_extend` to prefer full input `operators` array local default_opts = { n_times = vim.v.count1, operators = { 'c', 'd', 'y' }, wrap = true } opts = vim.tbl_extend('force', default_opts, H.get_config().yank.options, opts or {})
-- Update yank history data local cache_yank, history = H.cache.yank, H.cache.yank.history local n_history = #history local cur_state = H.get_yank_state() if not vim.deep_equal(cur_state, cache_yank.state) then H.yank_stop_advancing() end
-- Define iterator that traverses yank history for entry with proper operator local iterator = {}
iterator.next = function(id) for i = id + 1, n_history do if vim.tbl_contains(opts.operators, history[i].operator) then return i end end end
iterator.prev = function(id) for i = id - 1, 1, -1 do if vim.tbl_contains(opts.operators, history[i].operator) then return i end end end
iterator.state = cache_yank.current_id iterator.start_edge = 0 iterator.end_edge = n_history + 1
-- Iterate local res_id = MiniBracketed.advance(iterator, direction, opts) if res_id == nil then return end
-- Apply. Replace latest put region with yank history entry -- - Account for possible errors when latest region became out of bounds local ok, _ = pcall(H.replace_latest_put_region, cache_yank.history[res_id]) if not ok then return end
cache_yank.current_id = res_id cache_yank.is_advancing = true cache_yank.state = H.get_yank_state()end
--- Register "latest put region"------ This function should be called after put register becomes relevant--- (|v:register| is appropriately set) but before put operation takes place--- (|'[| and |']| marks become relevant).------ Designed to be used in a user-facing expression mapping (see |:map-expression|).--- For mapping examples see |MiniBracketed.yank()|.------@param put_key string Put keys to be remapped.------@return string Returns `put_key` for a better usage inside expression mappings.MiniBracketed.register_put_region = function(put_key) local buf_id = vim.api.nvim_get_current_buf()
-- Compute mode of register **before** putting (while it is still relevant) local mode = H.get_register_mode(vim.v.register)
-- Register latest put region **after** it is done (when it becomes relevant) vim.schedule(function() H.cache.yank.user_put_regions[buf_id] = H.get_latest_region(mode) end)
return put_keyend
--- Advance iterator------ This is the main function which performs any forward/backward/first/last--- advance in this module. Its basic idea is to take iterator (object containing--- information about current state and how to go to next/previous one) and go--- in certain direction until needed/allowed.------ Notes:--- - Directions "first" and "last" are convenience wrappers for "forward" and--- "backward" with pre-setting initial state to `start_edge` and `end_edge`.--- - Iterators `next()` and `prev()` methods should be able to handle `nil` as input.--- - This function only returns new state and doesn't modify `iterator.state`.------@param iterator table Table:--- - Methods:--- - <next> - given state, return state in forward direction (no wrap).--- - <prev> - given state, return state in backward direction (no wrap).--- - Fields:--- - <state> - object describing current state.--- - <start_edge> (optional) - object with `forward(start_edge)` describing--- first state. If `nil`, can't wrap forward or use direction "first".--- - <end_edge> (optional) - object with `backward(end_edge)` describing--- last state. If `nil`, can't wrap backward or use direction "last".---@param direction string Direction. One of "first", "backward", "forward", "last".---@param opts table|nil Options with the following keys:--- - <n_times> `(number)` - number of times to go in input direction.--- Default: `v:count1`.--- - <wrap> `(boolean)` - whether to wrap around edges when `next()` or--- `prev()` return `nil`. Default: `true`.------@return any Result state. If `nil`, could not reach any valid result state.MiniBracketed.advance = function(iterator, direction, opts) opts = vim.tbl_deep_extend('force', { n_times = vim.v.count1, wrap = true }, opts or {})
-- Use two states: "result" will be used as result, "current" will be used -- for iteration. Separation is needed at least for two reasons: -- - Allow partial reach of `n_times`. -- - Don't allow `start_edge` and `end_edge` be the output. local res_state = iterator.state
-- Compute loop data local iter_method = 'next' local cur_state = res_state
if direction == 'backward' then iter_method = 'prev' end
if direction == 'first' then cur_state, iter_method = iterator.start_edge, 'next' end
if direction == 'last' then cur_state, iter_method = iterator.end_edge, 'prev' end
-- Loop local iter = iterator[iter_method] for _ = 1, opts.n_times do -- Advance cur_state = iter(cur_state)
if cur_state == nil then -- Stop if can't wrap around edges if not opts.wrap then break end
-- Wrap around edge local edge = iterator.start_edge if iter_method == 'prev' then edge = iterator.end_edge end if edge == nil then break end
cur_state = iter(edge)
-- Ensure non-nil new state (can happen when there are no targets) if cur_state == nil then break end end
-- Allow only partial reach of `n_times` res_state = cur_state end
return res_stateend
-- Helper data ================================================================-- Module default configH.default_config = vim.deepcopy(MiniBracketed.config)
H.cache = { -- Tracking of old files for `oldfile()` (this data structure is designed to be -- fast to add new file; initially `nil` to postpone initialization from -- `v:oldfiles` up until it is actually needed): -- - `recency` is a table with file paths as fields and numerical values -- indicating how recent file was accessed (higher - more recent). -- - `max_recency` is a maximum currently used `recency`. Used to add new file. -- - `is_advancing` is an indicator that buffer change was done inside -- `oldfile()` function. It is a key to enabling moving along old files -- (and not just going back and forth between two files because they swap -- places as two most recent files). -- - `last_advanced_bufname` - name of last advanced buffer. Used to update -- recency of only the last buffer entered during advancing. oldfile = nil,
-- Per buffer history of visited undo states. A table for each buffer id: -- - Numerical fields indicate actual history of visited undo states (from -- oldest to latest). -- - <current_id> - identifier of current history entry (used for iteration). -- - <seq_last> - latest recorded state (`seq_last` from `undotree()`). -- - <is_advancing> - whether currently advancing. Used to allow consecutive -- advances along tracked undo history. undo = {},
-- Cache for `yank` targets yank = { -- Per-buffer region of latest advance. Used to correctly determine range -- and mode of latest advanced region. advance_put_regions = {}, -- Current id of yank entry in yank history current_id = 0, -- Yank history. Each element contains data necessary to replace latest put -- region with yanked one. See `track_yank()`. history = {}, -- Whether currently advancing is_advancing = false, -- State of latest yank advancement to determine of currently advancing state = {}, -- Per-buffer region registered by user as "latest put region". Used to -- overcome limitations of automatic detection of latest put region (like -- not reliable mode detection when pasting from register; respecting not -- only regions of put operations, but also yank and change). user_put_regions = {}, },}
-- 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('buffer', config.buffer, 'table') H.check_type('buffer.suffix', config.buffer.suffix, 'string') H.check_type('buffer.options', config.buffer.options, 'table')
H.check_type('comment', config.comment, 'table') H.check_type('comment.suffix', config.comment.suffix, 'string') H.check_type('comment.options', config.comment.options, 'table')
H.check_type('conflict', config.conflict, 'table') H.check_type('conflict.suffix', config.conflict.suffix, 'string') H.check_type('conflict.options', config.conflict.options, 'table')
H.check_type('diagnostic', config.diagnostic, 'table') H.check_type('diagnostic.suffix', config.diagnostic.suffix, 'string') H.check_type('diagnostic.options', config.diagnostic.options, 'table')
H.check_type('file', config.file, 'table') H.check_type('file.suffix', config.file.suffix, 'string') H.check_type('file.options', config.file.options, 'table')
H.check_type('indent', config.indent, 'table') H.check_type('indent.suffix', config.indent.suffix, 'string') H.check_type('indent.options', config.indent.options, 'table')
H.check_type('jump', config.jump, 'table') H.check_type('jump.suffix', config.jump.suffix, 'string') H.check_type('jump.options', config.jump.options, 'table')
H.check_type('location', config.location, 'table') H.check_type('location.suffix', config.location.suffix, 'string') H.check_type('location.options', config.location.options, 'table')
H.check_type('oldfile', config.oldfile, 'table') H.check_type('oldfile.suffix', config.oldfile.suffix, 'string') H.check_type('oldfile.options', config.oldfile.options, 'table')
H.check_type('quickfix', config.quickfix, 'table') H.check_type('quickfix.suffix', config.quickfix.suffix, 'string') H.check_type('quickfix.options', config.quickfix.options, 'table')
H.check_type('treesitter', config.treesitter, 'table') H.check_type('treesitter.suffix', config.treesitter.suffix, 'string') H.check_type('treesitter.options', config.treesitter.options, 'table')
H.check_type('undo', config.undo, 'table') H.check_type('undo.suffix', config.undo.suffix, 'string') H.check_type('undo.options', config.undo.options, 'table')
H.check_type('window', config.window, 'table') H.check_type('window.suffix', config.window.suffix, 'string') H.check_type('window.options', config.window.options, 'table')
H.check_type('yank', config.yank, 'table') H.check_type('yank.suffix', config.yank.suffix, 'string') H.check_type('yank.options', config.yank.options, 'table')
return configend
--stylua: ignoreH.apply_config = function(config) MiniBracketed.config = config
-- Make mappings. NOTE: make 'forward'/'backward' *after* 'first'/'last' to -- allow non-letter suffixes define 'forward'/'backward'. if config.buffer.suffix ~= '' then local low, up = H.get_suffix_variants(config.buffer.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.buffer('first')<CR>", { desc = 'Buffer first' }) H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.buffer('last')<CR>", { desc = 'Buffer last' }) H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.buffer('backward')<CR>", { desc = 'Buffer backward' }) H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.buffer('forward')<CR>", { desc = 'Buffer forward' }) end
if config.comment.suffix ~= '' then local low, up = H.get_suffix_variants(config.comment.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.comment('first')<CR>", { desc = 'Comment first' }) H.map('x', '[' .. up, "<Cmd>lua MiniBracketed.comment('first')<CR>", { desc = 'Comment first' }) H.map('o', '[' .. up, "V<Cmd>lua MiniBracketed.comment('first')<CR>", { desc = 'Comment first' })
H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.comment('last')<CR>", { desc = 'Comment last' }) H.map('x', ']' .. up, "<Cmd>lua MiniBracketed.comment('last')<CR>", { desc = 'Comment last' }) H.map('o', ']' .. up, "V<Cmd>lua MiniBracketed.comment('last')<CR>", { desc = 'Comment last' })
H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.comment('backward')<CR>", { desc = 'Comment backward' }) H.map('x', '[' .. low, "<Cmd>lua MiniBracketed.comment('backward')<CR>", { desc = 'Comment backward' }) H.map('o', '[' .. low, "V<Cmd>lua MiniBracketed.comment('backward')<CR>", { desc = 'Comment backward' })
H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.comment('forward')<CR>", { desc = 'Comment forward' }) H.map('x', ']' .. low, "<Cmd>lua MiniBracketed.comment('forward')<CR>", { desc = 'Comment forward' }) H.map('o', ']' .. low, "V<Cmd>lua MiniBracketed.comment('forward')<CR>", { desc = 'Comment forward' }) end
if config.conflict.suffix ~= '' then local low, up = H.get_suffix_variants(config.conflict.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.conflict('first')<CR>", { desc = 'Conflict first' }) H.map('x', '[' .. up, "<Cmd>lua MiniBracketed.conflict('first')<CR>", { desc = 'Conflict first' }) H.map('o', '[' .. up, "V<Cmd>lua MiniBracketed.conflict('first')<CR>", { desc = 'Conflict first' })
H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.conflict('last')<CR>", { desc = 'Conflict last' }) H.map('x', ']' .. up, "<Cmd>lua MiniBracketed.conflict('last')<CR>", { desc = 'Conflict last' }) H.map('o', ']' .. up, "V<Cmd>lua MiniBracketed.conflict('last')<CR>", { desc = 'Conflict last' })
H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.conflict('backward')<CR>", { desc = 'Conflict backward' }) H.map('x', '[' .. low, "<Cmd>lua MiniBracketed.conflict('backward')<CR>", { desc = 'Conflict backward' }) H.map('o', '[' .. low, "V<Cmd>lua MiniBracketed.conflict('backward')<CR>", { desc = 'Conflict backward' })
H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.conflict('forward')<CR>", { desc = 'Conflict forward' }) H.map('x', ']' .. low, "<Cmd>lua MiniBracketed.conflict('forward')<CR>", { desc = 'Conflict forward' }) H.map('o', ']' .. low, "V<Cmd>lua MiniBracketed.conflict('forward')<CR>", { desc = 'Conflict forward' }) end
if config.diagnostic.suffix ~= '' then local low, up = H.get_suffix_variants(config.diagnostic.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.diagnostic('first')<CR>", { desc = 'Diagnostic first' }) H.map('x', '[' .. up, "<Cmd>lua MiniBracketed.diagnostic('first')<CR>", { desc = 'Diagnostic first' }) H.map('o', '[' .. up, "v<Cmd>lua MiniBracketed.diagnostic('first')<CR>", { desc = 'Diagnostic first' })
H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.diagnostic('last')<CR>", { desc = 'Diagnostic last' }) H.map('x', ']' .. up, "<Cmd>lua MiniBracketed.diagnostic('last')<CR>", { desc = 'Diagnostic last' }) H.map('o', ']' .. up, "v<Cmd>lua MiniBracketed.diagnostic('last')<CR>", { desc = 'Diagnostic last' })
H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.diagnostic('backward')<CR>", { desc = 'Diagnostic backward' }) H.map('x', '[' .. low, "<Cmd>lua MiniBracketed.diagnostic('backward')<CR>", { desc = 'Diagnostic backward' }) H.map('o', '[' .. low, "v<Cmd>lua MiniBracketed.diagnostic('backward')<CR>", { desc = 'Diagnostic backward' })
H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.diagnostic('forward')<CR>", { desc = 'Diagnostic forward' }) H.map('x', ']' .. low, "<Cmd>lua MiniBracketed.diagnostic('forward')<CR>", { desc = 'Diagnostic forward' }) H.map('o', ']' .. low, "v<Cmd>lua MiniBracketed.diagnostic('forward')<CR>", { desc = 'Diagnostic forward' }) end
if config.file.suffix ~= '' then local low, up = H.get_suffix_variants(config.file.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.file('first')<CR>", { desc = 'File first' }) H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.file('last')<CR>", { desc = 'File last' }) H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.file('backward')<CR>", { desc = 'File backward' }) H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.file('forward')<CR>", { desc = 'File forward' }) end
if config.indent.suffix ~= '' then local low, up = H.get_suffix_variants(config.indent.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.indent('first')<CR>", { desc = 'Indent first' }) H.map('x', '[' .. up, "<Cmd>lua MiniBracketed.indent('first')<CR>", { desc = 'Indent first' }) H.map('o', '[' .. up, "V<Cmd>lua MiniBracketed.indent('first')<CR>", { desc = 'Indent first' })
H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.indent('last')<CR>", { desc = 'Indent last' }) H.map('x', ']' .. up, "<Cmd>lua MiniBracketed.indent('last')<CR>", { desc = 'Indent last' }) H.map('o', ']' .. up, "V<Cmd>lua MiniBracketed.indent('last')<CR>", { desc = 'Indent last' })
H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.indent('backward')<CR>", { desc = 'Indent backward' }) H.map('x', '[' .. low, "<Cmd>lua MiniBracketed.indent('backward')<CR>", { desc = 'Indent backward' }) H.map('o', '[' .. low, "V<Cmd>lua MiniBracketed.indent('backward')<CR>", { desc = 'Indent backward' })
H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.indent('forward')<CR>", { desc = 'Indent forward' }) H.map('x', ']' .. low, "<Cmd>lua MiniBracketed.indent('forward')<CR>", { desc = 'Indent forward' }) H.map('o', ']' .. low, "V<Cmd>lua MiniBracketed.indent('forward')<CR>", { desc = 'Indent forward' }) end
if config.jump.suffix ~= '' then -- No Visual mode mappings due to implementation problems () local low, up = H.get_suffix_variants(config.jump.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.jump('first')<CR>", { desc = 'Jump first' }) H.map('o', '[' .. up, "v<Cmd>lua MiniBracketed.jump('first')<CR>", { desc = 'Jump first' })
H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.jump('last')<CR>", { desc = 'Jump last' }) H.map('o', ']' .. up, "v<Cmd>lua MiniBracketed.jump('last')<CR>", { desc = 'Jump last' })
H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.jump('backward')<CR>", { desc = 'Jump backward' }) H.map('o', '[' .. low, "v<Cmd>lua MiniBracketed.jump('backward')<CR>", { desc = 'Jump backward' })
H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.jump('forward')<CR>", { desc = 'Jump forward' }) H.map('o', ']' .. low, "v<Cmd>lua MiniBracketed.jump('forward')<CR>", { desc = 'Jump forward' }) end
if config.oldfile.suffix ~= '' then local low, up = H.get_suffix_variants(config.oldfile.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.oldfile('first')<CR>", { desc = 'Oldfile first' }) H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.oldfile('last')<CR>", { desc = 'Oldfile last' }) H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.oldfile('backward')<CR>", { desc = 'Oldfile backward' }) H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.oldfile('forward')<CR>", { desc = 'Oldfile forward' }) end
if config.location.suffix ~= '' then local low, up = H.get_suffix_variants(config.location.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.location('first')<CR>", { desc = 'Location first' }) H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.location('last')<CR>", { desc = 'Location last' }) H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.location('backward')<CR>", { desc = 'Location backward' }) H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.location('forward')<CR>", { desc = 'Location forward' }) end
if config.quickfix.suffix ~= '' then local low, up = H.get_suffix_variants(config.quickfix.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.quickfix('first')<CR>", { desc = 'Quickfix first' }) H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.quickfix('last')<CR>", { desc = 'Quickfix last' }) H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.quickfix('backward')<CR>", { desc = 'Quickfix backward' }) H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.quickfix('forward')<CR>", { desc = 'Quickfix forward' }) end
if config.treesitter.suffix ~= '' then local low, up = H.get_suffix_variants(config.treesitter.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.treesitter('first')<CR>", { desc = 'Treesitter first' }) H.map('x', '[' .. up, "<Cmd>lua MiniBracketed.treesitter('first')<CR>", { desc = 'Treesitter first' }) H.map('o', '[' .. up, "v<Cmd>lua MiniBracketed.treesitter('first')<CR>", { desc = 'Treesitter first' })
H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.treesitter('last')<CR>", { desc = 'Treesitter last' }) H.map('x', ']' .. up, "<Cmd>lua MiniBracketed.treesitter('last')<CR>", { desc = 'Treesitter last' }) H.map('o', ']' .. up, "v<Cmd>lua MiniBracketed.treesitter('last')<CR>", { desc = 'Treesitter last' })
H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.treesitter('backward')<CR>", { desc = 'Treesitter backward' }) H.map('x', '[' .. low, "<Cmd>lua MiniBracketed.treesitter('backward')<CR>", { desc = 'Treesitter backward' }) H.map('o', '[' .. low, "v<Cmd>lua MiniBracketed.treesitter('backward')<CR>", { desc = 'Treesitter backward' })
H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.treesitter('forward')<CR>", { desc = 'Treesitter forward' }) H.map('x', ']' .. low, "<Cmd>lua MiniBracketed.treesitter('forward')<CR>", { desc = 'Treesitter forward' }) H.map('o', ']' .. low, "v<Cmd>lua MiniBracketed.treesitter('forward')<CR>", { desc = 'Treesitter forward' }) end
if config.undo.suffix ~= '' then local low, up = H.get_suffix_variants(config.undo.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.undo('first')<CR>", { desc = 'Undo first' }) H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.undo('last')<CR>", { desc = 'Undo last' }) H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.undo('backward')<CR>", { desc = 'Undo backward' }) H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.undo('forward')<CR>", { desc = 'Undo forward' })
H.map('n', 'u', 'u<Cmd>lua MiniBracketed.register_undo_state()<CR>') H.map('n', '<C-R>', '<C-R><Cmd>lua MiniBracketed.register_undo_state()<CR>') end
if config.window.suffix ~= '' then local low, up = H.get_suffix_variants(config.window.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.window('first')<CR>", { desc = 'Window first' }) H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.window('last')<CR>", { desc = 'Window last' }) H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.window('backward')<CR>", { desc = 'Window backward' }) H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.window('forward')<CR>", { desc = 'Window forward' }) end
if config.yank.suffix ~= '' then local low, up = H.get_suffix_variants(config.yank.suffix) H.map('n', '[' .. up, "<Cmd>lua MiniBracketed.yank('first')<CR>", { desc = 'Yank first' }) H.map('n', ']' .. up, "<Cmd>lua MiniBracketed.yank('last')<CR>", { desc = 'Yank last' }) H.map('n', '[' .. low, "<Cmd>lua MiniBracketed.yank('backward')<CR>", { desc = 'Yank backward' }) H.map('n', ']' .. low, "<Cmd>lua MiniBracketed.yank('forward')<CR>", { desc = 'Yank forward' }) endend
H.get_suffix_variants = function(char) return char:lower(), char:upper() end
H.create_autocommands = function() local gr = vim.api.nvim_create_augroup('MiniBracketed', {})
local au = function(event, pattern, callback, desc) vim.api.nvim_create_autocmd(event, { group = gr, pattern = pattern, callback = callback, desc = desc }) end
au('BufEnter', '*', H.track_oldfile, 'Track oldfile') au('TextYankPost', '*', H.track_yank, 'Track yank')end
H.is_disabled = function() return vim.g.minibracketed_disable == true or vim.b.minibracketed_disable == true end
H.get_config = function(config) return vim.tbl_deep_extend('force', MiniBracketed.config, vim.b.minibracketed_config or {}, config or {})end
-- Autocommands ---------------------------------------------------------------H.track_oldfile = function() if H.is_disabled() then return end
-- Ensure tracking data is initialized H.oldfile_ensure_initialized()
-- Reset tracking indicator to allow proper tracking of next buffer local is_advancing = H.cache.oldfile.is_advancing H.cache.oldfile.is_advancing = false
-- Track only appropriate buffers (normal buffers with path) local path = vim.api.nvim_buf_get_name(0) local is_proper_buffer = path ~= '' and vim.bo.buftype == '' if not is_proper_buffer then return end
-- If advancing, don't touch tracking data to be able to consecutively move -- along recent files. Cache advanced buffer name to later update recency of -- the last one (just before buffer switching outside of `oldfile()`) local cache_oldfile = H.cache.oldfile
if is_advancing then cache_oldfile.last_advanced_bufname = path return end
-- If not advancing, update recency of a single latest advanced buffer (if -- present) and then update recency of current buffer if cache_oldfile.last_advanced_bufname ~= nil then H.oldfile_update_recency(cache_oldfile.last_advanced_bufname) cache_oldfile.last_advanced_bufname = nil end
H.oldfile_update_recency(path)end
H.track_yank = function() -- Don't track if asked not to. Allows other functionality to disable -- tracking (like in 'mini.move'). if H.is_disabled() then return end
-- Track all `TextYankPost` events without exceptions. This leads to a better -- handling of charwise/linewise/blockwise selection detection. local event = vim.v.event table.insert( H.cache.yank.history, { operator = event.operator, regcontents = event.regcontents, regtype = event.regtype } )
H.yank_stop_advancing()end
-- Comments -------------------------------------------------------------------H.make_comment_checker = function() local left, right = unpack(vim.fn.split(vim.bo.commentstring, '%s')) left, right = left or '', right or '' if left == '' and right == '' then return nil end
-- String is commented if it has structure: -- <space> <left> <anything> <right> <space> local regex = string.format('^%%s-%s.*%s%%s-$', vim.pesc(vim.trim(left)), vim.pesc(vim.trim(right)))
-- Check if line with number `line_num` is a comment. NOTE: `getline()` -- return empty string for invalid line number, which makes them *not -- commented*. return function(line_num) return vim.fn.getline(line_num):find(regex) ~= nil endend
-- Conflicts ------------------------------------------------------------------H.is_conflict_mark = function(line_num) local l_start = vim.fn.getline(line_num):sub(1, 8) return l_start == '<<<<<<< ' or l_start == '=======' or l_start == '>>>>>>> 'end
-- Diagnostic -----------------------------------------------------------------H.diagnostic_jump = function(pos, float, severity) vim.diagnostic.jump({ count = 1, pos = pos, float = float, severity = severity })endif vim.fn.has('nvim-0.11') == 0 then H.diagnostic_jump = function(pos, float, severity) vim.diagnostic.goto_next({ cursor_position = pos, float = float, severity = severity }) endend
-- Files ----------------------------------------------------------------------H.get_file_data = function() -- Compute target directory local cur_buf_path = vim.api.nvim_buf_get_name(0) local dir_path = cur_buf_path ~= '' and vim.fn.fnamemodify(cur_buf_path, ':p:h') or vim.fn.getcwd()
-- Compute sorted array of all files in target directory local dir_handle = vim.loop.fs_scandir(dir_path) local files_stream = function() return vim.loop.fs_scandir_next(dir_handle) end
local files = {} for basename, fs_type in files_stream do if fs_type == 'file' then table.insert(files, basename) end end
-- - Sort files ignoring case table.sort(files, function(x, y) return x:lower() < y:lower() end)
if #files == 0 then return end return { directory = dir_path, file_basenames = files }end
-- Jumps ----------------------------------------------------------------------H.make_jump = function(jump_list, cur_jump_num, new_jump_num) local num_diff = new_jump_num - cur_jump_num
if num_diff == 0 then -- Perform jump manually to always jump. Example: move to last jump and -- move manually; then jump with "last" direction should move to last jump. local jump_entry = jump_list[new_jump_num] pcall(vim.fn.cursor, { jump_entry.lnum, jump_entry.col + 1, jump_entry.coladd }) else -- Use builtin mappings to also update current jump entry local key = num_diff > 0 and '\t' or '\15' vim.cmd('normal! ' .. math.abs(num_diff) .. key) end
-- Open just enough folds vim.cmd('normal! zv')end
-- Oldfile --------------------------------------------------------------------H.oldfile_normalize = function() -- Ensure that tracking data is initialized H.oldfile_ensure_initialized()
-- Order currently readable paths in increasing order of recency local recency_pairs = {} for path, rec in pairs(H.cache.oldfile.recency) do if vim.fn.filereadable(path) == 1 then table.insert(recency_pairs, { path, rec }) end end table.sort(recency_pairs, function(x, y) return x[2] < y[2] end)
-- Construct new tracking data with recency from 1 to number of entries local new_recency = {} for i, pair in ipairs(recency_pairs) do new_recency[pair[1]] = i end
H.cache.oldfile = { recency = new_recency, max_recency = #recency_pairs, is_advancing = H.cache.oldfile.is_advancing }end
H.oldfile_ensure_initialized = function() if H.cache.oldfile ~= nil or vim.v.oldfiles == nil then return end
local n = #vim.v.oldfiles local recency = {} for i, path in ipairs(vim.v.oldfiles) do recency[path] = n - i + 1 end
H.cache.oldfile = { recency = recency, max_recency = n, is_advancing = false }end
H.oldfile_get_array = function() local res = {} for path, i in pairs(H.cache.oldfile.recency) do res[i] = path end return resend
H.oldfile_update_recency = function(path) local n = H.cache.oldfile.max_recency + 1 H.cache.oldfile.recency[path] = n H.cache.oldfile.max_recency = nend
-- Quickfix/Location lists ----------------------------------------------------H.qf_loc_implementation = function(list_type, direction, opts) local get_list, goto_command = vim.fn.getqflist, 'cc' if list_type == 'location' then get_list, goto_command = function(...) return vim.fn.getloclist(0, ...) end, 'll' end
-- Define iterator that traverses quickfix/location list entries local list = get_list() local n_list = #list if n_list == 0 then return end
local iterator = {}
iterator.next = function(ind) if ind == nil or n_list <= ind then return end return ind + 1 end
iterator.prev = function(ind) if ind == nil or ind <= 1 then return end return ind - 1 end
iterator.state = get_list({ idx = 0 }).idx iterator.start_edge = 0 iterator.end_edge = n_list + 1
-- Iterate local res_ind = MiniBracketed.advance(iterator, direction, opts)
-- Apply. Focus target entry, open enough folds and center. Allow jumping to -- current quickfix/loclist entry as it might be different from current -- cursor position. vim.cmd(goto_command .. ' ' .. res_ind) vim.cmd('normal! zvzz')end
-- Treesitter -----------------------------------------------------------------H.get_treesitter_node = function(row, col) return vim.treesitter.get_node({ pos = { row, col } }) end
-- Undo -----------------------------------------------------------------------H.undo_sync = function(buf_id, tree, is_advancing) -- Get or initialize buffer history of visited undo states local prev_buf_history = H.cache.undo[buf_id] or H.undo_init(tree) if is_advancing == nil then is_advancing = prev_buf_history.is_advancing end
-- Prune current buffer history to contain only allowed state numbers. This -- assumes that once undo state is not allowed, it will always be not -- allowed. This step is needed because allowed undo state numbers can: -- - Not start from 1 due to 'undolevels'. -- - Contain range of missing state numbers due to `:undo!`. -- -- Do this even if advancing because `:undo!` can be executed at any time. local allowed_states = H.undo_get_allowed_state_numbers(tree)
local buf_history = {} for i, state_num in ipairs(prev_buf_history) do -- Use only allowed states if allowed_states[state_num] then H.undo_append_state(buf_history, state_num) end
-- Correctly track current id when advancing if i == prev_buf_history.current_id then buf_history.current_id = #buf_history end end buf_history.current_id = buf_history.current_id or #buf_history buf_history.is_advancing = prev_buf_history.is_advancing buf_history.seq_last = prev_buf_history.seq_last
H.cache.undo[buf_id] = buf_history
-- Continue only if not actually advancing: either if set so manually *or* if -- there were additions to undo history *or* some states became not allowed -- (due to `:undo!`). if is_advancing and tree.seq_last <= buf_history.seq_last and #buf_history == #prev_buf_history then return end
-- Register current undo state (if not equal to last). -- Usually it is a result of advance but also can be due to `:undo`/`:undo!`. H.undo_append_state(buf_history, tree.seq_cur)
-- Add all new *allowed* undo states created since last sync for new_state = buf_history.seq_last + 1, tree.seq_last do if allowed_states[new_state] then H.undo_append_state(buf_history, new_state) end end
-- Update data to be most recent buf_history.current_id = #buf_history buf_history.is_advancing = false buf_history.seq_last = tree.seq_lastend
H.undo_append_state = function(buf_history, state_num) -- Ensure that there are no two consecutive equal states if state_num == nil or buf_history[#buf_history] == state_num then return end
table.insert(buf_history, state_num)end
H.undo_init = function(tree) -- Assume all previous states are allowed local res = {} for i = 0, tree.seq_last do res[i + 1] = i end res.current_id = #res res.is_advancing = false res.seq_last = tree.seq_last
return resend
H.undo_get_allowed_state_numbers = function(tree) -- `:undo 0` is always possible (goes to *before* the first allowed state). local res = { [0] = true } local traverse traverse = function(entries) for _, e in ipairs(entries) do if e.alt ~= nil then traverse(e.alt) end res[e.seq] = true end end
traverse(tree.entries) return resend
-- Yank -----------------------------------------------------------------------H.yank_stop_advancing = function() H.cache.yank.current_id = #H.cache.yank.history H.cache.yank.is_advancing = false H.cache.yank.advance_put_regions[vim.api.nvim_get_current_buf()] = nilend
H.get_yank_state = function() return { buf_id = vim.api.nvim_get_current_buf(), changedtick = vim.b.changedtick } end
H.replace_latest_put_region = function(yank_data) -- Squash all yank advancing in a single undo block local normal_command = (H.cache.yank.is_advancing and 'undojoin | ' or '') .. 'silent normal! ' local normal_fun = function(x) vim.cmd(normal_command .. x) end
-- Compute latest put region: from latest `yank` advance; or from user's -- latest put; or from `[`/`]` marks local cache_yank = H.cache.yank local buf_id = vim.api.nvim_get_current_buf() local latest_region = cache_yank.advance_put_regions[buf_id] or cache_yank.user_put_regions[buf_id] or H.get_latest_region()
-- Compute modes for replaced and new regions. local latest_mode = latest_region.mode local new_mode = yank_data.regtype:sub(1, 1)
-- Compute later put key based on replaced and new regions. -- Prefer `P` but use `p` in cases replaced region was on the edge: last line -- for linewise-linewise replace or last column for nonlinewise-nonlinewise. local is_linewise = (latest_mode == 'V' and new_mode == 'V') local is_edge_line = is_linewise and latest_region.to.line == vim.fn.line('$')
local is_charblockwise = (latest_mode ~= 'V' and new_mode ~= 'V') local is_edge_col = is_charblockwise and latest_region.to.col == vim.fn.getline(latest_region.to.line):len()
local is_edge = is_edge_line or is_edge_col local put_key = is_edge and 'p' or 'P'
-- Delete latest region H.region_delete(latest_region, normal_fun)
-- Paste yank data using temporary register local cache_z_reg = vim.fn.getreg('z') vim.fn.setreg('z', yank_data.regcontents, yank_data.regtype)
normal_fun('"z' .. put_key)
vim.fn.setreg('z', cache_z_reg)
-- Register newly put region for correct further advancing cache_yank.advance_put_regions[buf_id] = H.get_latest_region(new_mode)end
H.get_latest_region = function(mode) local left, right = vim.fn.getpos("'["), vim.fn.getpos("']") return { from = { line = left[2], col = left[3] }, to = { line = right[2], col = right[3] }, -- Mode should be one of 'v', 'V', or '\22' ('<C-v>') -- By default use mode of current or unnamed register -- NOTE: this breaks if latest paste was not from unnamed register. -- To account for that, use `register_put_region()`. mode = mode or H.get_register_mode(vim.v.register), }end
H.region_delete = function(region, normal_fun) -- Start with `to` to have cursor positioned on region start after deletion H.set_cursor(region.to.line, region.to.col - 1)
-- Do nothing more if region is empty (or leads to unnecessary line deletion) local is_empty = region.from.line == region.to.line and region.from.col == region.to.col and vim.fn.getline(region.from.line) == ''
if is_empty then return end
-- Select region in correct Visual mode normal_fun(region.mode) H.set_cursor(region.from.line, region.from.col - 1)
-- Delete region in "black hole" register -- - NOTE: it doesn't affect history as `"_` doesn't trigger `TextYankPost` normal_fun('"_d')end
H.get_register_mode = function(register) -- Use only first character to correctly get '\22' in blockwise mode return vim.fn.getregtype(register):sub(1, 1)end
-- Utilities ------------------------------------------------------------------H.error = function(msg) error('(mini.bracketed) ' .. 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.validate_direction = function(direction, choices, fun_name) if not vim.tbl_contains(choices, direction) then local choices_string = "'" .. table.concat(choices, "', '") .. "'" local error_text = string.format('In `%s()` argument `direction` should be one of %s.', fun_name, choices_string) H.error(error_text) endend
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.edit = function(path, win_id) if type(path) ~= 'string' then return end local b = vim.api.nvim_win_get_buf(win_id or 0) local try_mimic_buf_reuse = (vim.fn.bufname(b) == '' and vim.bo[b].buftype ~= 'quickfix' and not vim.bo[b].modified) and (#vim.fn.win_findbuf(b) == 1 and vim.deep_equal(vim.fn.getbufline(b, 1, '$'), { '' })) local buf_id = vim.fn.bufadd(vim.fn.fnamemodify(path, ':.')) -- Showing in window also loads. Use `pcall` to not error with swap messages. pcall(vim.api.nvim_win_set_buf, win_id or 0, buf_id) vim.bo[buf_id].buflisted = true if try_mimic_buf_reuse then pcall(vim.api.nvim_buf_delete, b, { unload = false }) end return buf_idend
H.add_to_jumplist = function() vim.cmd([[normal! m']]) end
H.set_cursor = function(row, col) if row <= 0 then return vim.api.nvim_win_set_cursor(0, { 1, 0 }) end local n_lines = vim.api.nvim_buf_line_count(0) if n_lines < row then return vim.api.nvim_win_set_cursor(0, { n_lines, vim.fn.getline(n_lines):len() - 1 }) end col = math.min(math.max(col, 0), vim.fn.getline(row):len()) return vim.api.nvim_win_set_cursor(0, { row, col })end
return MiniBracketed