lazy.nvim/lua/lazy/core/handler.lua

176 lines
5.0 KiB
Lua

local Util = require("lazy.core.util")
local Loader = require("lazy.core.loader")
local Config = require("lazy.core.config")
---@class LazyPluginHandlers
---@field event? string|string[]
---@field cmd? string|string[]
---@field ft? string|string[]
---@field keys? string|string[]
local M = {}
---@alias LazyHandler fun(grouped:table<string, string[]>)
function M.setup()
for key, handler in pairs(M.handlers) do
---@type table<string, string[]>
local group = {}
for _, plugin in pairs(Config.plugins) do
if plugin[key] then
---@diagnostic disable-next-line: no-unknown
for _, value in pairs(type(plugin[key]) == "table" and plugin[key] or { plugin[key] }) do
group[value] = group[value] or {}
table.insert(group[value], plugin.name)
end
end
end
handler(group)
end
end
---@param events string|string[]
---@param pattern? string
function M.get_augroups(events, pattern)
-- Check for all autocmd groups listening for the events
---@type table<string,true>
local groups = {}
for _, autocmd in ipairs(vim.api.nvim_get_autocmds({ event = events, pattern = pattern })) do
if autocmd.group then
groups[autocmd.group] = true
end
end
return groups
end
---@param groups table<string,true>
---@param events string|string[]
---@param pattern? string
function M.trigger(groups, events, pattern)
events = type(events) == "string" and { events } or events
---@cast events string[]
for _, event in ipairs(events) do
for _, autocmd in ipairs(vim.api.nvim_get_autocmds({ event = event, pattern = pattern })) do
if autocmd.event == event and autocmd.group and not groups[autocmd.group] then
if Config.options.debug then
local lines = {
"# Firing Events",
" - **event:** " .. autocmd.event,
" - **group:** `" .. autocmd.group_name .. "`",
}
if pattern then
table.insert(lines, 2, "- **pattern:** " .. pattern)
end
Util.info(lines)
end
Util.try(function()
vim.api.nvim_exec_autocmds(autocmd.event, { group = autocmd.group, modeline = false })
end)
end
end
end
end
---@type table<string, LazyHandler>
M.handlers = {}
function M.handlers.event(grouped)
local group = vim.api.nvim_create_augroup("lazy_handler_event", { clear = true })
for event_spec, plugins in pairs(grouped) do
if event_spec == "VeryLazy" then
event_spec = "User VeryLazy"
end
if event_spec == "VimEnter" and vim.v.vim_did_enter == 1 then
Loader.load(plugins, { event = event_spec })
else
local event, pattern = event_spec:match("^(%w+)%s+(.*)$")
event = event or event_spec
vim.api.nvim_create_autocmd(event, {
group = group,
once = true,
pattern = pattern,
callback = function()
Util.track({ event = event_spec })
local events = { event }
if event == "BufRead" then
events = { "BufReadPre", "BufRead" }
elseif event == "BufReadPost" then
events = { "BufReadPre", "BufRead", "BufReadPost" }
end
local groups = M.get_augroups(events, pattern)
-- load the plugins
Loader.load(plugins, { event = event_spec })
-- check if any plugin created an event handler for this event and fire the group
M.trigger(groups, events, pattern)
Util.track()
end,
})
end
end
end
function M.handlers.keys(grouped)
for keys, plugins in pairs(grouped) do
vim.keymap.set("n", keys, function()
vim.keymap.del("n", keys)
Util.track({ keys = keys })
Loader.load(plugins, { keys = keys })
vim.api.nvim_input(keys)
Util.track()
end)
end
end
function M.handlers.ft(grouped)
local group = vim.api.nvim_create_augroup("lazy_handler_ft", { clear = true })
for ft, plugins in pairs(grouped) do
vim.api.nvim_create_autocmd("FileType", {
once = true,
pattern = ft,
group = group,
callback = function()
Util.track({ ft = ft })
local groups = M.get_augroups("FileType", ft)
Loader.load(plugins, { ft = ft })
M.trigger(groups, "FileType", ft)
Util.track()
end,
})
end
end
function M.handlers.cmd(grouped)
for cmd, plugins in pairs(grouped) do
local function _load()
vim.api.nvim_del_user_command(cmd)
Util.track({ cmd = cmd })
Loader.load(plugins, { cmd = cmd })
Util.track()
end
vim.api.nvim_create_user_command(cmd, function(event)
_load()
vim.cmd(
("%s %s%s%s %s"):format(
event.mods or "",
event.line1 == event.line2 and "" or event.line1 .. "," .. event.line2,
cmd,
event.bang and "!" or "",
event.args or ""
)
)
end, {
bang = true,
nargs = "*",
complete = function()
_load()
-- HACK: trick Neovim to show the newly loaded command completion
vim.api.nvim_input("<space><bs><tab>")
end,
})
end
end
return M