dep/lua/dep.lua

local logger = require("dep.log")
local git = require("dep.git")
local fs = require("dep.fs")
local packager = require("dep.package")
local modules = require("dep.modules")
local bench = require("dep.bench")
local lazy = require("dep.lazy")
local ui = require("dep.ui")

-- all functions for convenience
local M = {}

-- TODO: maybe add the ability to get a lockfile? it's useful to make a config
-- rebuildable, but idk if it's actually useful for a neovim config
-- (look into how ofter people who use lazy.nvim us it)

--- sync a tree of plugins
---@param tree package[] tree of plugins
---@param cb function? callback
local function synctree(tree, cb)
  local progress = 0
  local has_errors = false

  local function done(err)
    progress = progress + 1
    has_errors = has_errors or err

    if progress == #tree then
      if has_errors then
        logger:log("error", "there were errors during sync; see :messages or :DepLog for more information")
      else
        logger:log("update", "synchronized %s %s", #tree, #tree == 1 and "package" or "packages")
      end

      fs:clean(packager)
      for _, package in pairs(tree) do
        package:reload()
      end

      if cb then
        cb()
      end
    end
  end

  for _, package in pairs(tree) do
    local co = coroutine.create(function()
      -- if the package provided prefers a local source then use the local
      -- source instead of the git repository
      if package.path then
        fs:sync(package, done)
      else
        git.sync(package, done)
      end
    end)
    coroutine.resume(co)
  end
end

--- check if a package should be synced
---@param opts table options
---@param package package package table spec
---@return boolean sync
local function shouldsync(opts, package)
  if opts.sync == "never" then
    return false
  elseif opts.sync == "new" or opts.sync == nil then
    return not package.exists
  else
    return opts.sync == "always"
  end
end

--- make comparison for table.sort
---@param a package package spec a
---@param b package package spec b
---@return boolean
local function comp(a, b)
  -- NOTE: this doesn't have to be in any real order, it just has to be
  -- consistant, thus we can just check if the unicode value of one package
  -- id is less than the other
  return a.id < b.id
end

-- basically the main function of our program
---@param opts speclist
return function(opts)
  M.config_path = debug.getinfo(2, "S").source:sub(2)
  logger.pipe = logger:setup()
  bench.setup()
  lazy.setup()

  -- generate doc tags
  vim.cmd.helptags(vim.fn.stdpath('data')..'/site/pack/deps/opt/dep/doc')

  local initialized, err = pcall(function()
    packager.set_base_dir(opts.base_dir or vim.fn.stdpath("data").."/site/pack/deps/opt/")
    bench.mark("load", function()
      -- register all packages
      local root = packager:new({
        "squibid/dep",
        url = "https://git.squi.bid/squibid/dep.git",
        branch = "lazy"
      })
      if not root then
        logger:log("error", "couldn't register root package")
        return
      end

      -- setup all packages and modules
      if opts.modules then
        modules:setup(opts, nil, M.config_path)
      end
      packager.register_speclist(opts)

      -- sort package dependencies
      for _, package in pairs(packager.get_packages()) do
        table.sort(package.requirements, comp)
        table.sort(package.dependents, comp)
      end

      -- make sure there arent any circular dependencies
      local ok = packager.findcycle(packager.get_packages())
      if type(ok) == "table" then
        logger:log("error", "found a cycle in the package spec here: %s", vim.inspect(ok))
      end
    end)

    -- load packages
    for _, package in pairs(packager.get_packages()) do
      package:reload()
    end

    -- get all package that need syncing
    local targets = {}
    for _, package in pairs(packager.get_packages()) do
      if shouldsync(opts, package) then
        table.insert(targets, package)
      end
    end

    -- install all targets
    synctree(targets)
  end)

  if not initialized then
    logger:log("error", err)
  end

  -- add some user commands
  vim.api.nvim_create_user_command("DepSync", function()
    synctree(packager.get_packages())
  end, {})

  vim.api.nvim_create_user_command("DepReload", function()
    for _, package in pairs(packager.get_packages()) do
      package:reload()
    end
  end, {})

  vim.api.nvim_create_user_command("DepClean", function()
    -- clean AND reload to make sure that all old packages are gone
    fs:clean(packager)
  end, {})

  vim.api.nvim_create_user_command("DepUi", function()
    ui.open(packager)
    ui.set_page("P")
  end, {})

  vim.api.nvim_create_user_command("DepLog", function()
    ui.open(packager)
    ui.set_page("L")
  end, {})

  logger:cleanup()
end