refactor: migrate to lazy.nvim (#3647)

* refactor: convert plugins spec to lazy

* refactor(lazy): remove impatient

* fix(telescope): no more errors if theme is nil

* refactor(lazy): use lazy in plugin_loader

* refactor(lazy): pin plugins with packer's snapshot

* fix: add plugins to rtp before config:init

* fix: fs_stat nil check

* feat: lazy cache

* feat(lazy): reloading

* refactor(lazy): plugin-loader functions

* feat(lazy): cache reset

* refactor: set runtimepath manually

* fix: runtimepath

* refactor(rtp)

* refactor(lazy): packer -> lazy in various places

* fix(lazy): disable tree-sitter ensure installed

* refactor(lazy): restore order to bootstrap

* refactor(lazy): remove unused impatient profiler

* small fixes

* `lvim.plugins` deprecation handling

* fix: deprecation of `requires` in plugin specs

* feat: core plugins pinning

* refactor(lazy): plugin loader tests

* refactor(lazy): use lazy in scripts

* refactor(lazy): which-key keybinds

* chore: format

* fix: installer

* fix: first time setup

* feat: changes required for packaging

commit 951ac2b7c01b5200b973660c967852d1706cce28
Author: LostNeophyte <[email protected]>
Date:   Wed Dec 28 13:49:44 2022 +0100

    fix: clean folder before copying plugins

commit 64e9afa44b8e528ba527e0510d0d8c2d2237a095
Author: LostNeophyte <[email protected]>
Date:   Wed Dec 28 13:35:41 2022 +0100

    feat: copy core plugins on first run

commit 2d8e72090c7624f68c09a9aa6582223373a810c1
Author: LostNeophyte <[email protected]>
Date:   Wed Dec 28 13:11:22 2022 +0100

    feat(utils): fs_copy

commit 85c1f025a6ba13183e85141f75f60e2eefc77bb5
Author: LostNeophyte <[email protected]>
Date:   Wed Dec 28 13:04:38 2022 +0100

    fix: copy correct example config

* fix: packer specs deprecation handling

* fix: plugin specs deprecation

* feat: pin lazy's version

* fix: remove plugins form rtp before loading lazy

* fix: plugin-loader test

* feat(lazy): add keymappings for profile, log, and debug (#3665)

* feat(lazy): Add keymappings for profile, log, and debug

* feat(lazy): Add keymap for cleaning

* chore: format

* pref: lazy load many plugins

Co-authored-by: Uzair Aftab <[email protected]>

* fix: bootstrap correct version of lazy

* fix: also use CmdLineEnter event for cmp

* fix: don't use lazy's modules before it's set up

* perf: (hack) enable lazy's cache before loading lazy

* fix: plugins.lua

* fix: plugins bump script

* chore: remove debug print

* feat: add rounded border for `:Lazy`

* fix: bufferline flashing

* fix: don't close lazy on startup

* fix: load breadcrumbs on startup

* fix: don't lazy load bufferline

* chore: bump lazy's version

* fix: remove site from rtp (fixes treesitter issues)

* revert default config copying changes

* fix(bootstrap): actually remove plugins dir on windows

* chore: bump lazy's version

* chore: bump lazy's version

Co-authored-by: kylo252 <[email protected]>
Co-authored-by: Uzair Aftab <[email protected]>
Co-authored-by: Uzair Aftab <[email protected]>
Co-authored-by: opalmay <[email protected]>

1 files changed, 0 insertions, 477 deletions

diff --git a/lua/lvim/impatient.lua b/lua/lvim/impatient.lua
deleted file mode 100644
index beb3862a..00000000
--- a/lua/lvim/impatient.lua
+++ /dev/null
@@ -1,477 +0,0 @@
--- modified version from https://github.com/lewis6991/impatient.nvim
-local vim = vim
-local api = vim.api
-local uv = vim.loop
-local _loadfile = loadfile
-local get_runtime = api.nvim__get_runtime
-local fs_stat = uv.fs_stat
-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 function modpath_mangle(modpath)
-  for name, dir in pairs(std_dirs) do
-    modpath = modpath:gsub(dir, name)
-  end
-  return modpath
-end
-
-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 = {
-    cache = {},
-    profile = nil,
-    dirty = false,
-    get = function(self, path)
-      return self.cache[modpath_mangle(path)]
-    end,
-    set = function(self, path, chunk)
-      self.cache[modpath_mangle(path)] = chunk
-    end,
-  },
-  modpaths = {
-    cache = {},
-    profile = nil,
-    dirty = false,
-    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 = {},
-}
-
----@diagnostic disable-next-line: undefined-field
-local M = vim.tbl_deep_extend("keep", _G.__luacache_config or {}, default_config, default_state)
-_G.__luacache = M
-
-local function log(...)
-  M.log[#M.log + 1] = table.concat({ string.format(...) }, " ")
-end
-
-local function print_log()
-  for _, l in ipairs(M.log) do
-    print(l)
-  end
-end
-
-local function hash(modpath)
-  local stat = fs_stat(modpath)
-  if stat then
-    return stat.mtime.sec .. stat.mtime.nsec .. stat.size
-  end
-  error("Could not hash " .. modpath)
-end
-
-local function profile(m, entry, name, loader)
-  if m.profile then
-    local mp = m.profile
-    mp[entry] = mp[entry] or {}
-    if not mp[entry].loader and loader then
-      mp[entry].loader = loader
-    end
-    if not mp[entry][name] then
-      mp[entry][name] = uv.hrtime()
-    end
-  end
-end
-
-local function mprofile(mod, name, loader)
-  profile(M.modpaths, mod, name, loader)
-end
-
-local function cprofile(path, name, loader)
-  if M.chunks.profile then
-    path = modpath_mangle(path)
-  end
-  profile(M.chunks, path, name, loader)
-end
-
-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.
-  -- If we have then try looking in the parents directory first.
-  local parents = vim.split(basename, sep)
-  for i = #parents, 1, -1 do
-    local parent = table.concat(vim.list_slice(parents, 1, i), sep)
-    local ppath = M.modpaths:get(parent)
-    if ppath then
-      if ppath:sub(-9) == (sep .. "init.lua") then
-        ppath = ppath:sub(1, -10) -- a/b/init.lua -> a/b
-      else
-        ppath = ppath:sub(1, -5) -- a/b.lua -> a/b
-      end
-
-      for _, path in ipairs(paths) do
-        -- path should be of form 'a/b/c.lua' or 'a/b/c/init.lua'
-        local modpath = ppath .. sep .. path:sub(#("lua" .. sep .. parent) + 2)
-        if fs_stat(modpath) then
-          return modpath, "cache(p)"
-        end
-      end
-    end
-  end
-end
-
-local rtp = vim.split(vim.o.rtp, ",")
-
--- 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
-
-local function get_runtime_file_cached(basename, paths)
-  local modpath, loader
-  local mp = M.modpaths
-  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
-
-  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
-    mprofile(basename, "resolve_end", loader)
-    if mp.enable and loader ~= "cache" then
-      log("Creating cache for module %s", basename)
-      mp:set(basename, modpath)
-      mp.dirty = true
-    end
-  end
-
-  return modpath
-end
-
-local function extract_basename(pats)
-  local basename
-
-  -- Deconstruct basename from pats
-  for _, pat in ipairs(pats) do
-    for i, npat in ipairs {
-      -- Ordered by most specific
-      "lua"
-        .. sep
-        .. "(.*)"
-        .. sep
-        .. "init%.lua",
-      "lua" .. sep .. "(.*)%.lua",
-    } do
-      local m = pat:match(npat)
-      if i == 2 and m and m:sub(-4) == "init" then
-        m = m:sub(0, -6)
-      end
-      if not basename then
-        if m then
-          basename = m
-        end
-      elseif m and m ~= basename then
-        -- matches are inconsistent
-        return
-      end
-    end
-  end
-
-  return basename
-end
-
-local function get_runtime_cached(pats, all, opts)
-  local fallback = false
-  if all or not opts or not opts.is_lua then
-    -- Fallback
-    fallback = true
-  end
-
-  local basename
-
-  if not fallback then
-    basename = extract_basename(pats)
-  end
-
-  if fallback or not basename then
-    return get_runtime(pats, all, opts)
-  end
-
-  return { get_runtime_file_cached(basename, pats) }
-end
-
--- Copied from neovim/src/nvim/lua/vim.lua with two lines changed
-local function load_package(name)
-  local basename = name:gsub("%.", sep)
-  local paths = { "lua" .. sep .. basename .. ".lua", "lua" .. sep .. basename .. sep .. "init.lua" }
-
-  -- Original line:
-  -- local found = vim.api.nvim__get_runtime(paths, false, {is_lua=true})
-  local found = { get_runtime_file_cached(basename, paths) }
-  if #found > 0 then
-    local f, err = loadfile(found[1])
-    return f or error(err)
-  end
-
-  local so_paths = {}
-  for _, trail in ipairs(vim._so_trails) do
-    local path = "lua" .. trail:gsub("?", basename) -- so_trails contains a leading slash
-    table.insert(so_paths, path)
-  end
-
-  -- Original line:
-  -- found = vim.api.nvim__get_runtime(so_paths, false, {is_lua=true})
-  found = { get_runtime_file_cached(basename, so_paths) }
-  if #found > 0 then
-    -- Making function name in Lua 5.1 (see src/loadlib.c:mkfuncname) is
-    -- a) strip prefix up to and including the first dash, if any
-    -- b) replace all dots by underscores
-    -- c) prepend "luaopen_"
-    -- So "foo-bar.baz" should result in "luaopen_bar_baz"
-    local dash = name:find("-", 1, true)
-    local modname = dash and name:sub(dash + 1) or name
-    local f, err = loadlib(found[1], "luaopen_" .. modname:gsub("%.", "_"))
-    return f or error(err)
-  end
-  return nil
-end
-
-local function load_from_cache(path)
-  local mc = M.chunks
-
-  local cache = mc:get(path)
-
-  if not cache then
-    return nil, string.format("No cache for path %s", path)
-  end
-
-  local mhash, codes = unpack(cache)
-
-  if mhash ~= hash(path) then
-    mc:set(path)
-    mc.dirty = true
-    return nil, string.format("Stale cache for path %s", path)
-  end
-
-  local chunk = loadstring(codes)
-
-  if not chunk then
-    mc:set(path)
-    mc.dirty = true
-    return nil, string.format("Cache error for path %s", path)
-  end
-
-  return chunk
-end
-
-local function loadfile_cached(path)
-  cprofile(path, "load_start")
-
-  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
-
-  chunk, err = _loadfile(path)
-
-  if not err and M.chunks.enable then
-    log("Creating cache for path %s", path)
-    M.chunks:set(path, { hash(path), string.dump(chunk) })
-    M.chunks.dirty = true
-  end
-
-  cprofile(path, "load_end", "standard")
-  return chunk, err
-end
-
-function M.save_cache()
-  local function _save_cache(t)
-    if not t.enable then
-      return
-    end
-    if t.dirty then
-      log("Updating chunk cache file: %s", t.path)
-      local f = assert(io.open(t.path, "w+b"))
-      f:write(mpack.encode(t.cache))
-      f:flush()
-      t.dirty = false
-    end
-  end
-  _save_cache(M.chunks)
-  _save_cache(M.modpaths)
-end
-
-local function clear_cache()
-  local function _clear_cache(t)
-    t.cache = {}
-    os.remove(t.path)
-  end
-  _clear_cache(M.chunks)
-  _clear_cache(M.modpaths)
-end
-
-local function init_cache()
-  local function _init_cache(t)
-    if not t.enable then
-      return
-    end
-    if fs_stat(t.path) then
-      log("Loading cache file %s", t.path)
-      local f = assert(io.open(t.path, "rb"))
-      local ok
-      ok, t.cache = pcall(function()
-        return mpack.decode(f:read "*a")
-      end)
-
-      if not ok then
-        log("Corrupted cache file, %s. Invalidating...", t.path)
-        os.remove(t.path)
-        t.cache = {}
-      end
-      t.dirty = not ok
-    end
-  end
-
-  if not uv.fs_stat(std_cache) then
-    vim.fn.mkdir(std_cache, "p")
-  end
-
-  _init_cache(M.chunks)
-  _init_cache(M.modpaths)
-end
-
-local function setup()
-  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
-  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.api.nvim__get_runtime = get_runtime_cached
-  loadfile = loadfile_cached
-
-  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,
-  })
-
-  api.nvim_create_autocmd("OptionSet", {
-    group = augroup,
-    pattern = "runtimepath",
-    callback = function()
-      rtp = vim.split(vim.o.rtp, ",")
-    end,
-  })
-end
-
-setup()
-
-return M