feat: added support for packages [WIP]

.github/workflows/ci.yml

@@ -26,31 +26,10 @@ jobs:
           nvim --version
           [ ! -d tests ] && exit 0
           nvim --headless -u tests/init.lua -c "PlenaryBustedDirectory tests/ {minimal_init = 'tests/init.lua', sequential = true}"
-  docs:
-    runs-on: ubuntu-latest
-    needs: tests
-    if: ${{ github.ref == 'refs/heads/main' }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: panvimdoc
-        uses: kdheepak/panvimdoc@main
-        with:
-          vimdoc: lazy.nvim
-          version: "Neovim >= 0.8.0"
-          demojify: true
-          treesitter: true
-      - name: Push changes
-        uses: stefanzweifel/git-auto-commit-action@v5
-        with:
-          commit_message: "chore(build): auto-generate vimdoc"
-          commit_user_name: "github-actions[bot]"
-          commit_user_email: "github-actions[bot]@users.noreply.github.com"
-          commit_author: "github-actions[bot] <github-actions[bot]@users.noreply.github.com>"
   release:
     name: release
     if: ${{ github.ref == 'refs/heads/main' }}
     needs:
-      - docs
       - tests
     runs-on: ubuntu-latest
     steps:

lua/lazy/core/config.lua

@@ -7,12 +7,16 @@ local M = {}
 M.defaults = {
   root = vim.fn.stdpath("data") .. "/lazy", -- directory where plugins will be installed
   defaults = {
+    -- Set this to `true` to have all your plugins lazy-loaded by default.
+    -- Only do this if you know what you are doing, as it can lead to unexpected behavior.
     lazy = false, -- should plugins be lazy-loaded?
-    version = nil,
+    -- It's recommended to leave version=false for now, since a lot the plugin that support versioning,
+    -- have outdated releases, which may break your Neovim install.
+    version = nil, -- always use the latest git commit
+    -- version = "*", -- try installing the latest stable version for plugins that support semver
     -- default `cond` you can use to globally disable a lot of plugins
     -- when running inside vscode for example
     cond = nil, ---@type boolean|fun(self:LazyPlugin):boolean|nil
-    -- version = "*", -- enable this to try installing the latest stable versions of plugins
   },
   -- leave nil when passing the spec as the first argument to setup()
   spec = nil, ---@type LazySpec
@@ -31,6 +35,21 @@ M.defaults = {
     -- increase downloads a lot.
     filter = true,
   },
+  pkg = {
+    enabled = true,
+    cache = vim.fn.stdpath("state") .. "/lazy/pkg-cache.lua",
+    versions = true, -- Honor versions in pkg sources
+    -- the first package source that is found for a plugin will be used.
+    sources = {
+      "lazy",
+      "rockspec",
+      "packspec",
+    },
+  },
+  rocks = {
+    root = vim.fn.stdpath("data") .. "/lazy-rocks",
+    server = "https://nvim-neorocks.github.io/rocks-binaries/",
+  },
   dev = {
     ---@type string | fun(plugin: LazyPlugin): string directory where you store your local plugin projects
     path = "~/projects",
@@ -164,12 +183,6 @@ M.defaults = {
     skip_if_doc_exists = true,
   },
   state = vim.fn.stdpath("state") .. "/lazy/state.json", -- state info for checker and other things
-  build = {
-    -- Plugins can provide a `build.lua` file that will be executed when the plugin is installed
-    -- or updated. When the plugin spec also has a `build` command, the plugin's `build.lua` not be
-    -- executed. In this case, a warning message will be shown.
-    warn_on_override = true,
-  },
   -- Enable profiling of lazy.nvim. This will add some overhead,
   -- so only enable this when you are debugging lazy.nvim
   profiling = {
@@ -281,6 +294,18 @@ function M.setup(opts)
           require("lazy.manage.checker").start()
         end, 10)
       end
+
+      -- useful for plugin developers when making changes to a packspec file
+      vim.api.nvim_create_autocmd("BufWritePost", {
+        pattern = { "lazy.lua", "pkg.json", "*.rockspec" },
+        callback = function()
+          require("lazy").pkg({
+            plugins = {
+              require("lazy.core.plugin").find(vim.uv.cwd() .. "/lua/"),
+            },
+          })
+        end,
+      })
     end,
   })
 

lua/lazy/core/fragments.lua

@@ -0,0 +1,174 @@
+local Config = require("lazy.core.config")
+local Util = require("lazy.core.util")
+
+--- This class is used to manage the fragments of a plugin spec.
+--- It keeps track of the fragments and their relations to other fragments.
+--- A fragment can be a dependency (dependencies) or a child (specs) of another fragment.
+---@class LazyFragments
+---@field fragments table<number, LazyFragment>
+---@field frag_stack number[]
+---@field dep_stack number[]
+---@field dirty table<number, boolean>
+---@field plugins table<LazyPlugin, number>
+---@field spec LazySpecLoader
+local M = {}
+
+M._fid = 0
+
+local function next_id()
+  M._fid = M._fid + 1
+  return M._fid
+end
+
+---@param spec LazySpecLoader
+---@return LazyFragments
+function M.new(spec)
+  local self = setmetatable({}, { __index = M })
+  self.fragments = {}
+  self.frag_stack = {}
+  self.dep_stack = {}
+  self.spec = spec
+  self.dirty = {}
+  self.plugins = {}
+  return self
+end
+
+---@param id number
+function M:get(id)
+  return self.fragments[id]
+end
+
+--- Remove a fragment and all its children.
+--- This will also remove the fragment from its parent's children list.
+---@param id number
+function M:del(id)
+  -- del fragment
+  local fragment = self.fragments[id]
+  if not fragment then
+    return
+  end
+
+  self.dirty[id] = true
+
+  -- remove from parent
+  local pid = fragment.pid
+  if pid then
+    local parent = self.fragments[pid]
+    if parent.frags then
+      ---@param fid number
+      parent.frags = Util.filter(function(fid)
+        return fid ~= id
+      end, parent.frags)
+    end
+    if parent.deps then
+      ---@param fid number
+      parent.deps = Util.filter(function(fid)
+        return fid ~= id
+      end, parent.deps)
+    end
+    self.dirty[pid] = true
+  end
+
+  -- remove children
+  if fragment.frags then
+    for _, fid in ipairs(fragment.frags) do
+      self:del(fid)
+    end
+  end
+
+  self.fragments[id] = nil
+end
+
+--- Add a fragment to the fragments list.
+--- This also resolves its name, url, dir, dependencies and child specs.
+---@param plugin LazyPluginSpec
+function M:add(plugin)
+  if self.plugins[plugin] then
+    return self.fragments[self.plugins[plugin]]
+  end
+
+  local id = next_id()
+  setmetatable(plugin, nil)
+
+  self.plugins[plugin] = id
+
+  local pid = self.frag_stack[#self.frag_stack]
+
+  ---@type LazyFragment
+  local fragment = {
+    id = id,
+    pid = pid,
+    name = plugin.name,
+    url = plugin.url,
+    dir = plugin.dir,
+    spec = plugin --[[@as LazyPlugin]],
+  }
+
+  -- short url / ref
+  if plugin[1] then
+    local slash = plugin[1]:find("/", 1, true)
+    if slash then
+      local prefix = plugin[1]:sub(1, 4)
+      if prefix == "http" or prefix == "git@" then
+        fragment.url = fragment.url or plugin[1]
+      else
+        fragment.name = fragment.name or plugin[1]:sub(slash + 1)
+        fragment.url = fragment.url or Config.options.git.url_format:format(plugin[1])
+      end
+    else
+      fragment.name = fragment.name or plugin[1]
+    end
+  end
+
+  -- name
+  fragment.name = fragment.name
+    or fragment.url and self.spec.get_name(fragment.url)
+    or fragment.dir and self.spec.get_name(fragment.dir)
+  if not fragment.name then
+    return self.spec:error("Invalid plugin spec " .. vim.inspect(plugin))
+  end
+
+  if type(plugin.config) == "table" then
+    self.spec:warn(
+      "{" .. fragment.name .. "}: setting a table to `Plugin.config` is deprecated. Please use `Plugin.opts` instead"
+    )
+    ---@diagnostic disable-next-line: assign-type-mismatch
+    plugin.opts = plugin.config
+    plugin.config = nil
+  end
+
+  self.fragments[id] = fragment
+
+  -- add to parent
+  if pid then
+    local parent = self.fragments[pid]
+    parent.frags = parent.frags or {}
+    table.insert(parent.frags, id)
+  end
+
+  -- add to parent's deps
+  local did = self.dep_stack[#self.dep_stack]
+  if did and did == pid then
+    fragment.dep = true
+    local parent = self.fragments[did]
+    parent.deps = parent.deps or {}
+    table.insert(parent.deps, id)
+  end
+
+  table.insert(self.frag_stack, id)
+  -- dependencies
+  if plugin.dependencies then
+    table.insert(self.dep_stack, id)
+    self.spec:normalize(plugin.dependencies)
+    table.remove(self.dep_stack)
+  end
+  -- child specs
+  if plugin.specs then
+    self.spec:normalize(plugin.specs)
+  end
+  table.remove(self.frag_stack)
+
+  return fragment
+end
+
+return M

lua/lazy/core/loader.lua

@@ -44,6 +44,7 @@ function M.setup()
     while M.install_missing() do
       count = count + 1
       if count > 5 then
+        Util.error("Too many rounds of missing plugins")
         break
       end
     end
@@ -66,7 +67,10 @@ end
 -- multiple rounds can happen when importing a spec from a missing plugin
 function M.install_missing()
   for _, plugin in pairs(Config.plugins) do
-    if not (plugin._.installed or Plugin.has_errors(plugin)) then
+    local installed = plugin._.installed
+    local has_errors = Plugin.has_errors(plugin)
+
+    if not has_errors and not (installed and not plugin._.build) then
       for _, colorscheme in ipairs(Config.options.install.colorscheme) do
         if colorscheme == "default" then
           break
@@ -100,7 +104,7 @@ function M.startup()
   M.source(vim.env.VIMRUNTIME .. "/filetype.lua")
 
   -- backup original rtp
-  local rtp = vim.opt.rtp:get()
+  local rtp = vim.opt.rtp:get() --[[@as string[] ]]
 
   -- 1. run plugin init
   Util.track({ start = "init" })
@@ -131,15 +135,17 @@ function M.startup()
     if not path:find("after/?$") then
       -- these paths don't will already have their ftdetect ran,
       -- by sourcing filetype.lua above, so skip them
-      M.did_ftdetect[path] = true
+      M.did_ftdetect[path] = path
       M.packadd(path)
     end
   end
   Util.track()
 
   -- 4. load after plugins
   Util.track({ start = "after" })
-  for _, path in ipairs(vim.opt.rtp:get()) do
+  for _, path in
+    ipairs(vim.opt.rtp:get() --[[@as string[] ]])
+  do
     if path:find("after/?$") then
       M.source_runtime(path, "plugin")
     end
@@ -337,6 +343,10 @@ function M._load(plugin, reason, opts)
 
   M.add_to_rtp(plugin)
 
+  if plugin._.pkg and plugin._.pkg.source == "rockspec" then
+    M.add_to_luapath(plugin)
+  end
+
   if plugin.dependencies then
     Util.try(function()
       M.load(plugin.dependencies, {})
@@ -480,6 +490,15 @@ function M.add_to_rtp(plugin)
   vim.opt.rtp = rtp
 end
 
+---@param plugin LazyPlugin
+function M.add_to_luapath(plugin)
+  local root = Config.options.rocks.root .. "/" .. plugin.name
+  local path = root .. "/share/lua/5.1"
+  local cpath = root .. "/lib/lua/5.1"
+  package.path = package.path .. ";" .. path .. "/?.lua;" .. path .. "/?/init.lua;"
+  package.cpath = package.cpath .. ";" .. cpath .. "/?." .. (jit.os:find("Windows") and "dll" or "so") .. ";"
+end
+
 function M.source(path)
   Util.track({ runtime = path })
   Util.try(function()