|
@@ -1,5 +1,4 @@
|
|
-- modified version from https://github.com/lewis6991/impatient.nvim
|
|
-- modified version from https://github.com/lewis6991/impatient.nvim
|
|
-
|
|
|
|
local vim = vim
|
|
local vim = vim
|
|
local api = vim.api
|
|
local api = vim.api
|
|
local uv = vim.loop
|
|
local uv = vim.loop
|
|
@@ -7,66 +6,96 @@ local _loadfile = loadfile
|
|
local get_runtime = api.nvim__get_runtime
|
|
local get_runtime = api.nvim__get_runtime
|
|
local fs_stat = uv.fs_stat
|
|
local fs_stat = uv.fs_stat
|
|
local mpack = vim.mpack
|
|
local mpack = vim.mpack
|
|
|
|
+local loadlib = package.loadlib
|
|
|
|
+
|
|
|
|
+local std_cache = vim.fn.stdpath "cache"
|
|
|
|
+
|
|
|
|
+local sep
|
|
|
|
+if jit.os == "Windows" then
|
|
|
|
+ sep = "\\"
|
|
|
|
+else
|
|
|
|
+ sep = "/"
|
|
|
|
+end
|
|
|
|
+
|
|
|
|
+local std_dirs = {
|
|
|
|
+ ["<APPDIR>"] = os.getenv "APPDIR",
|
|
|
|
+ ["<VIMRUNTIME>"] = os.getenv "VIMRUNTIME",
|
|
|
|
+ ["<STD_DATA>"] = vim.fn.stdpath "data",
|
|
|
|
+ ["<STD_CONFIG>"] = vim.fn.stdpath "config",
|
|
|
|
+ ["<LVIM_BASE>"] = get_lvim_base_dir(),
|
|
|
|
+ ["<LVIM_RUNTIME>"] = get_runtime_dir(),
|
|
|
|
+ ["<LVIM_CONFIG>"] = get_config_dir(),
|
|
|
|
+}
|
|
|
|
|
|
-local appdir = os.getenv "APPDIR"
|
|
|
|
|
|
+local function modpath_mangle(modpath)
|
|
|
|
+ for name, dir in pairs(std_dirs) do
|
|
|
|
+ modpath = modpath:gsub(dir, name)
|
|
|
|
+ end
|
|
|
|
+ return modpath
|
|
|
|
+end
|
|
|
|
|
|
-local M = {
|
|
|
|
|
|
+local function modpath_unmangle(modpath)
|
|
|
|
+ for name, dir in pairs(std_dirs) do
|
|
|
|
+ modpath = modpath:gsub(name, dir)
|
|
|
|
+ end
|
|
|
|
+ return modpath
|
|
|
|
+end
|
|
|
|
+
|
|
|
|
+-- Overridable by user
|
|
|
|
+local default_config = {
|
|
|
|
+ chunks = {
|
|
|
|
+ enable = true,
|
|
|
|
+ path = std_cache .. sep .. "luacache_chunks",
|
|
|
|
+ },
|
|
|
|
+ modpaths = {
|
|
|
|
+ enable = true,
|
|
|
|
+ path = std_cache .. sep .. "luacache_modpaths",
|
|
|
|
+ },
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+-- State used internally
|
|
|
|
+local default_state = {
|
|
chunks = {
|
|
chunks = {
|
|
cache = {},
|
|
cache = {},
|
|
profile = nil,
|
|
profile = nil,
|
|
dirty = false,
|
|
dirty = false,
|
|
- path = vim.fn.stdpath "cache" .. "/luacache_chunks",
|
|
|
|
|
|
+ get = function(self, path)
|
|
|
|
+ return self.cache[modpath_mangle(path)]
|
|
|
|
+ end,
|
|
|
|
+ set = function(self, path, chunk)
|
|
|
|
+ self.cache[modpath_mangle(path)] = chunk
|
|
|
|
+ end,
|
|
},
|
|
},
|
|
modpaths = {
|
|
modpaths = {
|
|
cache = {},
|
|
cache = {},
|
|
profile = nil,
|
|
profile = nil,
|
|
dirty = false,
|
|
dirty = false,
|
|
- path = vim.fn.stdpath "cache" .. "/luacache_modpaths",
|
|
|
|
|
|
+ get = function(self, mod)
|
|
|
|
+ if self.cache[mod] then
|
|
|
|
+ return modpath_unmangle(self.cache[mod])
|
|
|
|
+ end
|
|
|
|
+ end,
|
|
|
|
+ set = function(self, mod, path)
|
|
|
|
+ self.cache[mod] = modpath_mangle(path)
|
|
|
|
+ end,
|
|
},
|
|
},
|
|
log = {},
|
|
log = {},
|
|
}
|
|
}
|
|
|
|
|
|
|
|
+---@diagnostic disable-next-line: undefined-field
|
|
|
|
+local M = vim.tbl_deep_extend("keep", _G.__luacache_config or {}, default_config, default_state)
|
|
_G.__luacache = M
|
|
_G.__luacache = M
|
|
|
|
|
|
-if not get_runtime then
|
|
|
|
- -- nvim 0.5 compat
|
|
|
|
- get_runtime = function(paths, all, _)
|
|
|
|
- local r = {}
|
|
|
|
- for _, path in ipairs(paths) do
|
|
|
|
- local found = api.nvim_get_runtime_file(path, all)
|
|
|
|
- for i = 1, #found do
|
|
|
|
- r[#r + 1] = found[i]
|
|
|
|
- end
|
|
|
|
- end
|
|
|
|
- return r
|
|
|
|
- end
|
|
|
|
-end
|
|
|
|
-
|
|
|
|
local function log(...)
|
|
local function log(...)
|
|
M.log[#M.log + 1] = table.concat({ string.format(...) }, " ")
|
|
M.log[#M.log + 1] = table.concat({ string.format(...) }, " ")
|
|
end
|
|
end
|
|
|
|
|
|
-function M.print_log()
|
|
|
|
|
|
+local function print_log()
|
|
for _, l in ipairs(M.log) do
|
|
for _, l in ipairs(M.log) do
|
|
print(l)
|
|
print(l)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
-function M.enable_profile()
|
|
|
|
- local P = require "lvim.impatient.profile"
|
|
|
|
-
|
|
|
|
- M.chunks.profile = {}
|
|
|
|
- M.modpaths.profile = {}
|
|
|
|
-
|
|
|
|
- P.setup(M.modpaths.profile)
|
|
|
|
-
|
|
|
|
- M.print_profile = function()
|
|
|
|
- P.print_profile(M)
|
|
|
|
- end
|
|
|
|
-
|
|
|
|
- vim.cmd [[command! LuaCacheProfile lua _G.__luacache.print_profile()]]
|
|
|
|
-end
|
|
|
|
-
|
|
|
|
local function hash(modpath)
|
|
local function hash(modpath)
|
|
local stat = fs_stat(modpath)
|
|
local stat = fs_stat(modpath)
|
|
if stat then
|
|
if stat then
|
|
@@ -75,20 +104,6 @@ local function hash(modpath)
|
|
error("Could not hash " .. modpath)
|
|
error("Could not hash " .. modpath)
|
|
end
|
|
end
|
|
|
|
|
|
-local function modpath_mangle(modpath)
|
|
|
|
- if appdir then
|
|
|
|
- modpath = modpath:gsub(appdir, "/$APPDIR")
|
|
|
|
- end
|
|
|
|
- return modpath
|
|
|
|
-end
|
|
|
|
-
|
|
|
|
-local function modpath_unmangle(modpath)
|
|
|
|
- if appdir then
|
|
|
|
- modpath = modpath:gsub("/$APPDIR", appdir)
|
|
|
|
- end
|
|
|
|
- return modpath
|
|
|
|
-end
|
|
|
|
-
|
|
|
|
local function profile(m, entry, name, loader)
|
|
local function profile(m, entry, name, loader)
|
|
if m.profile then
|
|
if m.profile then
|
|
local mp = m.profile
|
|
local mp = m.profile
|
|
@@ -107,18 +122,41 @@ local function mprofile(mod, name, loader)
|
|
end
|
|
end
|
|
|
|
|
|
local function cprofile(path, name, loader)
|
|
local function cprofile(path, name, loader)
|
|
|
|
+ if M.chunks.profile then
|
|
|
|
+ path = modpath_mangle(path)
|
|
|
|
+ end
|
|
profile(M.chunks, path, name, loader)
|
|
profile(M.chunks, path, name, loader)
|
|
end
|
|
end
|
|
|
|
|
|
-local function get_runtime_file(basename, paths)
|
|
|
|
|
|
+function M.enable_profile()
|
|
|
|
+ local P = require "lvim.impatient.profile"
|
|
|
|
+
|
|
|
|
+ M.chunks.profile = {}
|
|
|
|
+ M.modpaths.profile = {}
|
|
|
|
+
|
|
|
|
+ loadlib = function(path, fun)
|
|
|
|
+ cprofile(path, "load_start")
|
|
|
|
+ local f, err = package.loadlib(path, fun)
|
|
|
|
+ cprofile(path, "load_end", "standard")
|
|
|
|
+ return f, err
|
|
|
|
+ end
|
|
|
|
+
|
|
|
|
+ P.setup(M.modpaths.profile)
|
|
|
|
+
|
|
|
|
+ api.nvim_create_user_command("LuaCacheProfile", function()
|
|
|
|
+ P.print_profile(M, std_dirs)
|
|
|
|
+ end, {})
|
|
|
|
+end
|
|
|
|
+
|
|
|
|
+local function get_runtime_file_from_parent(basename, paths)
|
|
-- Look in the cache to see if we have already loaded a parent module.
|
|
-- Look in the cache to see if we have already loaded a parent module.
|
|
-- If we have then try looking in the parents directory first.
|
|
-- If we have then try looking in the parents directory first.
|
|
- local parents = vim.split(basename, "/")
|
|
|
|
|
|
+ local parents = vim.split(basename, sep)
|
|
for i = #parents, 1, -1 do
|
|
for i = #parents, 1, -1 do
|
|
- local parent = table.concat(vim.list_slice(parents, 1, i), "/")
|
|
|
|
- local ppath = M.modpaths.cache[parent]
|
|
|
|
|
|
+ local parent = table.concat(vim.list_slice(parents, 1, i), sep)
|
|
|
|
+ local ppath = M.modpaths:get(parent)
|
|
if ppath then
|
|
if ppath then
|
|
- if ppath:sub(-9) == "/init.lua" then
|
|
|
|
|
|
+ if ppath:sub(-9) == (sep .. "init.lua") then
|
|
ppath = ppath:sub(1, -10) -- a/b/init.lua -> a/b
|
|
ppath = ppath:sub(1, -10) -- a/b/init.lua -> a/b
|
|
else
|
|
else
|
|
ppath = ppath:sub(1, -5) -- a/b.lua -> a/b
|
|
ppath = ppath:sub(1, -5) -- a/b.lua -> a/b
|
|
@@ -126,38 +164,71 @@ local function get_runtime_file(basename, paths)
|
|
|
|
|
|
for _, path in ipairs(paths) do
|
|
for _, path in ipairs(paths) do
|
|
-- path should be of form 'a/b/c.lua' or 'a/b/c/init.lua'
|
|
-- path should be of form 'a/b/c.lua' or 'a/b/c/init.lua'
|
|
- local modpath = ppath .. "/" .. path:sub(#("lua/" .. parent) + 2)
|
|
|
|
|
|
+ local modpath = ppath .. sep .. path:sub(#("lua" .. sep .. parent) + 2)
|
|
if fs_stat(modpath) then
|
|
if fs_stat(modpath) then
|
|
return modpath, "cache(p)"
|
|
return modpath, "cache(p)"
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
+end
|
|
|
|
+
|
|
|
|
+local rtp = vim.split(vim.o.rtp, ",")
|
|
|
|
|
|
- -- What Neovim does by default; slowest
|
|
|
|
- local modpath = get_runtime(paths, false, { is_lua = true })[1]
|
|
|
|
- return modpath, "standard"
|
|
|
|
|
|
+-- Make sure modpath is in rtp and that modpath is in paths.
|
|
|
|
+local function validate_modpath(modpath, paths)
|
|
|
|
+ local match = false
|
|
|
|
+ for _, p in ipairs(paths) do
|
|
|
|
+ if vim.endswith(modpath, p) then
|
|
|
|
+ match = true
|
|
|
|
+ break
|
|
|
|
+ end
|
|
|
|
+ end
|
|
|
|
+ if not match then
|
|
|
|
+ return false
|
|
|
|
+ end
|
|
|
|
+ for _, dir in ipairs(rtp) do
|
|
|
|
+ if vim.startswith(modpath, dir) then
|
|
|
|
+ return fs_stat(modpath) ~= nil
|
|
|
|
+ end
|
|
|
|
+ end
|
|
|
|
+ return false
|
|
end
|
|
end
|
|
|
|
|
|
local function get_runtime_file_cached(basename, paths)
|
|
local function get_runtime_file_cached(basename, paths)
|
|
|
|
+ local modpath, loader
|
|
local mp = M.modpaths
|
|
local mp = M.modpaths
|
|
- if mp.cache[basename] then
|
|
|
|
- local modpath = mp.cache[basename]
|
|
|
|
- if fs_stat(modpath) then
|
|
|
|
- mprofile(basename, "resolve_end", "cache")
|
|
|
|
- return modpath
|
|
|
|
|
|
+ if mp.enable then
|
|
|
|
+ local modpath_cached = mp:get(basename)
|
|
|
|
+ if modpath_cached then
|
|
|
|
+ modpath, loader = modpath_cached, "cache"
|
|
|
|
+ else
|
|
|
|
+ modpath, loader = get_runtime_file_from_parent(basename, paths)
|
|
|
|
+ end
|
|
|
|
+
|
|
|
|
+ if modpath and not validate_modpath(modpath, paths) then
|
|
|
|
+ modpath = nil
|
|
|
|
+
|
|
|
|
+ -- Invalidate
|
|
|
|
+ mp.cache[basename] = nil
|
|
|
|
+ mp.dirty = true
|
|
end
|
|
end
|
|
- mp.cache[basename] = nil
|
|
|
|
- mp.dirty = true
|
|
|
|
end
|
|
end
|
|
|
|
|
|
- local modpath, loader = get_runtime_file(basename, paths)
|
|
|
|
|
|
+ if not modpath then
|
|
|
|
+ -- What Neovim does by default; slowest
|
|
|
|
+ modpath, loader = get_runtime(paths, false, { is_lua = true })[1], "standard"
|
|
|
|
+ end
|
|
|
|
+
|
|
if modpath then
|
|
if modpath then
|
|
mprofile(basename, "resolve_end", loader)
|
|
mprofile(basename, "resolve_end", loader)
|
|
- log("Creating cache for module %s", basename)
|
|
|
|
- mp.cache[basename] = modpath_mangle(modpath)
|
|
|
|
- mp.dirty = true
|
|
|
|
|
|
+ if mp.enable and loader ~= "cache" then
|
|
|
|
+ log("Creating cache for module %s", basename)
|
|
|
|
+ mp:set(basename, modpath)
|
|
|
|
+ mp.dirty = true
|
|
|
|
+ end
|
|
end
|
|
end
|
|
|
|
+
|
|
return modpath
|
|
return modpath
|
|
end
|
|
end
|
|
|
|
|
|
@@ -168,8 +239,12 @@ local function extract_basename(pats)
|
|
for _, pat in ipairs(pats) do
|
|
for _, pat in ipairs(pats) do
|
|
for i, npat in ipairs {
|
|
for i, npat in ipairs {
|
|
-- Ordered by most specific
|
|
-- Ordered by most specific
|
|
- "lua/(.*)/init%.lua",
|
|
|
|
- "lua/(.*)%.lua",
|
|
|
|
|
|
+ "lua"
|
|
|
|
+ .. sep
|
|
|
|
+ .. "(.*)"
|
|
|
|
+ .. sep
|
|
|
|
+ .. "init%.lua",
|
|
|
|
+ "lua" .. sep .. "(.*)%.lua",
|
|
} do
|
|
} do
|
|
local m = pat:match(npat)
|
|
local m = pat:match(npat)
|
|
if i == 2 and m and m:sub(-4) == "init" then
|
|
if i == 2 and m and m:sub(-4) == "init" then
|
|
@@ -211,8 +286,8 @@ end
|
|
|
|
|
|
-- Copied from neovim/src/nvim/lua/vim.lua with two lines changed
|
|
-- Copied from neovim/src/nvim/lua/vim.lua with two lines changed
|
|
local function load_package(name)
|
|
local function load_package(name)
|
|
- local basename = name:gsub("%.", "/")
|
|
|
|
- local paths = { "lua/" .. basename .. ".lua", "lua/" .. basename .. "/init.lua" }
|
|
|
|
|
|
+ local basename = name:gsub("%.", sep)
|
|
|
|
+ local paths = { "lua" .. sep .. basename .. ".lua", "lua" .. sep .. basename .. sep .. "init.lua" }
|
|
|
|
|
|
-- Original line:
|
|
-- Original line:
|
|
-- local found = vim.api.nvim__get_runtime(paths, false, {is_lua=true})
|
|
-- local found = vim.api.nvim__get_runtime(paths, false, {is_lua=true})
|
|
@@ -239,7 +314,7 @@ local function load_package(name)
|
|
-- So "foo-bar.baz" should result in "luaopen_bar_baz"
|
|
-- So "foo-bar.baz" should result in "luaopen_bar_baz"
|
|
local dash = name:find("-", 1, true)
|
|
local dash = name:find("-", 1, true)
|
|
local modname = dash and name:sub(dash + 1) or name
|
|
local modname = dash and name:sub(dash + 1) or name
|
|
- local f, err = package.loadlib(found[1], "luaopen_" .. modname:gsub("%.", "_"))
|
|
|
|
|
|
+ local f, err = loadlib(found[1], "luaopen_" .. modname:gsub("%.", "_"))
|
|
return f or error(err)
|
|
return f or error(err)
|
|
end
|
|
end
|
|
return nil
|
|
return nil
|
|
@@ -248,14 +323,16 @@ end
|
|
local function load_from_cache(path)
|
|
local function load_from_cache(path)
|
|
local mc = M.chunks
|
|
local mc = M.chunks
|
|
|
|
|
|
- if not mc.cache[path] then
|
|
|
|
|
|
+ local cache = mc:get(path)
|
|
|
|
+
|
|
|
|
+ if not cache then
|
|
return nil, string.format("No cache for path %s", path)
|
|
return nil, string.format("No cache for path %s", path)
|
|
end
|
|
end
|
|
|
|
|
|
- local mhash, codes = unpack(mc.cache[path])
|
|
|
|
|
|
+ local mhash, codes = unpack(cache)
|
|
|
|
|
|
- if mhash ~= hash(modpath_unmangle(path)) then
|
|
|
|
- mc.cache[path] = nil
|
|
|
|
|
|
+ if mhash ~= hash(path) then
|
|
|
|
+ mc:set(path)
|
|
mc.dirty = true
|
|
mc.dirty = true
|
|
return nil, string.format("Stale cache for path %s", path)
|
|
return nil, string.format("Stale cache for path %s", path)
|
|
end
|
|
end
|
|
@@ -263,7 +340,7 @@ local function load_from_cache(path)
|
|
local chunk = loadstring(codes)
|
|
local chunk = loadstring(codes)
|
|
|
|
|
|
if not chunk then
|
|
if not chunk then
|
|
- mc.cache[path] = nil
|
|
|
|
|
|
+ mc:set(path)
|
|
mc.dirty = true
|
|
mc.dirty = true
|
|
return nil, string.format("Cache error for path %s", path)
|
|
return nil, string.format("Cache error for path %s", path)
|
|
end
|
|
end
|
|
@@ -274,19 +351,23 @@ end
|
|
local function loadfile_cached(path)
|
|
local function loadfile_cached(path)
|
|
cprofile(path, "load_start")
|
|
cprofile(path, "load_start")
|
|
|
|
|
|
- local chunk, err = load_from_cache(path)
|
|
|
|
- if chunk and not err then
|
|
|
|
- log("Loaded cache for path %s", path)
|
|
|
|
- cprofile(path, "load_end", "cache")
|
|
|
|
- return chunk
|
|
|
|
|
|
+ local chunk, err
|
|
|
|
+
|
|
|
|
+ if M.chunks.enable then
|
|
|
|
+ chunk, err = load_from_cache(path)
|
|
|
|
+ if chunk and not err then
|
|
|
|
+ log("Loaded cache for path %s", path)
|
|
|
|
+ cprofile(path, "load_end", "cache")
|
|
|
|
+ return chunk
|
|
|
|
+ end
|
|
|
|
+ log(err)
|
|
end
|
|
end
|
|
- log(err)
|
|
|
|
|
|
|
|
chunk, err = _loadfile(path)
|
|
chunk, err = _loadfile(path)
|
|
|
|
|
|
- if not err then
|
|
|
|
|
|
+ if not err and M.chunks.enable then
|
|
log("Creating cache for path %s", path)
|
|
log("Creating cache for path %s", path)
|
|
- M.chunks.cache[modpath_mangle(path)] = { hash(path), string.dump(chunk) }
|
|
|
|
|
|
+ M.chunks:set(path, { hash(path), string.dump(chunk) })
|
|
M.chunks.dirty = true
|
|
M.chunks.dirty = true
|
|
end
|
|
end
|
|
|
|
|
|
@@ -296,9 +377,12 @@ end
|
|
|
|
|
|
function M.save_cache()
|
|
function M.save_cache()
|
|
local function _save_cache(t)
|
|
local function _save_cache(t)
|
|
|
|
+ if not t.enable then
|
|
|
|
+ return
|
|
|
|
+ end
|
|
if t.dirty then
|
|
if t.dirty then
|
|
log("Updating chunk cache file: %s", t.path)
|
|
log("Updating chunk cache file: %s", t.path)
|
|
- local f = io.open(t.path, "w+b")
|
|
|
|
|
|
+ local f = assert(io.open(t.path, "w+b"))
|
|
f:write(mpack.encode(t.cache))
|
|
f:write(mpack.encode(t.cache))
|
|
f:flush()
|
|
f:flush()
|
|
t.dirty = false
|
|
t.dirty = false
|
|
@@ -308,7 +392,7 @@ function M.save_cache()
|
|
_save_cache(M.modpaths)
|
|
_save_cache(M.modpaths)
|
|
end
|
|
end
|
|
|
|
|
|
-function M.clear_cache()
|
|
|
|
|
|
+local function clear_cache()
|
|
local function _clear_cache(t)
|
|
local function _clear_cache(t)
|
|
t.cache = {}
|
|
t.cache = {}
|
|
os.remove(t.path)
|
|
os.remove(t.path)
|
|
@@ -319,9 +403,12 @@ end
|
|
|
|
|
|
local function init_cache()
|
|
local function init_cache()
|
|
local function _init_cache(t)
|
|
local function _init_cache(t)
|
|
|
|
+ if not t.enable then
|
|
|
|
+ return
|
|
|
|
+ end
|
|
if fs_stat(t.path) then
|
|
if fs_stat(t.path) then
|
|
log("Loading cache file %s", t.path)
|
|
log("Loading cache file %s", t.path)
|
|
- local f = io.open(t.path, "rb")
|
|
|
|
|
|
+ local f = assert(io.open(t.path, "rb"))
|
|
local ok
|
|
local ok
|
|
ok, t.cache = pcall(function()
|
|
ok, t.cache = pcall(function()
|
|
return mpack.decode(f:read "*a")
|
|
return mpack.decode(f:read "*a")
|
|
@@ -336,6 +423,10 @@ local function init_cache()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
+ if not uv.fs_stat(std_cache) then
|
|
|
|
+ vim.fn.mkdir(std_cache, "p")
|
|
|
|
+ end
|
|
|
|
+
|
|
_init_cache(M.chunks)
|
|
_init_cache(M.chunks)
|
|
_init_cache(M.modpaths)
|
|
_init_cache(M.modpaths)
|
|
end
|
|
end
|
|
@@ -343,20 +434,42 @@ end
|
|
local function setup()
|
|
local function setup()
|
|
init_cache()
|
|
init_cache()
|
|
|
|
|
|
|
|
+ -- Usual package loaders
|
|
|
|
+ -- 1. package.preload
|
|
|
|
+ -- 2. vim._load_package
|
|
|
|
+ -- 3. package.path
|
|
|
|
+ -- 4. package.cpath
|
|
|
|
+ -- 5. all-in-one
|
|
|
|
+
|
|
-- Override default functions
|
|
-- Override default functions
|
|
|
|
+ for i, loader in ipairs(package.loaders) do
|
|
|
|
+ if loader == vim._load_package then
|
|
|
|
+ package.loaders[i] = load_package
|
|
|
|
+ break
|
|
|
|
+ end
|
|
|
|
+ end
|
|
vim._load_package = load_package
|
|
vim._load_package = load_package
|
|
|
|
+
|
|
vim.api.nvim__get_runtime = get_runtime_cached
|
|
vim.api.nvim__get_runtime = get_runtime_cached
|
|
- -- luacheck: ignore 121
|
|
|
|
loadfile = loadfile_cached
|
|
loadfile = loadfile_cached
|
|
|
|
|
|
- vim.cmd [[
|
|
|
|
- augroup impatient
|
|
|
|
- autocmd VimEnter,VimLeave * lua _G.__luacache.save_cache()
|
|
|
|
- augroup END
|
|
|
|
|
|
+ local augroup = api.nvim_create_augroup("impatient", {})
|
|
|
|
+
|
|
|
|
+ api.nvim_create_user_command("LuaCacheClear", clear_cache, {})
|
|
|
|
+ api.nvim_create_user_command("LuaCacheLog", print_log, {})
|
|
|
|
+
|
|
|
|
+ api.nvim_create_autocmd({ "VimEnter", "VimLeave" }, {
|
|
|
|
+ group = augroup,
|
|
|
|
+ callback = M.save_cache,
|
|
|
|
+ })
|
|
|
|
|
|
- command! LuaCacheClear lua _G.__luacache.clear_cache()
|
|
|
|
- command! LuaCacheLog lua _G.__luacache.print_log()
|
|
|
|
- ]]
|
|
|
|
|
|
+ api.nvim_create_autocmd("OptionSet", {
|
|
|
|
+ group = augroup,
|
|
|
|
+ pattern = "runtimepath",
|
|
|
|
+ callback = function()
|
|
|
|
+ rtp = vim.split(vim.o.rtp, ",")
|
|
|
|
+ end,
|
|
|
|
+ })
|
|
end
|
|
end
|
|
|
|
|
|
setup()
|
|
setup()
|