lazy.nvim/lua/lazy/core/util.lua

516 lines
12 KiB
Lua
Raw Normal View History

---@class LazyUtilCore
2022-11-21 05:33:47 +08:00
local M = {}
2022-11-29 19:02:25 +08:00
---@alias LazyProfile {data: string|{[string]:string}, time: number, [number]:LazyProfile}
2022-11-21 05:33:47 +08:00
---@type LazyProfile[]
M._profiles = { { name = "lazy" } }
M.is_win = jit.os:find("Windows")
2022-11-21 05:33:47 +08:00
2022-11-29 19:02:25 +08:00
---@param data (string|{[string]:string})?
2022-11-21 05:33:47 +08:00
---@param time number?
2022-11-29 19:02:25 +08:00
function M.track(data, time)
if data then
2022-11-21 05:34:55 +08:00
local entry = {
2022-11-29 19:02:25 +08:00
data = data,
time = time or vim.uv.hrtime(),
2022-11-21 05:34:55 +08:00
}
table.insert(M._profiles[#M._profiles], entry)
if not time then
table.insert(M._profiles, entry)
end
2022-11-23 23:10:16 +08:00
return entry
2022-11-21 05:34:55 +08:00
else
2022-11-25 05:03:00 +08:00
---@type LazyProfile
2022-11-21 05:34:55 +08:00
local entry = table.remove(M._profiles)
entry.time = vim.uv.hrtime() - entry.time
2022-11-23 23:10:16 +08:00
return entry
2022-11-21 05:34:55 +08:00
end
2022-11-21 05:33:47 +08:00
end
2024-06-30 19:35:11 +08:00
function M.exiting()
return vim.v.exiting ~= vim.NIL
end
---@generic T
---@param list T[]
---@param fn fun(v: T):boolean?
---@return T[]
function M.filter(fn, list)
local ret = {}
for _, v in ipairs(list) do
if fn(v) then
table.insert(ret, v)
end
end
return ret
end
---@generic F: fun()
---@param data (string|{[string]:string})?
---@param fn F
---@return F
function M.trackfn(data, fn)
return function(...)
M.track(data)
local ok, ret = pcall(fn, ...)
M.track()
if not ok then
error(ret)
end
return ret
end
end
---@param name string
2022-12-23 17:18:19 +08:00
---@return string
function M.normname(name)
2022-12-23 17:18:19 +08:00
local ret = name:lower():gsub("^n?vim%-", ""):gsub("%.n?vim$", ""):gsub("%.lua", ""):gsub("[^a-z]+", "")
return ret
end
2022-12-23 17:18:19 +08:00
---@return string
function M.norm(path)
if path:sub(1, 1) == "~" then
local home = vim.uv.os_homedir()
2022-12-20 15:47:01 +08:00
if home:sub(-1) == "\\" or home:sub(-1) == "/" then
home = home:sub(1, -2)
end
path = home .. path:sub(2)
end
path = path:gsub("\\", "/"):gsub("/+", "/")
2022-12-21 17:17:10 +08:00
return path:sub(-1) == "/" and path:sub(1, -2) or path
end
---@param opts? {level?: number}
function M.pretty_trace(opts)
opts = opts or {}
local Config = require("lazy.core.config")
local trace = {}
local level = opts.level or 2
while true do
local info = debug.getinfo(level, "Sln")
if not info then
break
end
2023-10-22 20:24:27 +08:00
if info.what ~= "C" and (Config.options.debug or not info.source:find("lazy.nvim")) then
local source = info.source:sub(2)
if source:find(Config.options.root, 1, true) == 1 then
source = source:sub(#Config.options.root + 1)
end
source = vim.fn.fnamemodify(source, ":p:~:.") --[[@as string]]
local line = " - " .. source .. ":" .. info.currentline
if info.name then
line = line .. " _in_ **" .. info.name .. "**"
end
table.insert(trace, line)
end
level = level + 1
end
return #trace > 0 and ("\n\n# stacktrace:\n" .. table.concat(trace, "\n")) or ""
end
2024-06-18 06:36:11 +08:00
---@generic R
2024-06-23 04:18:26 +08:00
---@param fn fun():R?
---@param opts? string|{msg:string, on_error:fun(msg)}
2024-06-18 06:36:11 +08:00
---@return R
function M.try(fn, opts)
opts = type(opts) == "string" and { msg = opts } or opts or {}
local msg = opts.msg
-- error handler
local error_handler = function(err)
msg = (msg and (msg .. "\n\n") or "") .. err .. M.pretty_trace()
if opts.on_error then
opts.on_error(msg)
else
vim.schedule(function()
M.error(msg)
end)
end
return err
end
---@type boolean, any
local ok, result = xpcall(fn, error_handler)
return ok and result or nil
end
function M.get_source()
local f = 2
while true do
local info = debug.getinfo(f, "S")
if not info then
break
end
if info.what ~= "C" and not info.source:find("lazy.nvim", 1, true) and info.source ~= "@vim/loader.lua" then
return info.source:sub(2)
end
f = f + 1
end
end
-- Fast implementation to check if a table is a list
---@param t table
function M.is_list(t)
local i = 0
---@diagnostic disable-next-line: no-unknown
for _ in pairs(t) do
i = i + 1
if t[i] == nil then
return false
end
end
return true
end
2022-11-21 05:33:47 +08:00
function M.very_lazy()
2022-11-21 05:34:55 +08:00
local function _load()
vim.schedule(function()
if vim.v.exiting ~= vim.NIL then
return
end
vim.g.did_very_lazy = true
M.track({ event = "VeryLazy" })
vim.api.nvim_exec_autocmds("User", { pattern = "VeryLazy", modeline = false })
M.track()
end)
2022-11-21 05:34:55 +08:00
end
vim.api.nvim_create_autocmd("User", {
pattern = "LazyDone",
once = true,
callback = function()
if vim.v.vim_did_enter == 1 then
_load()
else
vim.api.nvim_create_autocmd("UIEnter", {
2022-11-21 05:34:55 +08:00
once = true,
callback = function()
_load()
end,
})
end
end,
})
2022-11-21 05:33:47 +08:00
end
2022-11-25 05:03:00 +08:00
---@alias FileType "file"|"directory"|"link"
---@param path string
---@param fn fun(path: string, name:string, type:FileType):boolean?
2022-11-25 05:03:00 +08:00
function M.ls(path, fn)
local handle = vim.uv.fs_scandir(path)
2022-11-25 05:03:00 +08:00
while handle do
local name, t = vim.uv.fs_scandir_next(handle)
2022-11-25 05:03:00 +08:00
if not name then
break
2022-11-21 05:34:55 +08:00
end
local fname = path .. "/" .. name
-- HACK: type is not always returned due to a bug in luv,
-- so fecth it with fs_stat instead when needed.
-- see https://github.com/folke/lazy.nvim/issues/306
if fn(fname, name, t or vim.uv.fs_stat(fname).type) == false then
break
end
2022-11-21 05:34:55 +08:00
end
2022-11-21 05:33:47 +08:00
end
2022-11-25 05:03:00 +08:00
---@param path string
---@param fn fun(path: string, name:string, type:FileType)
function M.walk(path, fn)
M.ls(path, function(child, name, type)
if type == "directory" then
M.walk(child, fn)
2022-11-21 05:34:55 +08:00
end
2022-11-25 05:03:00 +08:00
fn(child, name, type)
end)
2022-11-21 05:33:47 +08:00
end
---@param root string
---@param fn fun(modname:string, modpath:string)
---@param modname? string
function M.walkmods(root, fn, modname)
modname = modname and (modname:gsub("%.$", "") .. ".") or ""
M.ls(root, function(path, name, type)
if name == "init.lua" then
fn(modname:gsub("%.$", ""), path)
elseif (type == "file" or type == "link") and name:sub(-4) == ".lua" then
fn(modname .. name:sub(1, -5), path)
elseif type == "directory" then
M.walkmods(path, fn, modname .. name .. ".")
end
end)
end
---@param modname string
---@return string
function M.topmod(modname)
return modname:match("^[^./]+") or modname
end
---@type table<string, string[]>
M.unloaded_cache = {}
---@param modname string
---@param opts? {cache?:boolean}
function M.get_unloaded_rtp(modname, opts)
opts = opts or {}
local topmod = M.topmod(modname)
if opts.cache and M.unloaded_cache[topmod] then
return M.unloaded_cache[topmod], true
end
local norm = M.normname(topmod)
---@type string[]
local rtp = {}
local Config = require("lazy.core.config")
if Config.spec then
for _, plugin in pairs(Config.spec.plugins) do
if not (plugin._.loaded or plugin.module == false) then
if norm == M.normname(plugin.name) then
table.insert(rtp, 1, plugin.dir)
else
table.insert(rtp, plugin.dir)
end
end
end
end
M.unloaded_cache[topmod] = rtp
return rtp, false
end
function M.find_root(modname)
local paths, cached = M.get_unloaded_rtp(modname, { cache = true })
local ret = require("lazy.core.cache").find(modname, {
rtp = true,
paths = paths,
patterns = { ".lua", "" },
})[1]
if not ret and cached then
paths = M.get_unloaded_rtp(modname)
ret = require("lazy.core.cache").find(modname, {
rtp = false,
paths = paths,
patterns = { ".lua", "" },
})[1]
end
if ret then
return ret.modpath:gsub("%.lua$", ""), ret.modpath
end
end
---@param modname string
2022-11-25 05:03:00 +08:00
---@param fn fun(modname:string, modpath:string)
function M.lsmod(modname, fn)
local root, match = M.find_root(modname)
if not root then
return
end
if match:sub(-4) == ".lua" then
fn(modname, match)
if not vim.uv.fs_stat(root) then
return
end
end
2022-11-25 05:03:00 +08:00
M.ls(root, function(path, name, type)
if name == "init.lua" then
fn(modname, path)
elseif (type == "file" or type == "link") and name:sub(-4) == ".lua" then
fn(modname .. "." .. name:sub(1, -5), path)
elseif type == "directory" and vim.uv.fs_stat(path .. "/init.lua") then
fn(modname .. "." .. name, path .. "/init.lua")
2022-11-25 05:03:00 +08:00
end
end)
2022-11-21 05:33:47 +08:00
end
---@generic T
---@param list T[]
---@param add T[]
---@return T[]
function M.extend(list, add)
local idx = {}
for _, v in ipairs(list) do
idx[v] = v
end
for _, a in ipairs(add) do
if not idx[a] then
table.insert(list, a)
end
end
return list
end
---@alias LazyNotifyOpts {lang?:string, title?:string, level?:number, once?:boolean, stacktrace?:boolean, stacklevel?:number}
2022-12-02 23:52:22 +08:00
---@param msg string|string[]
---@param opts? LazyNotifyOpts
function M.notify(msg, opts)
2023-01-03 23:17:15 +08:00
if vim.in_fast_event() then
return vim.schedule(function()
M.notify(msg, opts)
2023-01-03 23:17:15 +08:00
end)
end
opts = opts or {}
if type(msg) == "table" then
msg = table.concat(
vim.tbl_filter(function(line)
return line or false
end, msg),
"\n"
)
end
if opts.stacktrace then
msg = msg .. M.pretty_trace({ level = opts.stacklevel or 2 })
end
2023-01-03 23:17:15 +08:00
local lang = opts.lang or "markdown"
local n = opts.once and vim.notify_once or vim.notify
n(msg, opts.level or vim.log.levels.INFO, {
on_open = function(win)
local ok = pcall(function()
vim.treesitter.language.add("markdown")
end)
if not ok then
pcall(require, "nvim-treesitter")
end
vim.wo[win].conceallevel = 3
vim.wo[win].concealcursor = ""
vim.wo[win].spell = false
local buf = vim.api.nvim_win_get_buf(win)
2023-01-03 23:17:15 +08:00
if not pcall(vim.treesitter.start, buf, lang) then
vim.bo[buf].filetype = lang
vim.bo[buf].syntax = lang
end
end,
title = opts.title or "lazy.nvim",
2022-11-21 05:34:55 +08:00
})
2022-11-21 05:33:47 +08:00
end
2022-12-02 23:52:22 +08:00
---@param msg string|string[]
---@param opts? LazyNotifyOpts
function M.error(msg, opts)
opts = opts or {}
opts.level = vim.log.levels.ERROR
M.notify(msg, opts)
end
2022-12-02 23:52:22 +08:00
---@param msg string|string[]
---@param opts? LazyNotifyOpts
function M.info(msg, opts)
opts = opts or {}
opts.level = vim.log.levels.INFO
M.notify(msg, opts)
2022-11-23 05:35:06 +08:00
end
2022-12-02 23:52:22 +08:00
---@param msg string|string[]
---@param opts? LazyNotifyOpts
function M.warn(msg, opts)
opts = opts or {}
opts.level = vim.log.levels.WARN
M.notify(msg, opts)
2022-12-02 23:52:22 +08:00
end
2023-01-03 23:17:15 +08:00
---@param msg string|table
---@param opts? LazyNotifyOpts
function M.debug(msg, opts)
2023-01-03 23:17:15 +08:00
if not require("lazy.core.config").options.debug then
return
end
opts = opts or {}
if opts.title then
opts.title = "lazy.nvim: " .. opts.title
end
2023-01-03 23:17:15 +08:00
if type(msg) == "string" then
M.notify(msg, opts)
2023-01-03 23:17:15 +08:00
else
opts.lang = "lua"
M.notify(vim.inspect(msg), opts)
2023-01-03 23:17:15 +08:00
end
end
local function can_merge(v)
return type(v) == "table" and (vim.tbl_isempty(v) or not M.is_list(v))
end
--- Merges the values similar to vim.tbl_deep_extend with the **force** behavior,
--- but the values can be any type, in which case they override the values on the left.
--- Values will me merged in-place in the first left-most table. If you want the result to be in
--- a new table, then simply pass an empty table as the first argument `vim.merge({}, ...)`
--- Supports clearing values by setting a key to `vim.NIL`
---@generic T
---@param ... T
---@return T
function M.merge(...)
local ret = select(1, ...)
if ret == vim.NIL then
ret = nil
end
for i = 2, select("#", ...) do
local value = select(i, ...)
if can_merge(ret) and can_merge(value) then
for k, v in pairs(value) do
ret[k] = M.merge(ret[k], v)
end
elseif value == vim.NIL then
ret = nil
elseif value ~= nil then
ret = value
end
end
return ret
end
2023-10-09 02:22:01 +08:00
function M.lazy_require(module)
local mod = nil
-- if already loaded, return the module
-- otherwise return a lazy module
return type(package.loaded[module]) == "table" and package.loaded[module]
or setmetatable({}, {
__index = function(_, key)
mod = mod or require(module)
return mod[key]
end,
})
end
---@param t table
---@param key string|string[]
---@return any
function M.key_get(t, key)
local path = type(key) == "table" and key or vim.split(key, ".", true)
local value = t
for _, k in ipairs(path) do
if type(value) ~= "table" then
return value
end
value = value[k]
end
return value
end
---@param t table
---@param key string|string[]
---@param value any
function M.key_set(t, key, value)
local path = type(key) == "table" and key or vim.split(key, ".", true)
local last = t
for i = 1, #path - 1 do
local k = path[i]
if type(last[k]) ~= "table" then
last[k] = {}
end
last = last[k]
end
last[path[#path]] = value
end
2022-11-21 05:33:47 +08:00
return M