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.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959--- *mini.diff* Work with diff hunks------ MIT License Copyright (c) 2024 Evgeni Chasnovski
--- Features:------ - Visualize difference between buffer text and its configurable reference--- interactively (updates as you type). This is done per line showing whether--- it is inside added, changed, or deleted part of difference (called hunk).--- Visualization can be with customizable colored signs or line numbers.------ - Special toggleable overlay view with more hunk details inside text area.--- See |MiniDiff.toggle_overlay()|.------ - Completely configurable per buffer source(s) of reference text used to keep--- it up to date and define interactions with it. Can be array of sources which--- are attempted to attach in order. See |MiniDiff-source-specification|.--- By default uses Git source. See |MiniDiff.gen_source.git()|.------ - Configurable mappings to manage diff hunks:--- - Apply and reset hunks inside region (selected visually or with--- a dot-repeatable operator).--- - "Hunk range under cursor" textobject to be used as operator target.--- - Navigate to first/previous/next/last hunk. See |MiniDiff.goto_hunk()|.------ What it doesn't do:------ - Provide functionality to work directly with Git outside of visualizing--- and staging (applying) hunks with (default) Git source. In particular,--- unstaging hunks is not supported. See |MiniDiff.gen_source.git()|.------ Sources with more details:--- - |MiniDiff-overview|--- - |MiniDiff-source-specification|--- - |MiniDiff-hunk-specification|--- - |MiniDiff-diff-summary|------ # Setup ~------ This module needs a setup with `require('mini.diff').setup({})` (replace--- `{}` with your `config` table). It will create global Lua table `MiniDiff`--- which you can use for scripting or manually (with `:lua MiniDiff.*`).------ See |MiniDiff.config| for `config` structure and default values.------ You can override runtime config settings locally to buffer inside--- `vim.b.minidiff_config` which should have same structure as--- `MiniDiff.config`. See |mini.nvim-buffer-local-config| for more details.------ # Comparisons ~------ - [lewis6991/gitsigns.nvim](https://github.com/lewis6991/gitsigns.nvim):--- - Main inspiration for this module, so there are many similarities.--- - Can display only Git hunks, while this module has extensible design.--- - Provides more functionality to work with Git outside of hunks.--- This module does not (by design).------ # Highlight groups ~--- *MiniDiff-hl-groups*------ - `MiniDiffSignAdd` - "add" hunk lines visualization.--- - `MiniDiffSignChange` - "change" hunk lines visualization.--- - `MiniDiffSignDelete` - "delete" hunk lines visualization.--- - `MiniDiffOverAdd` - added buffer text shown in overlay.--- - `MiniDiffOverChange` - changed reference text shown in overlay.--- - `MiniDiffOverChangeBuf` - changed buffer text shown in overlay.--- - `MiniDiffOverContext` - context of a change shown in reference overlay.--- - `MiniDiffOverContextBuf` - context of a change shown in buffer overlay.--- - `MiniDiffOverDelete` - deleted reference text shown in overlay.------ To change any highlight group, set it directly with |nvim_set_hl()|.------ # Disabling ~------ To temporarily disable features without relying on |MiniDiff.disable()|,--- set `vim.g.minidiff_disable` (globally) or `vim.b.minidiff_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 MiniDiff
--- # Diffs and hunks ~------ The "diff" (short for "difference") is a result of computing how two text--- strings differ from one another. This is done on per line basis, i.e. the--- goal is to compute sequences of lines common to both files, interspersed--- with groups of differing lines (called "hunks").------ Although computing diff is a general concept (used on its own, in Git, etc.),--- this module computes difference between current text in a buffer and some--- reference text which is kept up to date specifically for that buffer.--- For example, default reference text is computed as file content in Git index.--- This can be customized in `config.source` (see |MiniDiff-source-specification|).------ # Hunk specification ~--- *MiniDiff-hunk-specification*------ Hunk describes two sets (one from buffer text, one - from reference) of--- consecutive lines which are different. In this module hunk is stored as--- a table with the following fields:------ - <buf_start> `(number)` - start of hunk buffer lines. First line is 1.--- Can be 0 if first reference lines are deleted.------ - <buf_count> `(number)` - number of consecutive buffer lines. Can be 0 in--- case reference lines are deleted.------ - <ref_start> `(number)` - start of hunk reference lines. First line is 1.--- Can be 0 if lines are added before first reference line.------ - <ref_count> `(number)` - number of consecutive reference lines. Can be 0 in--- case buffer lines are added.------ - <type> `(string)` - hunk type. Can be one of:--- - "add" - lines are present in buffer but absent in reference.--- - "change" - lines are present in both buffer and reference.--- - "delete" - lines are absent in buffer but present in reference.------ # Life cycle ~------ - When entering proper (not already enabled, valid, showing text) buffer,--- it is attempted to be enabled for diff processing.--- - During enabling, attempt attaching the source. This should set up how--- reference text is kept up to date.--- - On every text change, diff computation is scheduled in debounced fashion--- after customizable delay (200 ms by default).--- - After the diff is computed, do the following:--- - Update visualization based on configurable style: either by placing--- colored text in sign column or coloring line numbers. Colors for both--- styles are defined per hunk type in corresponding `MiniDiffSign*`--- highlight group (see |mini.diff|) and sign text for "sign" style can--- be configured in `view.signs` of |MiniDiff.config|.--- - Update overlay view (if it is enabled).--- - Update `vim.b.minidiff_summary` and `vim.b.minidiff_summary_string`--- buffer-local variables. These can be used, for example, in statusline.--- - *MiniDiff-update-event* Trigger `MiniDiffUpdated` `User` event.--- See |MiniDiff-diff-summary| for example of how to use it.------ Notes:--- - Use |:edit| to reset (disable and re-enable) current buffer.--- - To work with BOM bytes, set |'bomb'| and have `ucs-bom` in |'fileencodings'|.------ # Overlay ~------ Along with basic visualization, there is a special view called "overlay".--- Although it is meant for temporary overview of diff details and can be--- manually toggled via |MiniDiff.toggle_overlay()|, text can be changed with--- overlay reacting accordingly.------ It shows more diff details inside text area:------ - Added buffer lines are highlighted with `MiniDiffOverAdd` highlight group.------ - Deleted reference lines are shown as virtual lines and highlighted with--- `MiniDiffOverDelete` highlight group.------ - "Change" hunks with equal number of buffer/reference lines show "word diff".--- This is usually the case when `options.linematch` is enabled (as by default).--- Reference line is shown next to its buffer counterpart. Changed parts are--- highlighted with `MiniDiffOverChange` and `MiniDiffOverChangeBuf` in reference--- and buffer lines. The rest of lines have `MiniDiffOverContext`--- and `MiniDiffOverContextBuf` highlighting.------ Change with unequal number of buffer/reference lines is shown with reference--- part as virtual lines highlighted with `MiniDiffOverChange` group.--- Corresponding buffer lines are treated as context for the change and are--- highlighted with `MiniDiffOverContextBuf` group.------ Notes:--- - Word diff has non-zero context width. This means if changed characters--- are close enough, whole range between them is also colored. This usually--- reduces visual noise.--- - Virtual lines above line 1 (like deleted or changed lines) need manual--- scroll to become visible (with |CTRL-Y|).------ # Mappings ~------ This module provides mappings for common actions with diffs, like:--- - Apply and reset hunks.--- - "Hunk range under cursor" textobject.--- - Go to first/previous/next/last hunk range.------ Examples:--- - `vip` followed by `gh` / `gH` applies/resets hunks inside current paragraph.--- Same can be achieved in operator form `ghip` / `gHip`, which has the--- advantage of being dot-repeatable (see |single-repeat|).--- - `gh_` / `gH_` applies/resets current line (even if it is not a full hunk).--- - `ghgh` / `gHgh` applies/resets hunk range under cursor.--- - `dgh` deletes hunk range under cursor.--- - `[H` / `[h` / `]h` / `]H` navigate cursor to the first / previous / next / last--- hunk range of the current buffer.------ Mappings for some functionality are assumed to be done manually.--- See |MiniDiff.operator()|.------ # Buffer-local variables ~--- *MiniDiff-diff-summary*------ Each enabled buffer has the following buffer-local variables which can be--- used in custom statusline to show an overview of hunks in current buffer:------ - `vim.b.minidiff_summary` is a table with the following fields:--- - `source_name` - name of the active source. This is the only present field--- if buffer's reference text is not (yet) set.--- - `n_ranges` - number of hunk ranges (sequences of contiguous hunks).--- - `add` - number of added lines.--- - `change` - number of changed lines.--- - `delete` - number of deleted lines.------ - `vim.b.minidiff_summary_string` is a string representation of summary--- with a fixed format. Empty string if there is no reference text (yet).--- It is expected to be used as is. To achieve different formatting, use--- `vim.b.minidiff_summary` to construct one. The best way to do this is by--- overriding `vim.b.minidiff_summary_string` inside |MiniDiff-update-event|: >lua------ local format_summary = function(data)--- local summary = vim.b[data.buf].minidiff_summary--- local t = {}--- if summary.add > 0 then table.insert(t, '+' .. summary.add) end--- if summary.change > 0 then table.insert(t, '~' .. summary.change) end--- if summary.delete > 0 then table.insert(t, '-' .. summary.delete) end--- vim.b[data.buf].minidiff_summary_string = table.concat(t, ' ')--- end--- local au_opts = { pattern = 'MiniDiffUpdated', callback = format_summary }--- vim.api.nvim_create_autocmd('User', au_opts)--- <---@tag MiniDiff-overview
---@alias __diff_buf_id number Target buffer identifier. Default: 0 for current buffer.
---@diagnostic disable:undefined-field---@diagnostic disable:discard-returns---@diagnostic disable:unused-local---@diagnostic disable:cast-local-type---@diagnostic disable:undefined-doc-name---@diagnostic disable:luadoc-miss-type-name
-- Module definition ==========================================================local MiniDiff = {}local H = {}
--- Module setup------@param config table|nil Module config table. See |MiniDiff.config|.------@usage >lua--- require('mini.diff').setup() -- use default config--- -- OR--- require('mini.diff').setup({}) -- replace {} with your config table--- <MiniDiff.setup = function(config) -- Export module _G.MiniDiff = MiniDiff
-- Setup config config = H.setup_config(config)
-- Apply config H.apply_config(config)
-- Define behavior H.create_autocommands() for _, buf_id in ipairs(vim.api.nvim_list_bufs()) do H.auto_enable({ buf = buf_id }) end
-- Create default highlighting H.create_default_hl()end
--stylua: ignore--- Defaults ~---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)---@text # View ~------ `config.view` contains settings for how diff hunks are visualized.--- Example of using custom signs: >lua------ require('mini.diff').setup({--- view = {--- style = 'sign',--- signs = { add = '+', change = '~', delete = '-' },--- },--- })--- <--- `view.style` is a string defining visualization style. Can be one of "sign"--- (as a colored sign in a |sign-column|) or "number" (colored line number).--- Default: "number" if |'number'| option is enabled, "sign" otherwise.--- Note: with "sign" style it is better to have |'signcolumn'| always shown.------ `view.signs` is a table with one or two character strings used as signs for--- corresponding ("add", "change", "delete") hunks.--- Default: all hunks use "▒" character resulting in a contiguous colored lines.------ `view.priority` is a number with priority used for visualization and--- overlay |extmarks|.--- Default: 199 which is one less than `user` in |vim.hl.priorities| (on Neovim<0.11--- see |vim.hl.priorities|) to have higher priority than automated--- extmarks but not as in user enabled ones.------ # Source ~--- *MiniDiff-source-specification*------ `config.source` is a table with single source or array of them. Single source--- defines how reference text is managed in a particular buffer. Sources in array--- are attempted to attach in order; call |MiniDiff.disable()| if none attaches.------ A single source table can have the following fields:------ - <attach> `(function)` - callable which defines how and when reference text--- is updated inside a particular buffer. It is used inside |MiniDiff.enable()|--- with a buffer identifier as a single argument.------ Should execute logic which results into calling |MiniDiff.set_ref_text()|--- when reference text for buffer needs to be updated. Like inside callback--- for an |autocommand| or file watcher (see |watch-file|).------ For example, default Git source watches when ".git/index" file is changed--- and computes reference text as the one from Git index for current file.------ Can return `false` to indicate that attach has failed. If attach fail can--- not be inferred immediately (for example, due to asynchronous execution),--- should explicitly call |MiniDiff.fail_attach()| with appropriate arguments.--- This is important to properly process array of sources.------ No default value, should be always supplied.------ - <name> `(string|nil)` - source name. String `"unknown"` is used if not supplied.------ - <detach> `(function|nil)` - callable with cleanup action to be done when--- buffer is disabled. It is called inside |MiniDiff.disable()| with a buffer--- identifier as a single argument.------ If not supplied, nothing is done during detaching.------ - <apply_hunks> `(function|nil)` - callable which defines how hunks are applied.--- It is called with buffer identifier as first argument and array of hunks--- (see |MiniDiff-hunk-specification|) as second. It should eventually update--- reference text: either by explicitly calling |MiniDiff.set_ref_text()| or--- performing action triggering its call.------ For example, default Git source computes patch based on the hunks and--- applies it inside file's git repo.------ If not supplied, applying hunks throws an error.------ Default: a single |MiniDiff.gen_source.git()|.------ # Delay ~------ `config.delay` contains settings for delays in asynchronous processes.------ `delay.text_change` is a number (in ms) defining how long to wait after latest--- text change (in debounced fashion) before updating diff and visualization.--- Default: 200.------ # Mappings ~------ `config.mappings` contains keys which are mapped during |MiniDiff.setup()|.------ `mappings.apply` keys can be used to apply hunks inside visual/operator region.--- What exactly "apply hunks" means depends on the source and its `apply_hunks()`.--- For example, in default Git source it means stage hunks.------ `mappings.reset` keys can be used to reset hunks inside visual/operator region.--- Reset means replacing buffer text in region with corresponding reference text.------ `mappings.textobject` keys define "hunk range under cursor" textobject--- which can be used in Operator-pending mode as target for operator (like--- |d|, |y|, apply/reset hunks, etc.). It is also set up in Visual mode if--- keys do not conflict with `mappings.apply` and `mappings.reset`.--- "Hunk range" is used in a sense that contiguous (back-to-back) hunks are--- considered as parts of a same hunk range.------ `mappings.goto_first` / `mappings.goto_prev` / `mappings.goto_next` /--- `mappings.goto_last` keys can be used to navigate to first / previous / next /--- last hunk range in the current buffer.------ # Options ~------ `config.options` contains various customization options.------ `options.algorithm` is a string defining which diff algorithm to use.--- Default: "histogram". See |vim.text.diff()| (|vim.diff()| on Neovim<=0.11)--- for possible values.------ `options.indent_heuristic` is a boolean defining whether to use indent--- heuristic for a (possibly) more naturally aligned hunks.--- Default: `true`.------ `options.linematch` is a number defining hunk size for which a second--- stage diff is executed for a better aligned and more granular hunks.--- Default: 60. See |vim.text.diff()| (|vim.diff()| on Neovim<=0.11) and |'diffopt'|--- for more details.------ `options.wrap_goto` is a boolean indicating whether to wrap around edges during--- hunk navigation (with |MiniDiff.goto_hunk()| or `goto_*` mappings). Like if--- cursor is after the last hunk, going "next" will put cursor on the first hunk.--- Default: `false`.MiniDiff.config = { -- Options for how hunks are visualized view = { -- Visualization style. Possible values are 'sign' and 'number'. -- Default: 'number' if line numbers are enabled, 'sign' otherwise. style = vim.go.number and 'number' or 'sign',
-- Signs used for hunks with 'sign' view signs = { add = '▒', change = '▒', delete = '▒' },
-- Priority of used visualization extmarks priority = 199, },
-- Source(s) for how reference text is computed/updated/etc -- Uses content from Git index by default source = nil,
-- Delays (in ms) defining asynchronous processes delay = { -- How much to wait before update following every text change text_change = 200, },
-- Module mappings. Use `''` (empty string) to disable one. mappings = { -- Apply hunks inside a visual/operator region apply = 'gh',
-- Reset hunks inside a visual/operator region reset = 'gH',
-- Hunk range textobject to be used inside operator -- Works also in Visual mode if mapping differs from apply and reset textobject = 'gh',
-- Go to hunk range in corresponding direction goto_first = '[H', goto_prev = '[h', goto_next = ']h', goto_last = ']H', },
-- Various options options = { -- Diff algorithm (see `:h vim.text.diff()`) algorithm = 'histogram',
-- Whether to use "indent heuristic" (see `:h vim.text.diff()`) indent_heuristic = true,
-- The amount of second-stage diff to align lines linematch = 60,
-- Whether to wrap around edges during hunk navigation wrap_goto = false, },}--minidoc_afterlines_end
--- Enable diff processing in buffer------@param buf_id __diff_buf_idMiniDiff.enable = function(buf_id) buf_id = H.validate_buf_id(buf_id)
-- Don't enable more than once if H.is_buf_enabled(buf_id) or H.is_disabled(buf_id) then return end
-- Ensure buffer is loaded (to have up to date lines returned) H.buf_ensure_loaded(buf_id)
-- Register enabled buffer with cached data for performance H.update_buf_cache(buf_id)
-- Add buffer watchers vim.api.nvim_buf_attach(buf_id, false, { -- Called on every text change (`:h nvim_buf_lines_event`) on_lines = function(_, _, _, from_line, _, to_line) local buf_cache = H.cache[buf_id] -- Properly detach if diffing is disabled if buf_cache == nil then return true end H.schedule_diff_update(buf_id, buf_cache.config.delay.text_change) end,
-- Called when buffer content is changed outside of current session on_reload = function() H.schedule_diff_update(buf_id, 0) end,
-- Called when buffer is unloaded from memory (`:h nvim_buf_detach_event`), -- **including** `:edit` command on_detach = function() MiniDiff.disable(buf_id) end, })
-- Add buffer autocommands H.setup_buf_autocommands(buf_id)
-- Try attaching source after all necessary watchers are set up. It is needed -- to still have them set up if first source of many returned `false`. local attach_output = H.get_active_source(H.cache[buf_id]).attach(buf_id) if attach_output == false then MiniDiff.fail_attach(buf_id) endend
--- Disable diff processing in buffer------@param buf_id __diff_buf_idMiniDiff.disable = function(buf_id) buf_id = H.validate_buf_id(buf_id)
local buf_cache = H.cache[buf_id] if buf_cache == nil then return end H.cache[buf_id] = nil
pcall(vim.api.nvim_del_augroup_by_id, buf_cache.augroup) vim.b[buf_id].minidiff_summary, vim.b[buf_id].minidiff_summary_string = nil, nil H.clear_all_diff(buf_id) pcall(H.get_active_source(buf_cache).detach, buf_id)end
--- Toggle diff processing in buffer------ Enable if disabled, disable if enabled.------@param buf_id __diff_buf_idMiniDiff.toggle = function(buf_id) buf_id = H.validate_buf_id(buf_id) if H.is_buf_enabled(buf_id) then return MiniDiff.disable(buf_id) end return MiniDiff.enable(buf_id)end
--- Toggle overlay view in buffer------@param buf_id __diff_buf_idMiniDiff.toggle_overlay = function(buf_id) buf_id = H.validate_buf_id(buf_id) local buf_cache = H.cache[buf_id] if buf_cache == nil then H.error(string.format('Buffer %d is not enabled.', buf_id)) end
buf_cache.overlay = not buf_cache.overlay H.clear_all_diff(buf_id) H.schedule_diff_update(buf_id, 0)end
--- Export hunks------ Get and convert hunks from current/all buffers. Example of using it: >lua------ -- Set quickfix list from all available hunks--- vim.fn.setqflist(MiniDiff.export('qf'))--- <---@param format string Output format. Currently only `'qf'` value is supported.---@param opts table|nil Options. Possible fields:--- - <scope> `(string)` - scope defining from which buffers to use hunks.--- One of "all" (all enabled buffers) or "current".------@return table Result of export. Depends on the `format`:--- - If "qf", an array compatible with |setqflist()| and |setloclist()|.MiniDiff.export = function(format, opts) opts = vim.tbl_deep_extend('force', { scope = 'all' }, opts or {}) if format == 'qf' then return H.export_qf(opts) end H.error('`format` should be one of "qf".')end
--- Get buffer data------@param buf_id __diff_buf_id------@return table|nil Table with buffer diff data or `nil` if buffer is not enabled.--- Table has the following fields:--- - <config> `(table)` - config used for this particular buffer.--- - <hunks> `(table)` - array of hunks. See |MiniDiff-hunk-specification|.--- - <overlay> `(boolean)` - whether an overlay view is shown.--- - <ref_text> `(string|nil)` - current value of reference text. Lines are--- separated with newline character (`'\n'`). Can be `nil` indicating that--- reference text was not yet set (for example, if source did not yet react).--- - <summary> `(table)` - overall diff summary. See |MiniDiff-diff-summary|.MiniDiff.get_buf_data = function(buf_id) buf_id = H.validate_buf_id(buf_id) local buf_cache = H.cache[buf_id] if buf_cache == nil then return nil end return vim.deepcopy({ config = buf_cache.config, hunks = buf_cache.hunks, overlay = buf_cache.overlay, ref_text = buf_cache.ref_text, summary = buf_cache.summary, })end
--- Set reference text for the buffer------ Note: this will call |MiniDiff.enable()| for target buffer if it is not--- already enabled.------@param buf_id __diff_buf_id---@param text string|table|nil New reference text. Default: `nil`. Can be:--- - String with `\n` separating lines.--- - Array of strings representing lines.--- - `nil` to unset current reference text (results in no hunks shown).------ Notes:--- - Empty string `''` and empty array `{}` set empty reference text (whole--- buffer text is a single "add" hunk). Use `'\n'` or `{ '' }` to set a single--- empty line as a reference text.--- - Newline character is appended (if not already there) at the end of the--- non-empty reference text for better diffs.MiniDiff.set_ref_text = function(buf_id, text) buf_id = H.validate_buf_id(buf_id) if type(text) == 'table' then text = table.concat(text, '\n') .. (#text > 0 and '\n' or '') end if not (type(text) == 'string' or text == nil) then H.error('`text` should be either string, array, or nil.') end
-- Enable if not already enabled if not H.is_buf_enabled(buf_id) then MiniDiff.enable(buf_id) end if not H.is_buf_enabled(buf_id) then H.error('Can not set reference text for not enabled buffer.') end
-- Appending '\n' makes more intuitive diffs at end-of-file if not (text == nil or text == '' or text:sub(-1) == '\n') then text = text .. '\n' end if text == nil then H.clear_all_diff(buf_id) vim.cmd('redraw') end
-- Immediately update diff H.cache[buf_id].ref_text = text H.schedule_diff_update(buf_id, 0)end
--- Generate builtin sources------ This is a table with function elements. Call to actually get source.--- Examples: >lua------ local diff = require('mini.diff')------ -- Single `save` source--- diff.setup({ source = diff.gen_source.save() })------ -- Multiple sources (attempted to attach in order)--- diff.setup({ source = { diff.gen_source.git(), diff.gen_source.save() } })--- <MiniDiff.gen_source = {}
--- Git source------ Default source. Uses file text from Git index as reference. This results in:--- - "Add" hunks represent text present in current buffer, but not in index.--- - "Change" hunks represent modified text already present in index.--- - "Delete" hunks represent text deleted from index.------ Applying hunks means staging, a.k.a adding to index.--- Notes:--- - Requires Git version at least 2.38.0.--- - There is no capability for unstaging hunks. Use full Git client for that.------@return table Source. See |MiniDiff-source-specification|.MiniDiff.gen_source.git = function() local attach = function(buf_id) -- Try attaching to a buffer only once if H.git_cache[buf_id] ~= nil then return false end
-- Possibly resolve symlinks to get data from the original repo local path = H.get_buf_realpath(buf_id) if path == '' then return false end
-- Claim Git cache to not try to attach to the non-Git path several times. -- NOTE: Do this after `path==''` check since the same buffer can be reused -- for opening actual file (`nvim` -> `:edit file`). H.git_cache[buf_id] = {} H.git_start_watching_index(buf_id, path) end
local detach = function(buf_id) local cache = H.git_cache[buf_id] H.git_cache[buf_id] = nil H.git_invalidate_cache(cache) end
local apply_hunks = function(buf_id, hunks) local path_data = H.git_get_path_data(H.get_buf_realpath(buf_id)) if path_data == nil or path_data.rel_path == nil then return end local patch = H.git_format_patch(buf_id, hunks, path_data) H.git_apply_patch(path_data, patch) end
-- Ensure to clean source cache for `:edit` to force reattach, since regular -- `disable()` from `on_detach` is not enough as there can be no source -- attached (like for files not in Git repo). local augroup = vim.api.nvim_create_augroup('MiniDiffSourceGit', { clear = true }) local clear_buf_cache = function(ev) H.git_cache[ev.buf] = nil end local au_opts = { group = augroup, callback = clear_buf_cache, desc = 'Clear Git cache' } vim.api.nvim_create_autocmd({ 'BufUnload' }, au_opts)
return { name = 'git', attach = attach, detach = detach, apply_hunks = apply_hunks }end
--- "Do nothing" source------ Allows buffers to be enabled while not setting any reference text.--- Use this if the goal is to rely on manual |MiniDiff.set_ref_text()| calls.------@return table Source. See |MiniDiff-source-specification|.MiniDiff.gen_source.none = function() return { name = 'none', attach = function() end }end
--- Latest save source------ Uses text at latest save as the reference. This results into diff showing--- difference after the latest save.------@return table Source. See |MiniDiff-source-specification|.MiniDiff.gen_source.save = function() local augroups = {} local attach = function(buf_id) local augroup = vim.api.nvim_create_augroup('MiniDiffSourceSaveBuffer' .. buf_id, { clear = true }) augroups[buf_id] = augroup
local set_ref = function() if vim.bo[buf_id].modified then return end MiniDiff.set_ref_text(buf_id, H.get_buftext(buf_id)) end
-- Autocommand are more efficient than file watcher as it doesn't read disk local au_opts = { group = augroup, buffer = buf_id, callback = set_ref, desc = 'Set reference text after save' } vim.api.nvim_create_autocmd({ 'BufWritePost', 'FileChangedShellPost' }, au_opts) set_ref() end
local detach = function(buf_id) pcall(vim.api.nvim_del_augroup_by_id, augroups[buf_id]) end
return { name = 'save', attach = attach, detach = detach }end
--- Perform action on hunks in region------ Compute hunks inside a target region (even for hunks only partially inside it)--- and perform apply/reset/yank operation on them.------ The "yank" action yanks all reference lines of target hunks into--- a specified register (should be one of |registers|).------ Notes:--- - Whether hunk is inside a region is computed based on position of its--- buffer lines.--- - If "change" or "delete" is only partially inside a target region, all--- reference lines are used in computed "intersection" hunk.------ Used directly in `config.mappings.apply` and `config.mappings.reset`.--- Usually there is no need to use this function manually.--- See |MiniDiff.operator()| for how to set up a mapping for "yank".------@param buf_id __diff_buf_id---@param action string One of "apply", "reset", "yank".---@param opts table|nil Options. Possible fields:--- - <line_start> `(number)` - start line of the region. Default: 1.--- - <line_end> `(number)` - start line of the region. Default: last buffer line.--- - <register> `(string)` - register to yank reference lines into.--- Default: |v:register|.MiniDiff.do_hunks = function(buf_id, action, opts) buf_id = H.validate_buf_id(buf_id) local buf_cache = H.cache[buf_id] if buf_cache == nil then H.error(string.format('Buffer %d is not enabled.', buf_id)) end if type(buf_cache.ref_text) ~= 'string' then H.error(string.format('Buffer %d has no reference text.', buf_id)) end
if not (action == 'apply' or action == 'reset' or action == 'yank') then H.error('`action` should be one of "apply", "reset", "yank".') end
local default_opts = { line_start = 1, line_end = vim.api.nvim_buf_line_count(buf_id), register = vim.v.register } opts = vim.tbl_deep_extend('force', default_opts, opts or {}) local line_start, line_end = H.validate_target_lines(buf_id, opts.line_start, opts.line_end) if type(opts.register) ~= 'string' then H.error('`opts.register` should be string.') end
local hunks = H.get_hunks_in_range(buf_cache.hunks, line_start, line_end) if #hunks == 0 then return H.notify('No hunks to ' .. action, 'INFO') end if action == 'apply' then if H.has_extra_cursors() and not vim.v.cascading then H.force_mc_cascade() end H.get_active_source(buf_cache).apply_hunks(buf_id, hunks) end if action == 'reset' then H.reset_hunks(buf_id, hunks) end if action == 'yank' then H.yank_hunks_ref(buf_cache.ref_text, hunks, opts.register) endend
--- Go to hunk range in current buffer------@param direction string One of "first", "prev", "next", "last".---@param opts table|nil Options. A table with fields:--- - <n_times> `(number)` - Number of times to advance. Default: |v:count1|.--- - <line_start> `(number)` - Line number to start from for directions--- "prev" and "next". Default: cursor line.--- - <wrap> `(boolean)` - Whether to wrap around edges.--- Default: `options.wrap` value of the config.MiniDiff.goto_hunk = function(direction, opts) local buf_id = vim.api.nvim_get_current_buf() local buf_cache = H.cache[buf_id] if buf_cache == nil then H.error(string.format('Buffer %d is not enabled.', buf_id)) end
if not vim.tbl_contains({ 'first', 'prev', 'next', 'last' }, direction) then H.error('`direction` should be one of "first", "prev", "next", "last".') end
local default_wrap = buf_cache.config.options.wrap_goto local default_opts = { n_times = vim.v.count1, line_start = vim.fn.line('.'), wrap = default_wrap } opts = vim.tbl_deep_extend('force', default_opts, opts or {}) if not (type(opts.n_times) == 'number' and opts.n_times >= 1) then H.error('`opts.n_times` should be positive number.') end if type(opts.line_start) ~= 'number' then H.error('`opts.line_start` should be number.') end if type(opts.wrap) ~= 'boolean' then H.error('`opts.wrap` should be boolean.') end
-- Prepare ranges to iterate. local ranges = H.get_contiguous_hunk_ranges(buf_cache.hunks) if #ranges == 0 then return H.notify('No hunks to go to', 'INFO') end
-- Iterate local res_ind, did_wrap = H.iterate_hunk_ranges(ranges, direction, opts) if res_ind == nil then return H.notify('No hunk ranges in direction ' .. vim.inspect(direction), 'INFO') end local res_line = ranges[res_ind].from if did_wrap then H.notify('Wrapped around edge in direction ' .. vim.inspect(direction), 'INFO') end
-- Add to jumplist vim.cmd([[normal! m']])
-- Jump local _, col = vim.fn.getline(res_line):find('^%s*') vim.api.nvim_win_set_cursor(0, { res_line, col })
-- Open just enough folds vim.cmd('normal! zv')end
--- Perform action over region------ Perform action over region defined by marks. Used in mappings.------ Example of a mapping to yank reference lines of hunk range under cursor--- (assuming default `config.mappings.textobject`): >lua------ local rhs = function() return MiniDiff.operator('yank') .. 'gh' end--- vim.keymap.set('n', 'ghy', rhs, { expr = true, remap = true })--- <---@param mode string One of "apply", "reset", "yank", or the ones used in |g@|.MiniDiff.operator = function(mode) local buf_id = vim.api.nvim_get_current_buf() if H.is_disabled(buf_id) then return '' end
if mode == 'apply' or mode == 'reset' or mode == 'yank' then H.operator_cache = { action = mode, win_view = vim.fn.winsaveview(), register = vim.v.register } vim.o.operatorfunc = 'v:lua.MiniDiff.operator' return 'g@' end local cache = H.operator_cache
-- NOTE: Using `[` / `]` marks also works in Visual mode as because it is -- executed as part of `g@`, which treats visual selection as a result of -- Operator-pending mode mechanics (for which visual selection is allowed to -- define motion/textobject). The downside is that it sets 'operatorfunc', -- but the upside is that it is "dot-repeatable" (for relative selection). local opts = { line_start = vim.fn.line("'["), line_end = vim.fn.line("']"), register = cache.register } if opts.line_end < opts.line_start then return H.notify('Not a proper textobject', 'INFO') end MiniDiff.do_hunks(buf_id, cache.action, opts)
-- Restore window view for "apply" (as buffer text should not have changed) if cache.action == 'apply' and cache.win_view ~= nil then vim.fn.winrestview(cache.win_view) -- NOTE: Restore only once because during dot-repeat it is not up to date cache.win_view = nil end return ''end
--- Select hunk range textobject------ Selects all contiguous lines adjacent to cursor line which are in any (not--- necessarily same) hunk (if cursor line itself is in hunk).--- Used in default mappings.MiniDiff.textobject = function() local buf_id = vim.api.nvim_get_current_buf() local buf_cache = H.cache[buf_id] if buf_cache == nil or H.is_disabled(buf_id) then H.error('Current buffer is not enabled.') end
-- Get hunk range under cursor local cur_line = vim.fn.line('.') local regions, cur_region = H.get_contiguous_hunk_ranges(buf_cache.hunks), nil for _, r in ipairs(regions) do if r.from <= cur_line and cur_line <= r.to then cur_region = r end end if cur_region == nil then return H.notify('No hunk range under cursor', 'INFO') end
-- Select target region local is_visual = vim.tbl_contains({ 'v', 'V', '\22' }, vim.fn.mode()) if is_visual then vim.cmd('normal! \27') end vim.cmd(string.format('normal! %dGV%dG', cur_region.from, cur_region.to))end
--- Indicate source attach fail------ Try to attach next source; if there is none - call |MiniDiff.disable()|.------@param buf_id integer Buffer identifier for which attach has failed.MiniDiff.fail_attach = function(buf_id) buf_id = H.validate_buf_id(buf_id)
-- Do nothing if there was no attempt to enable local buf_cache = H.cache[buf_id] if buf_cache == nil then return end
-- If no next source, disable buffer without calling any of `detach` if buf_cache.source_id >= #buf_cache.source then H.cache[buf_id].source_id = math.huge return MiniDiff.disable(buf_id) end
-- Try attaching next source buf_cache.source_id = buf_cache.source_id + 1 local attach_output = H.get_active_source(H.cache[buf_id]).attach(buf_id) if attach_output == false then MiniDiff.fail_attach(buf_id) endend
-- Helper data ================================================================-- Module default configH.default_config = MiniDiff.config
H.default_source = { MiniDiff.gen_source.git() }
-- TimersH.timer_diff_update = vim.uv.new_timer()
-- Namespaces per highlighter nameH.ns_id = { viz = vim.api.nvim_create_namespace('MiniDiffViz'), overlay = vim.api.nvim_create_namespace('MiniDiffOverlay'),}
-- Cache of buffers waiting for debounced diff updateH.bufs_to_update = {}
-- Cache per enabled bufferH.cache = {}
-- Cache per buffer for attached `git` sourceH.git_cache = {}
-- Cache for operatorH.operator_cache = {}
-- Common extmark data for supported styles--stylua: ignoreH.style_extmark_data = { sign = { hl_group_prefix = 'MiniDiffSign', field = 'sign_hl_group' }, number = { hl_group_prefix = 'MiniDiffSign', field = 'number_hl_group' },}
-- Suffix for overlay virtual lines to be highlighted as full lineH.overlay_suffix = vim.fn.has('nvim-0.13') == 1 and '' or string.rep(' ', vim.o.columns)
-- Flag for whether to handle virtual lines overflowH.extmark_virt_lines_overflow = vim.fn.has('nvim-0.13') == 1 and 'auto' or (vim.fn.has('nvim-0.11') == 1 and 'scroll' or nil)
-- Permanent `vim.diff()` optionsH.vimdiff_opts = { result_type = 'indices', ctxlen = 0, interhunkctxlen = 0 }
-- Options for `vim.diff()` during word diff. Use `interhunkctxlen = 4` to-- reduce noisiness (chosen as slightly less than average English word length)--stylua: ignoreH.worddiff_opts = { algorithm = 'minimal', result_type = 'indices', ctxlen = 0, interhunkctxlen = 4, indent_heuristic = false, linematch = 0}
-- BOM bytes prepended to buffer text if 'bomb' is enabled. See `:h bom-bytes`.--stylua: ignoreH.bom_bytes = { ['utf-8'] = string.char(0xef, 0xbb, 0xbf), ['utf-16be'] = string.char(0xfe, 0xff), ['utf-16'] = string.char(0xfe, 0xff), ['utf-16le'] = string.char(0xff, 0xfe), -- In 'fileencoding', 'utf-32' is transformed into 'ucs-4' ['utf-32be'] = string.char(0x00, 0x00, 0xfe, 0xff), ['ucs-4be'] = string.char(0x00, 0x00, 0xfe, 0xff), ['utf-32'] = string.char(0x00, 0x00, 0xfe, 0xff), ['ucs-4'] = string.char(0x00, 0x00, 0xfe, 0xff), ['utf-32le'] = string.char(0xff, 0xfe, 0x00, 0x00), ['ucs-4le'] = string.char(0xff, 0xfe, 0x00, 0x00),}
-- 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('view', config.view, 'table') H.check_type('view.style', config.view.style, 'string') H.check_type('view.signs', config.view.signs, 'table') H.check_type('view.signs.add', config.view.signs.add, 'string') H.check_type('view.signs.change', config.view.signs.change, 'string') H.check_type('view.signs.delete', config.view.signs.delete, 'string') H.check_type('view.priority', config.view.priority, 'number')
H.check_type('source', config.source, 'table', true)
H.check_type('delay', config.delay, 'table') H.check_type('delay.text_change', config.delay.text_change, 'number')
H.check_type('mappings', config.mappings, 'table') H.check_type('mappings.apply', config.mappings.apply, 'string') H.check_type('mappings.reset', config.mappings.reset, 'string') H.check_type('mappings.textobject', config.mappings.textobject, 'string') H.check_type('mappings.goto_first', config.mappings.goto_first, 'string') H.check_type('mappings.goto_prev', config.mappings.goto_prev, 'string') H.check_type('mappings.goto_next', config.mappings.goto_next, 'string') H.check_type('mappings.goto_last', config.mappings.goto_last, 'string')
H.check_type('options', config.options, 'table') H.check_type('options.algorithm', config.options.algorithm, 'string') H.check_type('options.indent_heuristic', config.options.indent_heuristic, 'boolean') H.check_type('options.linematch', config.options.linematch, 'number') H.check_type('options.wrap_goto', config.options.wrap_goto, 'boolean')
return configend
H.apply_config = function(config) MiniDiff.config = config
-- Make mappings local mappings = config.mappings
local rhs_apply = function() return MiniDiff.operator('apply') end H.map({ 'n', 'x' }, mappings.apply, rhs_apply, { expr = true, desc = 'Apply hunks' }) local rhs_reset = function() return MiniDiff.operator('reset') end H.map({ 'n', 'x' }, mappings.reset, rhs_reset, { expr = true, desc = 'Reset hunks' })
local is_tobj_conflict = mappings.textobject == mappings.apply or mappings.textobject == mappings.reset local modes = is_tobj_conflict and { 'o' } or { 'x', 'o' } H.map(modes, mappings.textobject, '<Cmd>lua MiniDiff.textobject()<CR>', { desc = 'Hunk range textobject' })
--stylua: ignore start H.map({ 'n', 'x' }, mappings.goto_first, "<Cmd>lua MiniDiff.goto_hunk('first')<CR>", { desc = 'First hunk' }) H.map('o', mappings.goto_first, "V<Cmd>lua MiniDiff.goto_hunk('first')<CR>", { desc = 'First hunk' }) H.map({ 'n', 'x' }, mappings.goto_prev, "<Cmd>lua MiniDiff.goto_hunk('prev')<CR>", { desc = 'Previous hunk' }) H.map('o', mappings.goto_prev, "V<Cmd>lua MiniDiff.goto_hunk('prev')<CR>", { desc = 'Previous hunk' }) H.map({ 'n', 'x' }, mappings.goto_next, "<Cmd>lua MiniDiff.goto_hunk('next')<CR>", { desc = 'Next hunk' }) H.map('o', mappings.goto_next, "V<Cmd>lua MiniDiff.goto_hunk('next')<CR>", { desc = 'Next hunk' }) H.map({ 'n', 'x' }, mappings.goto_last, "<Cmd>lua MiniDiff.goto_hunk('last')<CR>", { desc = 'Last hunk' }) H.map('o', mappings.goto_last, "V<Cmd>lua MiniDiff.goto_hunk('last')<CR>", { desc = 'Last hunk' }) --stylua: ignore end
-- Register decoration provider which actually makes visualization local ns_id_viz, ns_id_overlay = H.ns_id.viz, H.ns_id.overlay H.set_decoration_provider(ns_id_viz, ns_id_overlay)end
H.create_autocommands = function() local gr = vim.api.nvim_create_augroup('MiniDiff', {})
local au = function(event, pattern, callback, desc) vim.api.nvim_create_autocmd(event, { group = gr, pattern = pattern, callback = callback, desc = desc }) end
-- NOTE: Try auto enabling buffer on every `BufEnter` to not have `:edit` -- disabling buffer, as it calls `on_detach()` from buffer watcher au('BufEnter', '*', H.auto_enable, 'Enable diff') au('VimResized', '*', H.on_resize, 'Track Neovim resizing') au('ColorScheme', '*', H.create_default_hl, 'Ensure colors')end
--stylua: ignoreH.create_default_hl = function() local hi = function(name, opts) opts.default = true vim.api.nvim_set_hl(0, name, opts) end
hi('MiniDiffSignAdd', { link = 'Added' }) hi('MiniDiffSignChange', { link = 'Changed' }) hi('MiniDiffSignDelete', { link = 'Removed' }) hi('MiniDiffOverAdd', { link = 'DiffAdd' }) hi('MiniDiffOverChange', { link = 'DiffText' }) hi('MiniDiffOverChangeBuf', { link = 'MiniDiffOverChange'}) hi('MiniDiffOverContext', { link = 'DiffChange' }) hi('MiniDiffOverContextBuf', {}) hi('MiniDiffOverDelete', { link = 'DiffDelete' })end
H.is_disabled = function(buf_id) local buf_disable = H.get_buf_var(buf_id, 'minidiff_disable') return vim.g.minidiff_disable == true or buf_disable == trueend
H.get_config = function(config, buf_id) local buf_config = H.get_buf_var(buf_id, 'minidiff_config') or {} return vim.tbl_deep_extend('force', MiniDiff.config, buf_config, config or {})end
H.get_buf_var = function(buf_id, name) if not vim.api.nvim_buf_is_valid(buf_id) then return nil end return vim.b[buf_id or 0][name]end
-- Autocommands ---------------------------------------------------------------H.auto_enable = vim.schedule_wrap(function(data) if H.is_buf_enabled(data.buf) or H.is_disabled(data.buf) then return end local buf = data.buf if not (vim.api.nvim_buf_is_loaded(buf) and vim.bo[buf].buftype == '' and vim.bo[buf].buflisted) then return end if not H.is_buf_text(buf) then return end MiniDiff.enable(buf)end)
H.on_resize = function() H.overlay_suffix = vim.fn.has('nvim-0.13') == 1 and '' or string.rep(' ', vim.o.columns) for buf_id, _ in pairs(H.cache) do if vim.api.nvim_buf_is_valid(buf_id) then H.clear_all_diff(buf_id) H.schedule_diff_update(buf_id, 0) end endend
-- Validators -----------------------------------------------------------------H.validate_buf_id = function(x) if x == nil or x == 0 then return vim.api.nvim_get_current_buf() end if not (type(x) == 'number' and vim.api.nvim_buf_is_valid(x)) then H.error('`buf_id` should be `nil` or valid buffer id.') end return xend
H.validate_target_lines = function(buf_id, line_start, line_end) local n_lines = vim.api.nvim_buf_line_count(buf_id)
if type(line_start) ~= 'number' then H.error('`line_start` should be number.') end if type(line_end) ~= 'number' then H.error('`line_end` should be number.') end
-- Allow negative lines to count from last line line_start = line_start < 0 and (n_lines + line_start + 1) or line_start line_end = line_end < 0 and (n_lines + line_end + 1) or line_end
-- Clamp to fit the allowed range line_start = math.min(math.max(line_start, 1), n_lines) line_end = math.min(math.max(line_end, 1), n_lines) if not (line_start <= line_end) then H.error('`line_start` should be less than or equal to `line_end`.') end
return line_start, line_endend
H.validate_callable = function(x, name) if vim.is_callable(x) then return x end H.error('`' .. name .. '` should be callable.')end
-- Enabling -------------------------------------------------------------------H.is_buf_enabled = function(buf_id) return H.cache[buf_id] ~= nil end
H.update_buf_cache = function(buf_id) local new_cache = H.cache[buf_id] or {}
local buf_config = H.get_config({}, buf_id) new_cache.config = buf_config new_cache.extmark_opts = H.convert_view_to_extmark_opts(buf_config.view) new_cache.source = H.normalize_source(buf_config.source or H.default_source) new_cache.source_id = new_cache.source_id or 1
new_cache.hunks = new_cache.hunks or {} new_cache.summary = new_cache.summary or {} new_cache.viz_lines = new_cache.viz_lines or {}
if new_cache.overlay == nil then new_cache.overlay = false end new_cache.overlay_lines = new_cache.overlay_lines or {}
H.cache[buf_id] = new_cacheend
H.setup_buf_autocommands = function(buf_id) local augroup = vim.api.nvim_create_augroup('MiniDiffBuffer' .. buf_id, { clear = true }) H.cache[buf_id].augroup = augroup
local buf_update = vim.schedule_wrap(function() H.update_buf_cache(buf_id) end) local bufwinenter_opts = { group = augroup, buffer = buf_id, callback = buf_update, desc = 'Update buffer cache' } vim.api.nvim_create_autocmd('BufWinEnter', bufwinenter_opts)
local reset_if_enabled = vim.schedule_wrap(function(data) if not H.is_buf_enabled(data.buf) then return end MiniDiff.disable(data.buf) MiniDiff.enable(data.buf) end) local bufrename_opts = { group = augroup, buffer = buf_id, callback = reset_if_enabled, desc = 'Reset on rename' } -- NOTE: `BufFilePost` does not look like a proper event, but it (yet) works vim.api.nvim_create_autocmd('BufFilePost', bufrename_opts)
local buf_disable = function() MiniDiff.disable(buf_id) end local bufdelete_opts = { group = augroup, buffer = buf_id, callback = buf_disable, desc = 'Disable on delete' } vim.api.nvim_create_autocmd('BufDelete', bufdelete_opts)end
H.normalize_source = function(source) -- Normalize to an array of sources if type(source) ~= 'table' then H.error('`source` should be table.') end if source[1] == nil then source = { source } end
local res = {} for i, s in ipairs(source) do local cur_s = { attach = s.attach } cur_s.name = s.name or 'unknown' cur_s.detach = s.detach or function(_) end cur_s.apply_hunks = s.apply_hunks or function(_) H.error('Current source does not support applying hunks.') end
if type(cur_s.name) ~= 'string' then H.error('`source.name` should be string.') end H.validate_callable(cur_s.attach, 'source.attach') H.validate_callable(cur_s.detach, 'source.detach') H.validate_callable(cur_s.apply_hunks, 'source.apply_hunks')
res[i] = cur_s end
return resend
H.get_active_source = function(buf_cache) return buf_cache.source[buf_cache.source_id] or {} end
H.convert_view_to_extmark_opts = function(view) local extmark_data = H.style_extmark_data[view.style] if extmark_data == nil then H.error('Style ' .. vim.inspect(view.style) .. ' is not supported.') end
local signs = view.style == 'sign' and view.signs or {} local field, hl_group_prefix = extmark_data.field, extmark_data.hl_group_prefix --stylua: ignore return { add = { [field] = hl_group_prefix .. 'Add', sign_text = signs.add, priority = view.priority, invalidate = true }, change = { [field] = hl_group_prefix .. 'Change', sign_text = signs.change, priority = view.priority, invalidate = true }, delete = { [field] = hl_group_prefix .. 'Delete', sign_text = signs.delete, priority = view.priority, invalidate = true }, }end
-- Processing -----------------------------------------------------------------H.set_decoration_provider = function(ns_id_viz, ns_id_overlay) local on_win = function(_, _, buf_id, top, bottom) local buf_cache = H.cache[buf_id] if buf_cache == nil then return false end
local viz_lines, overlay_lines = buf_cache.viz_lines, buf_cache.overlay_lines if buf_cache.needs_clear then H.clear_all_diff(buf_id) buf_cache.needs_clear, buf_cache.dummy_extmark = false, nil -- Ensure that sign column is visible even if hunks are outside of window -- view (matters with `signcolumn=auto`) if buf_cache.config.view.style == 'sign' and not vim.tbl_isempty(viz_lines) then local dummy_opts = { sign_text = ' ', priority = 0, right_gravity = false } dummy_opts.sign_hl_group, dummy_opts.cursorline_hl_group = 'SignColumn', 'CursorLineSign' buf_cache.dummy_extmark = vim.api.nvim_buf_set_extmark(buf_id, ns_id_viz, 0, 0, dummy_opts) end end
local has_viz_extmarks = false for i = top + 1, bottom + 1 do if viz_lines[i] ~= nil then H.set_extmark(buf_id, ns_id_viz, i - 1, 0, viz_lines[i]) viz_lines[i] = nil has_viz_extmarks = true end if overlay_lines[i] ~= nil then -- Allow several overlays at one line (like for "delete" and "change") for j = 1, #overlay_lines[i] do H.draw_overlay_line(buf_id, ns_id_overlay, i - 1, overlay_lines[i][j]) end overlay_lines[i] = nil end end
-- Make sure to clear dummy extmark when it is not needed (otherwise it -- affects signcolumn for cases like `yes:2` and `auto:2`) if buf_cache.dummy_extmark ~= nil and has_viz_extmarks then vim.api.nvim_buf_del_extmark(buf_id, ns_id_viz, buf_cache.dummy_extmark) buf_cache.dummy_extmark = nil end end vim.api.nvim_set_decoration_provider(ns_id_viz, { on_win = on_win })end
H.schedule_diff_update = vim.schedule_wrap(function(buf_id, delay_ms) H.bufs_to_update[buf_id] = true H.timer_diff_update:stop() H.timer_diff_update:start(delay_ms, 0, H.process_scheduled_buffers)end)
H.process_scheduled_buffers = vim.schedule_wrap(function() for buf_id, _ in pairs(H.bufs_to_update) do H.update_buf_diff(buf_id) end H.bufs_to_update = {}end)
H.update_buf_diff = vim.schedule_wrap(function(buf_id) -- Make early returns local buf_cache = H.cache[buf_id] if buf_cache == nil then return end if not vim.api.nvim_buf_is_valid(buf_id) then H.cache[buf_id] = nil return end if type(buf_cache.ref_text) ~= 'string' or H.is_disabled(buf_id) then local summary = { source_name = H.get_active_source(buf_cache).name } buf_cache.hunks, buf_cache.viz_lines, buf_cache.overlay_lines, buf_cache.summary = {}, {}, {}, summary vim.b[buf_id].minidiff_summary, vim.b[buf_id].minidiff_summary_string = summary, '' return end
-- Compute diff local options = buf_cache.config.options H.vimdiff_opts.algorithm = options.algorithm H.vimdiff_opts.indent_heuristic = options.indent_heuristic H.vimdiff_opts.linematch = options.linematch
local buf_text, buf_lines = H.get_buftext(buf_id) local diff = vim.diff(buf_cache.ref_text, buf_text, H.vimdiff_opts)
-- Recompute hunks with summary and draw information H.update_hunk_data(diff, buf_cache, buf_lines)
-- Set buffer-local variables with summary for easier external usage local summary = buf_cache.summary vim.b[buf_id].minidiff_summary = summary
local summary_string = {} if summary.n_ranges > 0 then table.insert(summary_string, '#' .. summary.n_ranges) end if summary.add > 0 then table.insert(summary_string, '+' .. summary.add) end if summary.change > 0 then table.insert(summary_string, '~' .. summary.change) end if summary.delete > 0 then table.insert(summary_string, '-' .. summary.delete) end vim.b[buf_id].minidiff_summary_string = table.concat(summary_string, ' ')
-- Request highlighting clear to be done in decoration provider buf_cache.needs_clear = true
-- Trigger event for users to possibly hook into. Ensure target buffer is -- current (for proper `buf` in event data) vim.api.nvim_buf_call(buf_id, function() vim.api.nvim_exec_autocmds('User', { pattern = 'MiniDiffUpdated' }) end)
-- Force redraw. NOTE: Using 'redraw' not always works (`<Cmd>update<CR>` -- from keymap with "save" source will not redraw) while 'redraw!' flickers. H.redraw_buffer(buf_id)end)
H.update_hunk_data = function(diff, buf_cache, buf_lines) local do_overlay = buf_cache.overlay local ref_lines = do_overlay and vim.split(buf_cache.ref_text, '\n') or nil
local extmark_opts, priority = buf_cache.extmark_opts, buf_cache.config.view.priority local hunks, viz_lines, overlay_lines = {}, {}, {} local n_add, n_change, n_delete = 0, 0, 0 local n_ranges, last_range_to = 0, -math.huge for i, d in ipairs(diff) do -- Hunk local n_ref, n_buf = d[2], d[4] local hunk_type = n_ref == 0 and 'add' or (n_buf == 0 and 'delete' or 'change') local hunk = { type = hunk_type, ref_start = d[1], ref_count = n_ref, buf_start = d[3], buf_count = n_buf } hunks[i] = hunk
-- Hunk summary local hunk_n_change = math.min(n_ref, n_buf) n_add = n_add + n_buf - hunk_n_change n_change = n_change + hunk_n_change n_delete = n_delete + n_ref - hunk_n_change
-- Number of contiguous ranges. -- NOTE: this relies on `vim.diff()` output being sorted by `buf_start`. local range_from = math.max(d[3], 1) local range_to = range_from + math.max(n_buf, 1) - 1 n_ranges = n_ranges + ((range_from <= last_range_to + 1) and 0 or 1) last_range_to = math.max(last_range_to, range_to)
-- Register lines for draw. At least one line should visualize hunk. local viz_ext_opts = extmark_opts[hunk_type] for l_num = range_from, range_to do -- Prefer showing "change" hunk over other types if viz_lines[l_num] == nil or hunk_type == 'change' then viz_lines[l_num] = viz_ext_opts end end
if do_overlay then if hunk_type == 'add' then H.append_overlay_add(overlay_lines, hunk, priority) end if hunk_type == 'change' then H.append_overlay_change(overlay_lines, hunk, ref_lines, buf_lines, priority) end if hunk_type == 'delete' then H.append_overlay_delete(overlay_lines, hunk, ref_lines, priority) end end end
buf_cache.hunks, buf_cache.viz_lines, buf_cache.overlay_lines = hunks, viz_lines, overlay_lines buf_cache.summary = { add = n_add, change = n_change, delete = n_delete, n_ranges = n_ranges } buf_cache.summary.source_name = H.get_active_source(buf_cache).nameend
H.clear_all_diff = function(buf_id) H.clear_namespace(buf_id, H.ns_id.viz, 0, -1) H.clear_namespace(buf_id, H.ns_id.overlay, 0, -1)end
-- Overlay --------------------------------------------------------------------H.append_overlay = function(overlay_lines, l_num, data) local t = overlay_lines[l_num] or {} table.insert(t, data) overlay_lines[l_num] = tend
H.append_overlay_add = function(overlay_lines, hunk, priority) -- Append one by one to have them reveal granularly when scrolling up for lnum = hunk.buf_start, hunk.buf_start + hunk.buf_count - 1 do H.append_overlay(overlay_lines, lnum, { type = 'add', priority = priority }) endend
H.append_overlay_change = function(overlay_lines, hunk, ref_lines, buf_lines, priority) -- For one-to-one change, show lines separately with word diff highlighted -- This is usually the case when `linematch` is on if hunk.buf_count == hunk.ref_count then for i = 0, hunk.ref_count - 1 do local ref_n, buf_n = hunk.ref_start + i, hunk.buf_start + i -- Defer actually computing word diff until in decoration provider as it -- will compute only for displayed lines local data = { type = 'change_worddiff', ref_line = ref_lines[ref_n], buf_line = buf_lines[buf_n], priority = priority } H.append_overlay(overlay_lines, buf_n, data) end return end
-- If not one-to-one change, show reference lines above first real one local changed_lines = {} for i = hunk.ref_start, hunk.ref_start + hunk.ref_count - 1 do -- End with `{'', '...'}` chunk to extend highlight past end of line local l = { { ref_lines[i], 'MiniDiffOverChange' }, { H.overlay_suffix, 'MiniDiffOverChange' } } table.insert(changed_lines, l) end local data = { type = 'change', lines = changed_lines, show_above = true, priority = priority } H.append_overlay(overlay_lines, hunk.buf_start, data)
-- - Append one by one to have them reveal granularly when scrolling up for lnum = hunk.buf_start + 1, hunk.buf_start + hunk.buf_count - 1 do H.append_overlay(overlay_lines, lnum, { type = 'change', priority = priority }) endend
H.append_overlay_delete = function(overlay_lines, hunk, ref_lines, priority) local deleted_lines = {} for i = hunk.ref_start, hunk.ref_start + hunk.ref_count - 1 do table.insert(deleted_lines, { { ref_lines[i], 'MiniDiffOverDelete' }, { H.overlay_suffix, 'MiniDiffOverDelete' } }) end local l_num, show_above = math.max(hunk.buf_start, 1), hunk.buf_start == 0 local data = { type = 'delete', lines = deleted_lines, show_above = show_above, priority = priority } H.append_overlay(overlay_lines, l_num, data)end
H.draw_overlay_line = function(buf_id, ns_id, row, data) -- "Change worddif" hunk: compute word diff and show it above and over text if data.type == 'change_worddiff' then return H.draw_overlay_line_worddiff(buf_id, ns_id, row, data) end
local opts = { priority = data.priority }
-- "Add"/"Change" hunks highlight whole lines in affected buffer range if data.type ~= 'delete' then opts.end_row, opts.end_col, opts.hl_eol = row + 1, 0, true opts.hl_group = data.type == 'add' and 'MiniDiffOverAdd' or 'MiniDiffOverContextBuf' end
-- "Change"/"Delete" hunks show affected reference range as virtual lines opts.virt_lines, opts.virt_lines_above, opts.virt_lines_overflow = data.lines, data.show_above, H.extmark_virt_lines_overflow H.set_extmark(buf_id, ns_id, row, 0, opts)end
H.draw_overlay_line_worddiff = function(buf_id, ns_id, row, data) local ref_line, buf_line, priority = data.ref_line, data.buf_line, data.priority local ref_parts, buf_parts = H.compute_worddiff_changed_parts(ref_line, buf_line)
-- Show changes in reference as two-colored virtual line above local virt_line, index = {}, 1 for i = 1, #ref_parts do local part = ref_parts[i] if index < part[1] then table.insert(virt_line, { ref_line:sub(index, part[1] - 1), 'MiniDiffOverContext' }) end table.insert(virt_line, { ref_line:sub(part[1], part[2]), 'MiniDiffOverChange' }) index = part[2] + 1 end if index <= ref_line:len() then table.insert(virt_line, { ref_line:sub(index), 'MiniDiffOverContext' }) end table.insert(virt_line, { H.overlay_suffix, 'MiniDiffOverContext' })
--stylua: ignore local ref_opts = { virt_lines = { virt_line }, virt_lines_above = true, virt_lines_overflow = H.extmark_virt_lines_overflow, priority = priority, } H.set_extmark(buf_id, ns_id, row, 0, ref_opts)
-- Show changes in buffer line as one whole-line highlighting with separate -- highlighting for changed regions on top (as priority of context is lower) local off = vim.bo[buf_id].bomb and (H.bom_bytes[vim.bo[buf_id].fileencoding] or ''):len() or 0 for i = 1, #buf_parts do local part = buf_parts[i] local buf_opts = { end_row = row, end_col = part[2] - off, hl_group = 'MiniDiffOverChangeBuf', priority = priority } H.set_extmark(buf_id, ns_id, row, part[1] - 1 - off, buf_opts) end local context_opts = { end_row = row + 1, end_col = 0, hl_group = 'MiniDiffOverContextBuf', hl_eol = true, priority = priority - 1 } H.set_extmark(buf_id, ns_id, row, 0, context_opts)end
H.compute_worddiff_changed_parts = function(ref_line, buf_line) local ref_sliced, ref_byte_starts, ref_byte_ends = H.slice_line(ref_line) local buf_sliced, buf_byte_starts, buf_byte_ends = H.slice_line(buf_line) local diff = vim.diff(ref_sliced, buf_sliced, H.worddiff_opts) local ref_ranges, buf_ranges = {}, {} for i = 1, #diff do local d = diff[i] if d[2] > 0 then table.insert(ref_ranges, { ref_byte_starts[d[1]], ref_byte_ends[d[1] + d[2] - 1] }) end if d[4] > 0 then table.insert(buf_ranges, { buf_byte_starts[d[3]], buf_byte_ends[d[3] + d[4] - 1] }) end end
return ref_ranges, buf_rangesend
H.str_utfindex = function(s, i) return vim.str_utfindex(s, 'utf-32', i) endif vim.fn.has('nvim-0.11') == 0 then H.str_utfindex = function(s, i) return (vim.str_utfindex(s, i)) end end
H.slice_line = function(line) -- Intertwine every proper character with '\n' local line_len = line:len() local sliced, starts, ends -- Make short route for a very common case of no multibyte characters if H.str_utfindex(line) == line_len then sliced, starts, ends = line:gsub('(.)', '%1\n'), {}, {} for i = 1, string.len(line) do starts[i], ends[i] = i, i end else sliced, starts, ends = {}, vim.str_utf_pos(line), {} for i = 1, #starts - 1 do table.insert(sliced, line:sub(starts[i], starts[i + 1] - 1)) table.insert(ends, starts[i + 1] - 1) end table.insert(sliced, line:sub(starts[#starts], line_len)) table.insert(ends, line_len) sliced = table.concat(sliced, '\n') .. '\n' end
return sliced, starts, endsend
-- Hunks ----------------------------------------------------------------------H.get_hunk_buf_range = function(hunk) -- "Change" and "Add" hunks have the range `[from, from + buf_count - 1]` if hunk.buf_count > 0 then return hunk.buf_start, hunk.buf_start + hunk.buf_count - 1 end -- "Delete" hunks have `buf_count = 0` yet its range is `[from, from]` -- `buf_start` can be 0 for 'delete' hunk, yet range should be real lines local from = math.max(hunk.buf_start, 1) return from, fromend
H.get_hunks_in_range = function(hunks, from, to) local res = {} for _, h in ipairs(hunks) do local h_from, h_to = H.get_hunk_buf_range(h)
local left, right = math.max(from, h_from), math.min(to, h_to) if left <= right then -- If any `cur` hunk part is selected, its `ref` part is used fully local new_h = { ref_start = h.ref_start, ref_count = h.ref_count } new_h.type = h.ref_count == 0 and 'add' or (h.buf_count == 0 and 'delete' or 'change')
-- It should be possible to work with only hunk part inside target range -- Also Treat "delete" hunks differently as they represent range differently -- and can have `buf_start=0` new_h.buf_start = new_h.type == 'delete' and h.buf_start or left new_h.buf_count = new_h.type == 'delete' and 0 or (right - left + 1)
table.insert(res, new_h) end end
table.sort(res, H.hunk_order) return resend
H.reset_hunks = function(buf_id, hunks) local ref_lines = vim.split(H.cache[buf_id].ref_text, '\n') local offset = 0 for _, h in ipairs(hunks) do -- Replace current hunk lines with corresponding reference local new_lines = vim.list_slice(ref_lines, h.ref_start, h.ref_start + h.ref_count - 1)
-- Compute buffer offset from parts: result of previous replaces, "delete" -- hunk offset which starts below the `buf_start` line, zero-indexing. local buf_offset = offset + (h.buf_count == 0 and 1 or 0) - 1 local from, to = h.buf_start + buf_offset, h.buf_start + h.buf_count + buf_offset vim.api.nvim_buf_set_lines(buf_id, from, to, false, new_lines)
-- Keep track of current hunk lines shift as a result of previous replaces offset = offset + (h.ref_count - h.buf_count) endend
H.yank_hunks_ref = function(ref_text, hunks, register) -- Collect reference lines local ref_lines, out_lines = vim.split(ref_text, '\n'), {} for _, h in ipairs(hunks) do for i = h.ref_start, h.ref_start + h.ref_count - 1 do out_lines[i] = ref_lines[i] end end
-- Construct reference lines in order local hunk_ref_lines = {} for i = 1, #ref_lines do table.insert(hunk_ref_lines, out_lines[i]) end
-- Put lines into target register vim.fn.setreg(register, hunk_ref_lines, 'l')end
H.get_contiguous_hunk_ranges = function(hunks) if #hunks == 0 then return {} end hunks = vim.deepcopy(hunks) table.sort(hunks, H.hunk_order)
local h1_from, h1_to = H.get_hunk_buf_range(hunks[1]) local res = { { from = h1_from, to = h1_to } } for i = 2, #hunks do local h, cur_region = hunks[i], res[#res] local h_from, h_to = H.get_hunk_buf_range(h) if h_from <= cur_region.to + 1 then cur_region.to = math.max(cur_region.to, h_to) else table.insert(res, { from = h_from, to = h_to }) end end return resend
H.iterate_hunk_ranges = function(ranges, direction, opts) local n = #ranges
-- Compute initial index local init_ind if direction == 'first' then init_ind = 0 end if direction == 'prev' then init_ind = H.get_range_id_prev(ranges, opts.line_start) end if direction == 'next' then init_ind = H.get_range_id_next(ranges, opts.line_start) end if direction == 'last' then init_ind = n + 1 end
local is_on_edge = (direction == 'prev' and init_ind == 1) or (direction == 'next' and init_ind == n) if not opts.wrap and is_on_edge then return nil end
-- Compute destination index local is_move_forward = direction == 'first' or direction == 'next' local res_ind = init_ind + opts.n_times * (is_move_forward and 1 or -1) local did_wrap = opts.wrap and (res_ind < 1 or n < res_ind) res_ind = opts.wrap and ((res_ind - 1) % n + 1) or math.min(math.max(res_ind, 1), n)
return res_ind, did_wrapend
H.get_range_id_next = function(ranges, line_start) for i = #ranges, 1, -1 do if ranges[i].from <= line_start then return i end end return 0end
H.get_range_id_prev = function(ranges, line_start) for i = 1, #ranges do if line_start <= ranges[i].to then return i end end return #ranges + 1end
H.hunk_order = function(a, b) -- Ensure buffer order and that "change" hunks are listed earlier "delete" -- ones from the same line (important for `reset_hunks()`) return a.buf_start < b.buf_start or (a.buf_start == b.buf_start and a.type == 'change')end
-- Export ---------------------------------------------------------------------H.export_qf = function(opts) local buffers = opts.scope == 'current' and { vim.api.nvim_get_current_buf() } or vim.tbl_keys(H.cache) buffers = vim.tbl_filter(vim.api.nvim_buf_is_valid, buffers) table.sort(buffers)
local type_text = { add = 'Add', change = 'Change', delete = 'Delete' }
local res = {} for _, buf_id in ipairs(buffers) do local filename = vim.api.nvim_buf_get_name(buf_id) local buf_lines = vim.api.nvim_buf_get_lines(buf_id, 0, -1, false) for _, h in ipairs(H.cache[buf_id].hunks) do local text = type_text[h.type] local entry = { bufnr = buf_id, filename = filename, type = text:sub(1, 1), text = text } entry.lnum, entry.end_lnum = H.get_hunk_buf_range(h) -- Make 'add' and 'change' hunks represent actual buffer regions entry.col, entry.end_col = 1, h.type == 'delete' and 1 or buf_lines[entry.end_lnum]:len() + 1 table.insert(res, entry) end end return resend
-- Git ------------------------------------------------------------------------H.git_start_watching_index = function(buf_id, path) -- NOTE: Watching single 'index' file is not enough as staging by Git is done -- via "create fresh 'index.lock' file, apply modifications, change file name -- to 'index'". Hence watch the whole '.git' (first level) and react only if -- change was in 'index' file. local stdout = vim.uv.new_pipe() local args = { 'rev-parse', '--path-format=absolute', '--git-dir' } local spawn_opts = { args = args, cwd = vim.fn.fnamemodify(path, ':h'), stdio = { nil, stdout, nil } }
-- If path is not in Git, disable buffer but make sure that it will not try -- to re-attach until buffer is properly disabled local on_not_in_git = vim.schedule_wrap(function() if not vim.api.nvim_buf_is_valid(buf_id) then H.cache[buf_id] = nil return end MiniDiff.fail_attach(buf_id) end)
local process, stdout_feed = nil, {} local on_exit = function(exit_code) process:close()
-- Watch index only if there was no error retrieving path to it if exit_code ~= 0 or stdout_feed[1] == nil then return on_not_in_git() end
-- Set up index watching local git_dir_path = table.concat(stdout_feed, ''):gsub('\n+$', '') H.git_setup_index_watch(buf_id, git_dir_path)
-- Set reference text immediately H.git_set_ref_text(buf_id) end
process = vim.uv.spawn('git', spawn_opts, on_exit) H.git_read_stream(stdout, stdout_feed)end
H.git_setup_index_watch = function(buf_id, git_dir_path) local buf_fs_event, timer = vim.uv.new_fs_event(), vim.uv.new_timer() local buf_git_set_ref_text = function() H.git_set_ref_text(buf_id) end
local watch_index = function(_, filename, _) if filename ~= 'index' then return end -- Debounce to not overload during incremental staging (like in script) timer:stop() timer:start(50, 0, buf_git_set_ref_text) end buf_fs_event:start(git_dir_path, { recursive = false }, watch_index)
H.git_invalidate_cache(H.git_cache[buf_id]) H.git_cache[buf_id] = { fs_event = buf_fs_event, timer = timer }end
H.git_set_ref_text = vim.schedule_wrap(function(buf_id) if not vim.api.nvim_buf_is_valid(buf_id) then return end local buf_set_ref_text = vim.schedule_wrap(function(text) pcall(MiniDiff.set_ref_text, buf_id, text) end)
-- NOTE: Do not cache buffer's name to react to its possible rename local path = H.get_buf_realpath(buf_id) if path == '' then return buf_set_ref_text(nil) end local cwd, basename = vim.fn.fnamemodify(path, ':h'), vim.fn.fnamemodify(path, ':t')
-- Set local stdout = vim.uv.new_pipe() local spawn_opts = { args = { 'show', ':0:./' .. basename }, cwd = cwd, stdio = { nil, stdout, nil } }
local process, stdout_feed = nil, {} local on_exit = function(exit_code) process:close()
-- Unset reference text in case of any error. This results into not showing -- hunks at all. Possible reasons to do so: -- - 'Not in index' files (new, ignored, etc.). -- - 'Neither in index nor on disk' files (after checking out commit which -- does not yet have file created). -- - 'Relative can not be used outside working tree' (when opening file -- inside '.git' directory). if exit_code ~= 0 or stdout_feed[1] == nil then return buf_set_ref_text(nil) end
-- Set reference text accounting for possible 'crlf' end of line in index local text = table.concat(stdout_feed, ''):gsub('\r\n', '\n') buf_set_ref_text(text) end
process = vim.uv.spawn('git', spawn_opts, on_exit) H.git_read_stream(stdout, stdout_feed)end)
H.git_get_path_data = function(path) -- Get path data needed for proper patch header local cwd, basename = vim.fn.fnamemodify(path, ':h'), vim.fn.fnamemodify(path, ':t') local stdout = vim.uv.new_pipe() local args = { 'ls-files', '-z', '--full-name', '--format=%(objectmode) %(eolinfo:index) %(path)', '--', basename } local spawn_opts = { args = args, cwd = cwd, stdio = { nil, stdout, nil } }
local process, stdout_feed, res, did_exit = nil, {}, { cwd = cwd }, false local on_exit = function(exit_code) process:close()
did_exit = true if exit_code ~= 0 then return end -- Parse data about path local out = table.concat(stdout_feed, ''):gsub('(%z\n)+$', '') res.mode_bits, res.eol, res.rel_path = string.match(out, '^(%d+) (%S+) (.*)$') end
process = vim.uv.spawn('git', spawn_opts, on_exit) H.git_read_stream(stdout, stdout_feed) vim.wait(1000, function() return did_exit end, 1) return resend
H.git_format_patch = function(buf_id, hunks, path_data) local _, buf_lines = H.get_buftext(buf_id) local ref_lines = vim.split(H.cache[buf_id].ref_text, '\n')
local res = { string.format('diff --git a/%s b/%s', path_data.rel_path, path_data.rel_path), 'index 000000..000000 ' .. path_data.mode_bits, '--- a/' .. path_data.rel_path, '+++ b/' .. path_data.rel_path, }
-- Take into account changing target ref region as a result of previous hunks local offset = 0 local cr_eol = path_data.eol == 'crlf' and '\r' or '' for _, h in ipairs(hunks) do -- "Add" hunks have reference line above target local start = h.ref_start + (h.ref_count == 0 and 1 or 0)
table.insert(res, string.format('@@ -%d,%d +%d,%d @@', start, h.ref_count, start + offset, h.buf_count)) for i = h.ref_start, h.ref_start + h.ref_count - 1 do table.insert(res, '-' .. ref_lines[i] .. cr_eol) end for i = h.buf_start, h.buf_start + h.buf_count - 1 do table.insert(res, '+' .. buf_lines[i] .. cr_eol) end offset = offset + (h.buf_count - h.ref_count) end
return resend
H.git_apply_patch = function(path_data, patch) local stdin = vim.uv.new_pipe() local args = { 'apply', '--whitespace=nowarn', '--cached', '--unidiff-zero', '-' } local spawn_opts = { args = args, cwd = path_data.cwd, stdio = { stdin, nil, nil } } local process process = vim.uv.spawn('git', spawn_opts, function() process:close() end)
-- Write patch, notify that writing is finished (shutdown), and close for _, l in ipairs(patch) do stdin:write(l) stdin:write('\n') end stdin:shutdown(function() stdin:close() end)end
H.git_read_stream = function(stream, feed) local callback = function(err, data) if data ~= nil then return table.insert(feed, data) end if err then feed[1] = nil end stream:close() end stream:read_start(callback)end
H.git_invalidate_cache = function(cache) if cache == nil then return end pcall(vim.uv.fs_event_stop, cache.fs_event) pcall(vim.uv.timer_stop, cache.timer)end
-- Utilities ------------------------------------------------------------------H.error = function(msg) error('(mini.diff) ' .. 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.notify = function(msg, level_name) vim.notify('(mini.diff) ' .. msg, vim.log.levels[level_name]) end
H.buf_ensure_loaded = function(buf_id) if type(buf_id) ~= 'number' or vim.api.nvim_buf_is_loaded(buf_id) then return end local cache_eventignore = vim.o.eventignore vim.o.eventignore = 'BufEnter,BufWinEnter' pcall(vim.fn.bufload, buf_id) vim.o.eventignore = cache_eventignoreend
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.set_extmark = function(...) pcall(vim.api.nvim_buf_set_extmark, ...) end
H.get_extmarks = function(...) local ok, res = pcall(vim.api.nvim_buf_get_extmarks, ...) if not ok then return {} end return resend
H.clear_namespace = function(...) pcall(vim.api.nvim_buf_clear_namespace, ...) end
H.is_buf_text = function(buf_id) local n = vim.api.nvim_buf_call(buf_id, function() return vim.fn.byte2line(1024) end) local lines = vim.api.nvim_buf_get_lines(buf_id, 0, n, false) return table.concat(lines, ''):find('\0') == nilend
H.get_buftext = function(buf_id) local lines = vim.api.nvim_buf_get_lines(buf_id, 0, -1, false) -- - NOTE: Appending '\n' makes more intuitive diffs at end-of-file local text = table.concat(lines, '\n') .. '\n' if not vim.bo[buf_id].bomb then return text, lines end local bytes = H.bom_bytes[vim.bo[buf_id].fileencoding] or '' lines[1] = bytes .. lines[1] return bytes .. text, linesend
-- Try getting buffer's full real path (after resolving symlinks)H.get_buf_realpath = function(buf_id) return vim.uv.fs_realpath(vim.api.nvim_buf_get_name(buf_id)) or '' end
-- nvim__redraw replaced nvim__buf_redraw_range during the 0.10 release cycleH.redraw_buffer = function(buf_id) vim.api.nvim__buf_redraw_range(buf_id, 0, -1)
-- Redraw statusline to have possible statusline component up to date vim.cmd('redrawstatus')endif vim.api.nvim__redraw ~= nil then H.redraw_buffer = function(buf_id) vim.api.nvim__redraw({ buf = buf_id, valid = true, statusline = true }) endend
H.has_extra_cursors = function() local ns_id = vim.api.nvim_get_namespaces()['nvim.multicursor'] if ns_id == nil then return end return #vim.api.nvim_buf_get_extmarks(0, ns_id, 0, -1, { limit = 1 }) > 0end
H.force_mc_cascade = function() -- A hack to force multicursor cascade, as it needs text edit or cursor move -- There might be a dedicated way to do that in the future -- See https://github.com/neovim/neovim/issues/42279 local cur = vim.api.nvim_win_get_cursor(0) local modified = vim.bo.modified vim.api.nvim_buf_set_text(0, cur[1] - 1, cur[2], cur[1] - 1, cur[2], { '' }) vim.bo.modified = modifiedend
return MiniDiff