--- *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: --- --- - `(number)` - start of hunk buffer lines. First line is 1. --- Can be 0 if first reference lines are deleted. --- --- - `(number)` - number of consecutive buffer lines. Can be 0 in --- case reference lines are deleted. --- --- - `(number)` - start of hunk reference lines. First line is 1. --- Can be 0 if lines are added before first reference line. --- --- - `(number)` - number of consecutive reference lines. Can be 0 in --- case buffer lines are added. --- --- - `(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) -- TODO: Remove after Neovim=0.9 support is dropped if vim.fn.has('nvim-0.10') == 0 then vim.notify( '(mini.diff) 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.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: --- --- - `(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. --- --- - `(string|nil)` - source name. String `"unknown"` is used if not supplied. --- --- - `(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. --- --- - `(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_id MiniDiff.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) end end --- Disable diff processing in buffer --- ---@param buf_id __diff_buf_id MiniDiff.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_id MiniDiff.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_id MiniDiff.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: --- - `(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: --- - `(table)` - config used for this particular buffer. --- - `(table)` - array of hunks. See |MiniDiff-hunk-specification|. --- - `(boolean)` - whether an overlay view is shown. --- - `(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). --- - `(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 New reference text. Either a string with `\n` used to --- separate lines or array of lines. Use empty table to unset current --- reference text (results into no hunks shown). Default: `{}`. --- Note: newline character is appended at the end (if it is not there already) --- for better diffs. MiniDiff.set_ref_text = function(buf_id, text) buf_id = H.validate_buf_id(buf_id) if not (type(text) == 'table' or type(text) == 'string') then H.error('`text` should be either string or array.') end if type(text) == 'table' then text = #text > 0 and table.concat(text, '\n') 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 text ~= nil and string.sub(text, -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: --- - `(number)` - start line of the region. Default: 1. --- - `(number)` - start line of the region. Default: last buffer line. --- - `(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 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) end end --- 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: --- - `(number)` - Number of times to advance. Default: |v:count1|. --- - `(number)` - Line number to start from for directions --- "prev" and "next". Default: cursor line. --- - `(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) end end -- Helper data ================================================================ -- Module default config H.default_config = MiniDiff.config H.default_source = { MiniDiff.gen_source.git() } -- Timers H.timer_diff_update = vim.loop.new_timer() -- Namespaces per highlighter name H.ns_id = { viz = vim.api.nvim_create_namespace('MiniDiffViz'), overlay = vim.api.nvim_create_namespace('MiniDiffOverlay'), } -- Cache of buffers waiting for debounced diff update H.bufs_to_update = {} -- Cache per enabled buffer H.cache = {} -- Cache per buffer for attached `git` source H.git_cache = {} -- Cache for operator H.operator_cache = {} -- Common extmark data for supported styles --stylua: ignore H.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 line H.overlay_suffix = string.rep(' ', vim.o.columns) -- Flag for whether to invalidate extmarks H.extmark_invalidate = vim.fn.has('nvim-0.10') == 1 and true or nil -- Flag for whether to handle virtual lines overflow H.extmark_virt_lines_overflow = vim.fn.has('nvim-0.11') == 1 and 'scroll' or nil -- Permanent `vim.diff()` options H.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: ignore H.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: ignore H.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 config end 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, 'lua MiniDiff.textobject()', { desc = 'Hunk range textobject' }) --stylua: ignore start H.map({ 'n', 'x' }, mappings.goto_first, "lua MiniDiff.goto_hunk('first')", { desc = 'First hunk' }) H.map('o', mappings.goto_first, "Vlua MiniDiff.goto_hunk('first')", { desc = 'First hunk' }) H.map({ 'n', 'x' }, mappings.goto_prev, "lua MiniDiff.goto_hunk('prev')", { desc = 'Previous hunk' }) H.map('o', mappings.goto_prev, "Vlua MiniDiff.goto_hunk('prev')", { desc = 'Previous hunk' }) H.map({ 'n', 'x' }, mappings.goto_next, "lua MiniDiff.goto_hunk('next')", { desc = 'Next hunk' }) H.map('o', mappings.goto_next, "Vlua MiniDiff.goto_hunk('next')", { desc = 'Next hunk' }) H.map({ 'n', 'x' }, mappings.goto_last, "lua MiniDiff.goto_hunk('last')", { desc = 'Last hunk' }) H.map('o', mappings.goto_last, "Vlua MiniDiff.goto_hunk('last')", { 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: ignore H.create_default_hl = function() local hi = function(name, opts) opts.default = true vim.api.nvim_set_hl(0, name, opts) end local has_core_diff_hl = vim.fn.has('nvim-0.10') == 1 hi('MiniDiffSignAdd', { link = has_core_diff_hl and 'Added' or 'diffAdded' }) hi('MiniDiffSignChange', { link = has_core_diff_hl and 'Changed' or 'diffChanged' }) hi('MiniDiffSignDelete', { link = has_core_diff_hl and 'Removed' or 'diffRemoved' }) 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 == true end 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 = 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 end end -- 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 x end 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_end end 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 {} new_cache.overlay = false new_cache.overlay_lines = new_cache.overlay_lines or {} H.cache[buf_id] = new_cache end 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 res end 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 = H.extmark_invalidate }, change = { [field] = hl_group_prefix .. 'Change', sign_text = signs.change, priority = view.priority, invalidate = H.extmark_invalidate }, delete = { [field] = hl_group_prefix .. 'Delete', sign_text = signs.delete, priority = view.priority, invalidate = H.extmark_invalidate }, } 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 (`update` -- 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).name end 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] = t end H.append_overlay_add = function(overlay_lines, hunk, priority) local data = { type = 'add', to = hunk.buf_start + hunk.buf_count - 1, priority = priority } H.append_overlay(overlay_lines, hunk.buf_start, data) end 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 local l = { { ref_lines[i] .. H.overlay_suffix, 'MiniDiffOverChange' } } table.insert(changed_lines, l) end local to = hunk.buf_start + hunk.buf_count - 1 local data = { type = 'change', to = to, lines = changed_lines, show_above = true, priority = priority } H.append_overlay(overlay_lines, hunk.buf_start, data) end 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 = data.to, 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_ranges end H.str_utfindex = function(s, i) return vim.str_utfindex(s, 'utf-32', i) end if 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, ends end -- 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, from end 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 res end 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) end end 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 res end 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_wrap end 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 0 end 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 + 1 end 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 res end -- 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.loop.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.loop.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.loop.new_fs_event(), vim.loop.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({}) end local cwd, basename = vim.fn.fnamemodify(path, ':h'), vim.fn.fnamemodify(path, ':t') -- Set local stdout = vim.loop.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({}) 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.loop.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.loop.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.loop.spawn('git', spawn_opts, on_exit) H.git_read_stream(stdout, stdout_feed) vim.wait(1000, function() return did_exit end, 1) return res end 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 res end H.git_apply_patch = function(path_data, patch) local stdin = vim.loop.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.loop.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.loop.fs_event_stop, cache.fs_event) pcall(vim.loop.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_eventignore end H.map = function(mode, lhs, rhs, opts) if lhs == '' then return end opts = vim.tbl_deep_extend('force', { silent = true }, opts or {}) vim.keymap.set(mode, lhs, rhs, opts) end H.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 res end 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') == nil end 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, lines end -- Try getting buffer's full real path (after resolving symlinks) H.get_buf_realpath = function(buf_id) return vim.loop.fs_realpath(vim.api.nvim_buf_get_name(buf_id)) or '' end -- nvim__redraw replaced nvim__buf_redraw_range during the 0.10 release cycle H.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') end if vim.api.nvim__redraw ~= nil then H.redraw_buffer = function(buf_id) vim.api.nvim__redraw({ buf = buf_id, valid = true, statusline = true }) end end return MiniDiff