757 lines
21 KiB
Lua
757 lines
21 KiB
Lua
local repo = require("git.core.repo")
|
|
local util = require("git.core.util")
|
|
|
|
local M = {}
|
|
|
|
local NS_SIGNS = vim.api.nvim_create_namespace("ow.git.hunks")
|
|
local NS_OVERLAY = vim.api.nvim_create_namespace("ow.git.hunks.overlay")
|
|
|
|
---@alias ow.Git.Hunks.HunkType "add"|"change"|"delete"
|
|
|
|
---@class ow.Git.Hunks.Hunk
|
|
---@field old_start integer
|
|
---@field old_count integer
|
|
---@field new_start integer
|
|
---@field new_count integer
|
|
---@field type ow.Git.Hunks.HunkType
|
|
---@field old_lines string[]
|
|
---@field new_lines string[]
|
|
|
|
---@class ow.Git.Hunks.BufState
|
|
---@field repo ow.Git.Repo
|
|
---@field rel string
|
|
---@field index string[]?
|
|
---@field index_sha string?
|
|
---@field index_hl { src: string[], lines: table[][]? }?
|
|
---@field hunks ow.Git.Hunks.Hunk[]
|
|
---@field overlay boolean
|
|
---@field autocmds integer[]
|
|
|
|
---@type table<integer, ow.Git.Hunks.BufState>
|
|
local states = {}
|
|
|
|
---@param buf integer
|
|
---@return ow.Git.Hunks.BufState?
|
|
function M.state(buf)
|
|
return states[buf]
|
|
end
|
|
|
|
---@param buf integer?
|
|
---@return integer
|
|
local function resolve_buf(buf)
|
|
return buf and buf ~= 0 and buf or vim.api.nvim_get_current_buf()
|
|
end
|
|
|
|
---Mirror the hunk-affecting parts of the user's 'diffopt' so the gutter
|
|
---lines up with what `:diffsplit` shows.
|
|
---@return table
|
|
local function diff_opts()
|
|
local opts = { result_type = "indices", algorithm = "myers" }
|
|
for _, item in ipairs(vim.split(vim.o.diffopt, ",", { plain = true })) do
|
|
if item == "indent-heuristic" then
|
|
opts.indent_heuristic = true
|
|
else
|
|
local algorithm = item:match("^algorithm:(.+)$")
|
|
if algorithm then
|
|
opts.algorithm = algorithm
|
|
end
|
|
local linematch = item:match("^linematch:(%d+)$")
|
|
if linematch then
|
|
opts.linematch = tonumber(linematch)
|
|
end
|
|
end
|
|
end
|
|
return opts
|
|
end
|
|
|
|
---@param state ow.Git.Hunks.BufState
|
|
---@param new_lines string[]
|
|
local function compute_hunks(state, new_lines)
|
|
local old = table.concat(state.index or {}, "\n")
|
|
local new = table.concat(new_lines, "\n")
|
|
local raw = vim.text.diff(old, new, diff_opts())
|
|
---@type ow.Git.Hunks.Hunk[]
|
|
local hunks = {}
|
|
if type(raw) ~= "table" then
|
|
state.hunks = hunks
|
|
return
|
|
end
|
|
for _, h in ipairs(raw) do
|
|
local os_ = h[1] --[[@as integer]]
|
|
local oc = h[2] --[[@as integer]]
|
|
local ns_ = h[3] --[[@as integer]]
|
|
local nc = h[4] --[[@as integer]]
|
|
local typ ---@type ow.Git.Hunks.HunkType
|
|
if oc == 0 then
|
|
typ = "add"
|
|
elseif nc == 0 then
|
|
typ = "delete"
|
|
else
|
|
typ = "change"
|
|
end
|
|
local old_lines = {}
|
|
if typ ~= "add" and state.index then
|
|
for i = os_, os_ + oc - 1 do
|
|
table.insert(old_lines, state.index[i] or "")
|
|
end
|
|
end
|
|
local hunk_new = {}
|
|
if typ ~= "delete" then
|
|
for i = ns_, ns_ + nc - 1 do
|
|
table.insert(hunk_new, new_lines[i] or "")
|
|
end
|
|
end
|
|
table.insert(hunks, {
|
|
old_start = os_,
|
|
old_count = oc,
|
|
new_start = ns_,
|
|
new_count = nc,
|
|
type = typ,
|
|
old_lines = old_lines,
|
|
new_lines = hunk_new,
|
|
})
|
|
end
|
|
state.hunks = hunks
|
|
end
|
|
|
|
---@type table<ow.Git.Hunks.HunkType, string>
|
|
local DEFAULT_SIGNS = { add = "┃", change = "┃", delete = "▁" }
|
|
|
|
---@return table<ow.Git.Hunks.HunkType, string>
|
|
local function resolve_signs()
|
|
local cfg = vim.g.git_hunk_signs
|
|
if type(cfg) ~= "table" then
|
|
return DEFAULT_SIGNS
|
|
end
|
|
return vim.tbl_extend("force", DEFAULT_SIGNS, cfg)
|
|
end
|
|
|
|
---@param buf integer
|
|
local function render_signs(buf)
|
|
if not vim.api.nvim_buf_is_valid(buf) then
|
|
return
|
|
end
|
|
vim.api.nvim_buf_clear_namespace(buf, NS_SIGNS, 0, -1)
|
|
local state = states[buf]
|
|
if not state or state.overlay then
|
|
return
|
|
end
|
|
local signs = resolve_signs()
|
|
local line_count = vim.api.nvim_buf_line_count(buf)
|
|
for _, h in ipairs(state.hunks) do
|
|
if h.type == "delete" then
|
|
local row = math.max(h.new_start, 1) - 1
|
|
if row >= line_count then
|
|
row = math.max(line_count - 1, 0)
|
|
end
|
|
pcall(vim.api.nvim_buf_set_extmark, buf, NS_SIGNS, row, 0, {
|
|
sign_text = signs.delete,
|
|
sign_hl_group = "GitHunkRemoved",
|
|
priority = 100,
|
|
})
|
|
else
|
|
local hl = h.type == "add" and "GitHunkAdded" or "GitHunkChanged"
|
|
local sign = h.type == "add" and signs.add or signs.change
|
|
for r = h.new_start, h.new_start + h.new_count - 1 do
|
|
local row = r - 1
|
|
if row >= 0 and row < line_count then
|
|
pcall(
|
|
vim.api.nvim_buf_set_extmark,
|
|
buf,
|
|
NS_SIGNS,
|
|
row,
|
|
0,
|
|
{
|
|
sign_text = sign,
|
|
sign_hl_group = hl,
|
|
priority = 100,
|
|
}
|
|
)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local SKIP_CAPTURES = { spell = true, nospell = true, conceal = true }
|
|
|
|
---@param buf integer
|
|
---@param lines string[]
|
|
---@return table[][]?
|
|
local function highlight_index(buf, lines)
|
|
if not vim.treesitter.highlighter.active[buf] then
|
|
return nil
|
|
end
|
|
local got, parser = pcall(vim.treesitter.get_parser, buf)
|
|
if not got or not parser then
|
|
return nil
|
|
end
|
|
local lang = parser:lang()
|
|
local query = vim.treesitter.query.get(lang, "highlights")
|
|
if not query then
|
|
return nil
|
|
end
|
|
local source = table.concat(lines, "\n")
|
|
local got_root, root = pcall(function()
|
|
local trees = vim.treesitter.get_string_parser(source, lang):parse()
|
|
local tree = trees and trees[1]
|
|
return tree and tree:root()
|
|
end)
|
|
if not got_root or not root then
|
|
return nil
|
|
end
|
|
---@type table<integer, table<integer, string>>
|
|
local groups = {}
|
|
for id, node in query:iter_captures(root, source) do
|
|
local name = query.captures[id]
|
|
if name and name:sub(1, 1) ~= "_" and not SKIP_CAPTURES[name] then
|
|
local sr, sc, er, ec = node:range()
|
|
for row = sr, math.min(er, #lines - 1) do
|
|
local row_groups = groups[row] or {}
|
|
groups[row] = row_groups
|
|
local from = row == sr and sc or 0
|
|
local to = row == er and ec or #(lines[row + 1] or "")
|
|
for col = from, to - 1 do
|
|
row_groups[col] = name
|
|
end
|
|
end
|
|
end
|
|
end
|
|
local out = {}
|
|
for row = 0, #lines - 1 do
|
|
local line = lines[row + 1] or ""
|
|
local row_groups = groups[row] or {}
|
|
local chunks = {}
|
|
local col = 0
|
|
while col < #line do
|
|
local name = row_groups[col]
|
|
local stop = col + 1
|
|
while stop < #line and row_groups[stop] == name do
|
|
stop = stop + 1
|
|
end
|
|
local hl ---@type string|string[]
|
|
if name then
|
|
hl = { "GitHunkDeleteLine", "@" .. name }
|
|
else
|
|
hl = "GitHunkDeleteLine"
|
|
end
|
|
table.insert(chunks, { line:sub(col + 1, stop), hl })
|
|
col = stop
|
|
end
|
|
out[row + 1] = chunks
|
|
end
|
|
return out
|
|
end
|
|
|
|
---@param h ow.Git.Hunks.Hunk
|
|
---@param hl_lines table[][]? per-index-line syntax chunks, or nil
|
|
---@return table[]
|
|
local function delete_virt_lines(h, hl_lines)
|
|
local width = vim.o.columns
|
|
local virt = {}
|
|
for i, line in ipairs(h.old_lines) do
|
|
local pad = math.max(width - vim.api.nvim_strwidth(line), 0)
|
|
local cached = hl_lines and hl_lines[h.old_start + i - 1]
|
|
if cached then
|
|
local chunks = vim.list_extend({}, cached)
|
|
table.insert(chunks, {
|
|
string.rep(" ", pad),
|
|
"GitHunkDeleteLine",
|
|
})
|
|
table.insert(virt, chunks)
|
|
else
|
|
table.insert(virt, {
|
|
{ line .. string.rep(" ", pad), "GitHunkDeleteLine" },
|
|
})
|
|
end
|
|
end
|
|
return virt
|
|
end
|
|
|
|
---@param state ow.Git.Hunks.BufState
|
|
---@param buf integer
|
|
---@return table[][]?
|
|
local function index_spans(state, buf)
|
|
if not state.index then
|
|
return nil
|
|
end
|
|
local cache = state.index_hl
|
|
if cache and cache.src == state.index then
|
|
return cache.lines
|
|
end
|
|
local lines = highlight_index(buf, state.index)
|
|
state.index_hl = { src = state.index, lines = lines }
|
|
return lines
|
|
end
|
|
|
|
---@param buf integer
|
|
local function render_overlay(buf)
|
|
if not vim.api.nvim_buf_is_valid(buf) then
|
|
return
|
|
end
|
|
vim.api.nvim_buf_clear_namespace(buf, NS_OVERLAY, 0, -1)
|
|
local state = states[buf]
|
|
if not state or not state.overlay then
|
|
return
|
|
end
|
|
local line_count = vim.api.nvim_buf_line_count(buf)
|
|
local hl_lines = index_spans(state, buf)
|
|
for _, h in ipairs(state.hunks) do
|
|
if h.type ~= "delete" then
|
|
for r = h.new_start, h.new_start + h.new_count - 1 do
|
|
local row = r - 1
|
|
if row >= 0 and row < line_count then
|
|
pcall(
|
|
vim.api.nvim_buf_set_extmark,
|
|
buf,
|
|
NS_OVERLAY,
|
|
row,
|
|
0,
|
|
{
|
|
line_hl_group = "GitHunkAddLine",
|
|
priority = 100,
|
|
}
|
|
)
|
|
end
|
|
end
|
|
end
|
|
if h.type ~= "add" then
|
|
local row, above
|
|
if h.type == "delete" then
|
|
if h.new_start <= 0 then
|
|
row, above = 0, true
|
|
elseif h.new_start >= line_count then
|
|
row, above = math.max(line_count - 1, 0), false
|
|
else
|
|
row, above = h.new_start, true
|
|
end
|
|
else
|
|
row, above = math.max(h.new_start - 1, 0), true
|
|
end
|
|
pcall(vim.api.nvim_buf_set_extmark, buf, NS_OVERLAY, row, 0, {
|
|
virt_lines = delete_virt_lines(h, hl_lines),
|
|
virt_lines_above = above,
|
|
right_gravity = false,
|
|
invalidate = true,
|
|
})
|
|
end
|
|
end
|
|
end
|
|
|
|
---@param buf integer
|
|
local function render(buf)
|
|
render_signs(buf)
|
|
render_overlay(buf)
|
|
end
|
|
|
|
---@param state ow.Git.Hunks.BufState
|
|
---@param buf integer
|
|
---@param new_sha string
|
|
local function load_index_and_render(state, buf, new_sha)
|
|
util.git({ "cat-file", "-p", ":0:" .. state.rel }, {
|
|
cwd = state.repo.worktree,
|
|
silent = true,
|
|
on_exit = function(res)
|
|
if states[buf] ~= state or not vim.api.nvim_buf_is_valid(buf) then
|
|
return
|
|
end
|
|
if res.code ~= 0 then
|
|
state.index = {}
|
|
state.index_sha = nil
|
|
state.hunks = {}
|
|
render(buf)
|
|
return
|
|
end
|
|
state.index = util.split_lines(res.stdout or "")
|
|
state.index_sha = new_sha
|
|
local new_lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
|
|
compute_hunks(state, new_lines)
|
|
render(buf)
|
|
end,
|
|
})
|
|
end
|
|
|
|
---@param buf integer
|
|
local function recompute(buf)
|
|
if not vim.api.nvim_buf_is_valid(buf) then
|
|
return
|
|
end
|
|
local state = states[buf]
|
|
if not state then
|
|
return
|
|
end
|
|
local new_sha = state.repo:index_sha(state.rel)
|
|
if not new_sha then
|
|
state.index = nil
|
|
state.index_sha = nil
|
|
state.hunks = {}
|
|
render(buf)
|
|
return
|
|
end
|
|
if new_sha == state.index_sha and state.index then
|
|
local new_lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
|
|
compute_hunks(state, new_lines)
|
|
render(buf)
|
|
return
|
|
end
|
|
load_index_and_render(state, buf, new_sha)
|
|
end
|
|
|
|
local schedule, sched_handle = util.keyed_debounce(recompute, 100)
|
|
|
|
---@param buf integer
|
|
function M._flush(buf)
|
|
sched_handle.flush(buf)
|
|
end
|
|
|
|
---@param buf integer
|
|
function M.attach(buf)
|
|
if states[buf] then
|
|
return
|
|
end
|
|
if not repo.is_worktree_buf(buf) then
|
|
return
|
|
end
|
|
local r = repo.find(buf)
|
|
if not r then
|
|
return
|
|
end
|
|
local rel = vim.fs.relpath(r.worktree, vim.fn.resolve(vim.api.nvim_buf_get_name(buf)))
|
|
if not rel then
|
|
return
|
|
end
|
|
---@type ow.Git.Hunks.BufState
|
|
local state = {
|
|
repo = r,
|
|
rel = rel,
|
|
index = nil,
|
|
index_sha = nil,
|
|
hunks = {},
|
|
overlay = vim.g.git_hunk_overlay_default == true,
|
|
autocmds = {},
|
|
}
|
|
states[buf] = state
|
|
|
|
local group =
|
|
vim.api.nvim_create_augroup("ow.git.hunks." .. buf, { clear = true })
|
|
table.insert(
|
|
state.autocmds,
|
|
vim.api.nvim_create_autocmd({ "TextChanged", "TextChangedI" }, {
|
|
group = group,
|
|
buffer = buf,
|
|
callback = function()
|
|
schedule(buf)
|
|
end,
|
|
})
|
|
)
|
|
table.insert(
|
|
state.autocmds,
|
|
vim.api.nvim_create_autocmd("BufWritePost", {
|
|
group = group,
|
|
buffer = buf,
|
|
callback = function()
|
|
schedule(buf)
|
|
end,
|
|
})
|
|
)
|
|
|
|
schedule(buf)
|
|
end
|
|
|
|
---@param buf integer
|
|
function M.detach(buf)
|
|
local state = states[buf]
|
|
if not state then
|
|
return
|
|
end
|
|
if vim.api.nvim_buf_is_valid(buf) then
|
|
vim.api.nvim_buf_clear_namespace(buf, NS_SIGNS, 0, -1)
|
|
vim.api.nvim_buf_clear_namespace(buf, NS_OVERLAY, 0, -1)
|
|
end
|
|
for _, id in ipairs(state.autocmds) do
|
|
pcall(vim.api.nvim_del_autocmd, id)
|
|
end
|
|
pcall(vim.api.nvim_del_augroup_by_name, "ow.git.hunks." .. buf)
|
|
sched_handle.cancel(buf)
|
|
states[buf] = nil
|
|
end
|
|
|
|
---@param buf integer?
|
|
function M.toggle_overlay(buf)
|
|
buf = resolve_buf(buf)
|
|
local state = states[buf]
|
|
if not state then
|
|
util.warning("git hunks: buffer not attached")
|
|
return
|
|
end
|
|
state.overlay = not state.overlay
|
|
render(buf)
|
|
end
|
|
|
|
---@param buf? integer
|
|
---@param row integer 1-indexed cursor line
|
|
---@return ow.Git.Hunks.Hunk?
|
|
local function hunk_at(buf, row)
|
|
buf = buf or vim.api.nvim_get_current_buf()
|
|
local state = states[buf]
|
|
if not state then
|
|
return nil
|
|
end
|
|
for _, h in ipairs(state.hunks) do
|
|
if h.type == "delete" then
|
|
local anchor = math.max(h.new_start, 1)
|
|
if anchor == row then
|
|
return h
|
|
end
|
|
else
|
|
local lo = h.new_start
|
|
local hi = h.new_start + h.new_count - 1
|
|
if row >= lo and row <= hi then
|
|
return h
|
|
end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
---@param buf integer?
|
|
---@return integer buf
|
|
---@return ow.Git.Hunks.BufState? state
|
|
---@return ow.Git.Hunks.Hunk? hunk
|
|
local function cursor_hunk(buf)
|
|
buf = resolve_buf(buf)
|
|
local state = states[buf]
|
|
if not state then
|
|
return buf, nil, nil
|
|
end
|
|
return buf, state, hunk_at(buf, vim.api.nvim_win_get_cursor(0)[1])
|
|
end
|
|
|
|
---@param h ow.Git.Hunks.Hunk
|
|
---@return integer
|
|
local function anchor_line(h)
|
|
if h.type == "delete" then
|
|
return math.max(h.new_start, 1)
|
|
end
|
|
return h.new_start
|
|
end
|
|
|
|
---@param direction "next"|"prev"
|
|
function M.nav(direction)
|
|
local buf = vim.api.nvim_get_current_buf()
|
|
local state = states[buf]
|
|
if not state or #state.hunks == 0 then
|
|
return
|
|
end
|
|
local cur = vim.api.nvim_win_get_cursor(0)[1]
|
|
local hunks = state.hunks
|
|
local target = direction == "next" and hunks[1] or hunks[#hunks]
|
|
if direction == "next" then
|
|
for _, h in ipairs(hunks) do
|
|
if anchor_line(h) > cur then
|
|
target = h
|
|
break
|
|
end
|
|
end
|
|
else
|
|
for i = #hunks, 1, -1 do
|
|
if anchor_line(hunks[i]) < cur then
|
|
target = hunks[i]
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if not target then
|
|
return
|
|
end
|
|
vim.api.nvim_win_set_cursor(0, { anchor_line(target), 0 })
|
|
end
|
|
|
|
---@param h ow.Git.Hunks.Hunk
|
|
---@return string[]
|
|
local function hunk_body(h)
|
|
local lines = {
|
|
string.format(
|
|
"@@ -%d,%d +%d,%d @@",
|
|
h.old_start,
|
|
h.old_count,
|
|
h.new_start,
|
|
h.new_count
|
|
),
|
|
}
|
|
for _, l in ipairs(h.old_lines) do
|
|
table.insert(lines, "-" .. l)
|
|
end
|
|
for _, l in ipairs(h.new_lines) do
|
|
table.insert(lines, "+" .. l)
|
|
end
|
|
return lines
|
|
end
|
|
|
|
---@param h ow.Git.Hunks.Hunk
|
|
---@param state ow.Git.Hunks.BufState
|
|
---@return string
|
|
local function build_patch(h, state)
|
|
local lines = { "--- a/" .. state.rel, "+++ b/" .. state.rel }
|
|
vim.list_extend(lines, hunk_body(h))
|
|
return table.concat(lines, "\n") .. "\n"
|
|
end
|
|
|
|
---@param buf? integer
|
|
function M.stage_hunk(buf)
|
|
local _, state, h = cursor_hunk(buf)
|
|
if not state then
|
|
return
|
|
end
|
|
if not h then
|
|
util.warning("git hunks: no hunk at cursor")
|
|
return
|
|
end
|
|
util.git({ "apply", "--cached", "--unidiff-zero", "-" }, {
|
|
cwd = state.repo.worktree,
|
|
stdin = build_patch(h, state),
|
|
on_exit = function(res)
|
|
if res.code ~= 0 then
|
|
util.error(
|
|
"git apply failed: %s",
|
|
vim.trim(res.stderr or "")
|
|
)
|
|
end
|
|
end,
|
|
})
|
|
end
|
|
|
|
---@param buf? integer
|
|
function M.reset_hunk(buf)
|
|
local target, state, h = cursor_hunk(buf)
|
|
if not state then
|
|
return
|
|
end
|
|
if not h then
|
|
util.warning("git hunks: no hunk at cursor")
|
|
return
|
|
end
|
|
if h.type == "add" then
|
|
vim.api.nvim_buf_set_lines(
|
|
target,
|
|
h.new_start - 1,
|
|
h.new_start - 1 + h.new_count,
|
|
false,
|
|
{}
|
|
)
|
|
elseif h.type == "delete" then
|
|
vim.api.nvim_buf_set_lines(
|
|
target,
|
|
h.new_start,
|
|
h.new_start,
|
|
false,
|
|
h.old_lines
|
|
)
|
|
else
|
|
vim.api.nvim_buf_set_lines(
|
|
target,
|
|
h.new_start - 1,
|
|
h.new_start - 1 + h.new_count,
|
|
false,
|
|
h.old_lines
|
|
)
|
|
end
|
|
end
|
|
|
|
---@param buf? integer
|
|
function M.select_hunk(buf)
|
|
local _, _, h = cursor_hunk(buf)
|
|
if not h or h.type == "delete" then
|
|
return
|
|
end
|
|
local first = h.new_start
|
|
local last = h.new_start + math.max(h.new_count, 1) - 1
|
|
vim.api.nvim_win_set_cursor(0, { first, 0 })
|
|
vim.cmd("normal! V")
|
|
vim.api.nvim_win_set_cursor(0, { last, 0 })
|
|
end
|
|
|
|
local preview_win ---@type integer?
|
|
|
|
---@param buf? integer
|
|
function M.preview_hunk(buf)
|
|
if preview_win and vim.api.nvim_win_is_valid(preview_win) then
|
|
vim.api.nvim_set_current_win(preview_win)
|
|
return
|
|
end
|
|
local target, state, h = cursor_hunk(buf)
|
|
if not state then
|
|
return
|
|
end
|
|
if not h then
|
|
return
|
|
end
|
|
local lines = hunk_body(h)
|
|
local pbuf = vim.api.nvim_create_buf(false, true)
|
|
vim.api.nvim_buf_set_lines(pbuf, 0, -1, false, lines)
|
|
vim.bo[pbuf].filetype = "diff"
|
|
vim.bo[pbuf].bufhidden = "wipe"
|
|
local width = 0
|
|
for _, l in ipairs(lines) do
|
|
if #l > width then
|
|
width = #l
|
|
end
|
|
end
|
|
width = math.min(math.max(width + 2, 40), vim.o.columns - 4)
|
|
local height = math.min(#lines, math.floor(vim.o.lines / 2))
|
|
local win = vim.api.nvim_open_win(pbuf, false, {
|
|
relative = "cursor",
|
|
row = 1,
|
|
col = 0,
|
|
width = width,
|
|
height = height,
|
|
style = "minimal",
|
|
})
|
|
preview_win = win
|
|
|
|
local function close()
|
|
if vim.api.nvim_win_is_valid(win) then
|
|
vim.api.nvim_win_close(win, true)
|
|
end
|
|
end
|
|
local group =
|
|
vim.api.nvim_create_augroup("ow.git.hunks.preview", { clear = true })
|
|
vim.api.nvim_create_autocmd(
|
|
{ "CursorMoved", "CursorMovedI", "InsertEnter" },
|
|
{ group = group, buffer = target, callback = close }
|
|
)
|
|
vim.api.nvim_create_autocmd("WinLeave", {
|
|
group = group,
|
|
buffer = pbuf,
|
|
callback = close,
|
|
})
|
|
vim.api.nvim_create_autocmd("WinClosed", {
|
|
group = group,
|
|
pattern = tostring(win),
|
|
callback = function()
|
|
preview_win = nil
|
|
pcall(vim.api.nvim_del_augroup_by_name, "ow.git.hunks.preview")
|
|
end,
|
|
})
|
|
vim.keymap.set("n", "q", close, { buffer = pbuf, nowait = true })
|
|
end
|
|
|
|
repo.on("change", function(r, change)
|
|
for buf, state in pairs(states) do
|
|
if
|
|
state.repo == r
|
|
and (change.paths[state.rel] or change.branch_changed)
|
|
then
|
|
schedule(buf)
|
|
end
|
|
end
|
|
end)
|
|
|
|
for _, buf in ipairs(vim.api.nvim_list_bufs()) do
|
|
if vim.api.nvim_buf_is_loaded(buf) then
|
|
M.attach(buf)
|
|
end
|
|
end
|
|
|
|
return M
|