dotfiles - My dotfiles. git clone https://git.oscarbenedito.com/dotfiles

About | Log | Files | Refs | License | Contribute

paq.lua (20418B) - raw

---

 -- This file is a modified version of paq-nvim (https://github.com/savq/paq-nvim),
 -- which has the following notice.
 -- Last update: 2023-11-06 (commit 07eb567dbb70044cabc622900b2bf755f7aecb99)
 
 -- MIT License
 --
 -- Copyright (c) 2020 Sergio Alejandro Vargas
 --
 -- Permission is hereby granted, free of charge, to any person obtaining a copy
 -- of this software and associated documentation files (the "Software"), to deal
 -- in the Software without restriction, including without limitation the rights
 -- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 -- copies of the Software, and to permit persons to whom the Software is
 -- furnished to do so, subject to the following conditions:
 --
 -- The above copyright notice and this permission notice shall be included in all
 -- copies or substantial portions of the Software.
 --
 -- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 -- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 -- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 -- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 -- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 -- SOFTWARE.
 
 -- VARS: {{{
 
 ---@alias Path string
 
 local uv = vim.loop
 
 ---@class setup_opts
 ---@field path Path
 ---@field opt boolean
 ---@field verbose boolean
 ---@field log Path
 ---@field lock Path
 ---@field url_format string
 ---@field clone_args string[]
 local Config = {
     path = vim.fn.stdpath("data") .. "/site/pack/paqs/",
     opt = false,
     verbose = false,
     url_format = "https://github.com/%s.git",
     log = vim.fn.stdpath(vim.fn.has("nvim-0.8") == 1 and "log" or "cache") .. "/paq.log",
     lock = vim.fn.stdpath("data") .. "/paq-lock.json",
     clone_args = { "--recurse-submodules", "--shallow-submodules", "--no-single-branch" }
 }
 
 ---@enum Messages
 local Messages = {
     install = { ok = "Installed", err = "Failed to install" },
     update = { ok = "Updated", err = "Failed to update", nop = "(up-to-date)" },
     remove = { ok = "Removed", err = "Failed to remove" },
     build = { ok = "Built", err = "Failed to build" },
 }
 
 local Lock = {}     -- Table of pgks loaded from the lockfile
 local Packages = {} -- Table of pkgs loaded from the user configuration
 
 ---@enum Status
 local Status = {
     INSTALLED = 0,
     CLONED = 1,
     UPDATED = 2,
     REMOVED = 3,
     TO_INSTALL = 4,
     TO_MOVE = 5,
     TO_RECLONE = 6,
 }
 
 -- stylua: ignore
 local Filter = {
     installed   = function(p) return p.status ~= Status.REMOVED and p.status ~= Status.TO_INSTALL end,
     not_removed = function(p) return p.status ~= Status.REMOVED end,
     removed     = function(p) return p.status == Status.REMOVED end,
     to_install  = function(p) return p.status == Status.TO_INSTALL end,
     to_update   = function(p) return p.status ~= Status.REMOVED and p.status ~= Status.TO_INSTALL and not p.pin end,
     to_move     = function(p) return p.status == Status.TO_MOVE end,
     to_reclone  = function(p) return p.status == Status.TO_RECLONE end,
 }
 
 -- Copy environment variables once. Doing it for every process seems overkill.
 local Env = {}
 for var, val in pairs(uv.os_environ()) do
     table.insert(Env, string.format("%s=%s", var, val))
 end
 table.insert(Env, "GIT_TERMINAL_PROMPT=0")
 
 -- }}}
 -- UTILS: {{{
 
 ---@return Package
 local function find_unlisted()
     local unlisted = {}
     -- TODO(breaking): Replace with `vim.fs.dir`
     for _, packdir in pairs { "start", "opt" } do
         local path = Config.path .. packdir
         local handle = uv.fs_scandir(path)
         while handle do
             local name, t = uv.fs_scandir_next(handle)
             if t == "directory" and name ~= "paq-nvim" then
                 local dir = path .. "/" .. name
                 local pkg = Packages[name]
                 if not pkg or pkg.dir ~= dir then
                     table.insert(unlisted, { name = name, dir = dir })
                 end
             elseif not name then
                 break
             end
         end
     end
     return unlisted
 end
 
 ---@param dir Path
 ---@return string
 local function get_git_hash(dir)
     local first_line = function(path)
         local file = io.open(path)
         if file then
             local line = file:read()
             file:close()
             return line
         end
     end
     local head_ref = first_line(dir .. "/.git/HEAD")
     return head_ref and first_line(dir .. "/.git/" .. head_ref:gsub("ref: ", ""))
 end
 
 ---@param process string
 ---@param args string[]
 ---@param cwd string?
 ---@param cb function
 ---@param print_stdout boolean?
 local function run(process, args, cwd, cb, print_stdout)
     local log = uv.fs_open(Config.log, "a+", 0x1A4)
     local stderr = uv.new_pipe(false)
     stderr:open(log)
     local handle, pid
     handle, pid = uv.spawn(
         process,
         { args = args, cwd = cwd, stdio = { nil, print_stdout and stderr, stderr }, env = Env },
         vim.schedule_wrap(function(code)
             uv.fs_close(log)
             stderr:close()
             handle:close()
             cb(code == 0)
         end)
     )
     if not handle then
         vim.notify(string.format(" Paq: Failed to spawn %s (%s)", process, pid))
     end
 end
 
 ---Return an interator that walks `dir` in post-order.
 ---@param dir Path
 local function walkdir(dir)
     return coroutine.wrap(function()
         local handle = uv.fs_scandir(dir)
         while handle do
             local name, t = uv.fs_scandir_next(handle)
             if not name then
                 return
             elseif t == "directory" then
                 for child, t in walkdir(dir .. "/" .. name) do
                     coroutine.yield(child, t)
                 end
             end
             coroutine.yield(dir .. "/" .. name, t)
         end
     end)
 end
 
 ---@param dir Path
 local function rmdir(dir)
     for name, t in walkdir(dir) do
         local ok = (t == "directory") and uv.fs_rmdir(name) or uv.fs_unlink(name)
         if not ok then
             return ok
         end
     end
     return uv.fs_rmdir(dir)
 end
 
 
 -- }}}
 -- LOGGING: {{{
 
 ---@param pkg Package
 ---@param prev_hash string
 ---@param cur_hash string
 local function log_update_changes(pkg, prev_hash, cur_hash)
     local output = { "\n\n" .. pkg.name .. " updated:\n" }
     local stdout = uv.new_pipe()
     local options = {
         args = { "log", "--pretty=format:* %s", prev_hash .. ".." .. cur_hash },
         cwd = pkg.dir,
         stdio = { nil, stdout, nil },
     }
     local handle
     handle, _ = uv.spawn("git", options, function(code)
         assert(code == 0, "Exited(" .. code .. ")")
         handle:close()
         local log = uv.fs_open(Config.log, "a+", 0x1A4)
         uv.fs_write(log, output, nil, nil)
         uv.fs_close(log)
     end)
     stdout:read_start(function(err, data)
         assert(not err, err)
         table.insert(output, data)
     end)
 end
 
 ---@param name string
 ---@param msg_op Messages
 ---@param result boolean
 ---@param n integer
 ---@param total integer
 local function report(name, msg_op, result, n, total)
     local count = n and string.format(" [%d/%d]", n, total) or ""
     vim.notify(
         string.format(" Paq:%s %s %s", count, msg_op[result], name),
         result == "err" and vim.log.levels.ERROR or vim.log.levels.INFO
     )
 end
 
 ---Object to track result of operations (installs, updates, etc.)
 ---@param total integer
 ---@param callback function
 local function new_counter(total, callback)
     return coroutine.wrap(function()
         local c = { ok = 0, err = 0, nop = 0 }
         while c.ok + c.err + c.nop < total do
             local name, msg_op, result = coroutine.yield(true)
             c[result] = c[result] + 1
             if result ~= "nop" or Config.verbose then
                 report(name, msg_op, result, c.ok + c.nop, total)
             end
         end
         callback(c.ok, c.err, c.nop)
         return true
     end)
 end
 
 
 -- }}}
 -- LOCKFILE: {{{
 
 local function lock_write()
     -- remove run key since can have a function in it, and
     -- json.encode doesn't support functions
     local pkgs = vim.deepcopy(Packages)
     for p, _ in pairs(pkgs) do
         pkgs[p].build = nil
     end
     local file = uv.fs_open(Config.lock, "w", 438)
     if file then
         local ok, result = pcall(vim.json.encode, pkgs)
         if not ok then
             error(result)
         end
         assert(uv.fs_write(file, result))
         assert(uv.fs_close(file))
     end
     Lock = Packages
 end
 
 local function lock_load()
     -- don't really know why 438 see ':h uv_fs_t'
     local file = uv.fs_open(Config.lock, "r", 438)
     if file then
         local stat = assert(uv.fs_fstat(file))
         local data = assert(uv.fs_read(file, stat.size, 0))
         assert(uv.fs_close(file))
         local ok, result = pcall(vim.json.decode, data)
         if ok then
             Lock = not vim.tbl_isempty(result) and result or Packages
             -- Repopulate 'build' key so 'vim.deep_equal' works
             for name, pkg in pairs(result) do
                 pkg.build = Packages[name] and Packages[name].build or nil
             end
         end
     else
         lock_write()
         Lock = Packages
     end
 end
 
 -- }}}
 -- PKGS: {{{
 
 ---@class Package
 ---@field name string
 ---@field as string
 ---@field branch string
 ---@field shallow boolean
 ---@field dir string
 ---@field status Status
 ---@field hash string
 ---@field pin boolean
 ---@field build string | function
 ---@field url string
 
 ---@param pkg Package
 ---@param counter function
 ---@param build_queue table
 local function clone(pkg, counter, build_queue)
     local args = vim.list_extend({ "clone", pkg.url }, Config.clone_args)
     if pkg.shallow then
         vim.list_extend(args, { "--depth=1" })
     end
     if pkg.branch then
         vim.list_extend(args, { "-b", pkg.branch })
     end
     table.insert(args, pkg.dir)
     run("git", args, nil, function(ok)
         if ok then
             pkg.status = Status.CLONED
             lock_write()
             if pkg.build then
                 table.insert(build_queue, pkg)
             end
         end
         counter(pkg.name, Messages.install, ok and "ok" or "err")
     end)
 end
 
 ---@param pkg Package
 ---@param counter function
 ---@param build_queue table
 local function pull(pkg, counter, build_queue)
     local prev_hash = Lock[pkg.name] and Lock[pkg.name].hash or pkg.hash
     run("git", { "pull", "--recurse-submodules", "--update-shallow" }, pkg.dir, function(ok)
         if not ok then
             counter(pkg.name, Messages.update, "err")
         else
             local cur_hash = pkg.hash
             if cur_hash ~= prev_hash then
                 log_update_changes(pkg, prev_hash, cur_hash)
                 pkg.status = Status.UPDATED
                 lock_write()
                 counter(pkg.name, Messages.update, "ok")
                 if pkg.build then
                     table.insert(build_queue, pkg)
                 end
             else
                 counter(pkg.name, Messages.update, "nop")
             end
         end
     end)
 end
 
 ---@param pkg Package
 ---@param counter function
 ---@param build_queue table
 local function clone_or_pull(pkg, counter, build_queue)
     if Filter.to_update(pkg) then
         pull(pkg, counter, build_queue)
     elseif Filter.to_install(pkg) then
         clone(pkg, counter, build_queue)
     end
 end
 
 ---Move package to wanted location.
 ---@param src Package
 ---@param dst Package
 local function move(src, dst)
     local ok = uv.fs_rename(src.dir, dst.dir)
     if ok then
         dst.status = Status.INSTALLED
         lock_write()
     end
 end
 
 ---@param pkg Package
 local function run_build(pkg)
     local t = type(pkg.build)
     if t == "function" then
         local ok = pcall(pkg.build)
         report(pkg.name, Messages.build, ok and "ok" or "err")
     elseif t == "string" and pkg.build:sub(1, 1) == ":" then
         local ok = pcall(vim.cmd, pkg.build)
         report(pkg.name, Messages.build, ok and "ok" or "err")
     elseif t == "string" then
         local args = {}
         for word in pkg.build:gmatch("%S+") do
             table.insert(args, word)
         end
         run(table.remove(args, 1), args, pkg.dir, function(ok)
             report(pkg.name, Messages.build, ok and "ok" or "err")
         end)
     end
 end
 
 ---@param pkg Package
 local function reclone(pkg, counter, build_queue)
     local ok = rmdir(pkg.dir)
     if not ok then
         return
     end
     local args = vim.list_extend({ "clone", pkg.url }, Config.clone_args)
     if pkg.branch then
         vim.list_extend(args, { "-b", pkg.branch })
     end
     table.insert(args, pkg.dir)
     run("git", args, nil, function(ok)
         if ok then
             pkg.status = Status.INSTALLED
             pkg.hash = get_git_hash(pkg.dir)
             lock_write()
             if pkg.build then
                 table.insert(build_queue, pkg)
             end
         end
     end)
 end
 
 local function resolve(pkg, counter, build_queue)
     if Filter.to_move(pkg) then
         move(pkg, Packages[pkg.name])
     elseif Filter.to_reclone(pkg) then
         reclone(Packages[pkg.name], counter, build_queue)
     end
 end
 
 ---@param pkg Package
 local function register(pkg)
     if type(pkg) == "string" then
         pkg = { pkg }
     end
     local url = pkg.url
         or (pkg[1]:match("^https?://") and pkg[1])                      -- [1] is a URL
         or string.format(Config.url_format, pkg[1])                     -- [1] is a repository name
     local name = pkg.as or url:gsub("%.git$", ""):match("/([%w-_.]+)$") -- Infer name from `url`
     if not name then
         return vim.notify(" Paq: Failed to parse " .. vim.inspect(pkg), vim.log.levels.ERROR)
     end
     local opt = pkg.opt or Config.opt and pkg.opt == nil
     local dir = Config.path .. (opt and "opt/" or "start/") .. name
     Packages[name] = {
         name = name,
         branch = pkg.branch,
         shallow = pkg.shallow == nil or pkg.shallow,
         dir = dir,
         status = uv.fs_stat(dir) and Status.INSTALLED or Status.TO_INSTALL,
         hash = get_git_hash(dir),
         pin = pkg.pin,
         build = pkg.build or pkg.run,
         url = url,
     }
     if pkg.run then
         vim.deprecate("`run` option", "`build`", "3.0", "Paq", false)
     end
 end
 
 ---@param pkg Package
 ---@param counter function
 local function remove(pkg, counter)
     local ok = rmdir(pkg.dir)
     counter(pkg.name, Messages.remove, ok and "ok" or "err")
     if ok then
         Packages[pkg.name] = { name = pkg.name, status = Status.REMOVED }
         lock_write()
     end
 end
 
 ---@alias Operation
 ---| '"install"'
 ---| '"update"'
 ---| '"remove"'
 ---| '"build"'
 ---| '"resolve"'
 ---| '"sync"'
 
 ---Boilerplate around operations (autocmds, counter initialization, etc.)
 ---@param op Operation
 ---@param fn function
 ---@param pkgs Package[]
 ---@param silent boolean?
 local function exe_op(op, fn, pkgs, silent)
     if #pkgs == 0 then
         if not silent then
             vim.notify(" Paq: Nothing to " .. op)
         end
         vim.cmd("doautocmd User PaqDone" .. op:gsub("^%l", string.upper))
         return
     end
 
     local build_queue = {}
 
     local function after(ok, err, nop)
         local summary = " Paq: %s complete. %d ok; %d errors;" .. (nop > 0 and " %d no-ops" or "")
         vim.notify(string.format(summary, op, ok, err, nop))
         vim.cmd("packloadall! | silent! helptags ALL")
         if #build_queue ~= 0 then
             exe_op("build", run_build, build_queue)
         end
         vim.cmd("doautocmd User PaqDone" .. op:gsub("^%l", string.upper))
     end
 
     local counter = new_counter(#pkgs, after)
     counter() -- Initialize counter
 
     for _, pkg in pairs(pkgs) do
         fn(pkg, counter, build_queue)
     end
 end
 
 -- }}}
 -- DIFFS: {{{
 
 local function diff_gather()
     local diffs = {}
     for name, lock_pkg in pairs(Lock) do
         local pack_pkg = Packages[name]
         if pack_pkg and Filter.not_removed(lock_pkg) and not vim.deep_equal(lock_pkg, pack_pkg) then
             for k, v in pairs {
                 dir = Status.TO_MOVE,
                 branch = Status.TO_RECLONE,
                 url = Status.TO_RECLONE,
             } do
                 if lock_pkg[k] ~= pack_pkg[k] then
                     lock_pkg.status = v
                     table.insert(diffs, lock_pkg)
                 end
             end
         end
     end
     return diffs
 end
 
 
 -- }}}
 -- PUBLIC API: {{{
 
 local paq = {}
 
 ---Installs all packages listed in your configuration. If a package is already
 ---installed, the function ignores it. If a package has a `build` argument,
 ---it'll be executed after the package is installed.
 function paq.install() exe_op("install", clone, vim.tbl_filter(Filter.to_install, Packages)) end
 
 ---Updates the installed packages listed in your configuration. If a package
 ---hasn't been installed with |PaqInstall|, the function ignores it. If a
 ---package had changes and it has a `build` argument, then the `build` argument
 ---will be executed.
 function paq.update() exe_op("update", pull, vim.tbl_filter(Filter.to_update, Packages)) end
 
 ---Removes packages found on |paq-dir| that aren't listed in your
 ---configuration.
 function paq.clean() exe_op("remove", remove, find_unlisted()) end
 
 ---Executes |paq.clean|, |paq.update|, and |paq.install|. Note that all
 ---paq operations are performed asynchronously, so messages might be printed
 ---out of order.
 function paq:sync()
     self:clean()
     exe_op("sync", clone_or_pull, vim.tbl_filter(Filter.not_removed, Packages))
 end
 
 ---@param opts setup_opts
 function paq:setup(opts)
     for k, v in pairs(opts) do
         Config[k] = v
     end
     return self
 end
 
 function paq.list()
     local installed = vim.tbl_filter(Filter.installed, Lock)
     local removed = vim.tbl_filter(Filter.removed, Lock)
     local function sort_by_name(t)
         table.sort(t, function(a, b) return a.name < b.name end)
     end
     sort_by_name(installed)
     sort_by_name(removed)
     local markers = { "+", "*" }
     for header, pkgs in pairs { ["Installed packages:"] = installed, ["Recently removed:"] = removed } do
         if #pkgs ~= 0 then
             print(header)
             for _, pkg in ipairs(pkgs) do
                 print(" ", markers[pkg.status] or " ", pkg.name)
             end
         end
     end
 end
 
 function paq.log_open() vim.cmd("sp " .. Config.log) end
 
 function paq.log_clean() return assert(uv.fs_unlink(Config.log)) and vim.notify(" Paq: log file deleted") end
 
 local meta = {}
 
 ---The `paq` module is itself a callable object. It takes as argument a list of
 ---packages. Each element of the list can be a table or a string.
 ---
 ---When the element is a table, the first value has to be a string with the
 ---name of the repository, like: `'<GitHub-username>/<repository-name>'`.
 ---The other key-value pairs in the table have to be named explicitly, see
 ---|paq-options|. When the element is a string, it works as if it was the first
 ---value of the table, and all other options will be set to their default
 ---values.
 ---
 ---Note: Lua can elide parentheses when passing a single table argument to a
 ---function, so you can always call `paq` without parentheses.
 ---See |luaref-langFuncCalls|.
 function meta:__call(pkgs)
     Packages = {}
     vim.tbl_map(register, pkgs)
     lock_load()
     exe_op("resolve", resolve, diff_gather(), true)
     return self
 end
 
 setmetatable(paq, meta)
 
 for cmd_name, fn in pairs {
     PaqInstall = paq.install,
     PaqUpdate = paq.update,
     PaqClean = paq.clean,
     PaqList = paq.list,
     PaqLogOpen = paq.log_open,
     PaqLogClean = paq.log_clean,
 }
 do
     vim.api.nvim_create_user_command(cmd_name, function(_) fn() end, { bar = true })
 end
 
 -- stylua: ignore
 do
     local build_cmd_opts = {
         bar = true,
         nargs = 1,
         complete = function() return vim.tbl_keys(vim.tbl_map(function(pkg) return pkg.build end, Packages)) end,
     }
     vim.api.nvim_create_user_command("PaqSync", function() paq:sync() end, { bar = true })
     vim.api.nvim_create_user_command("PaqBuild", function(a) run_build(Packages[a.args]) end, build_cmd_opts)
     vim.api.nvim_create_user_command("PaqRunHook", function(a)
         vim.deprecate("`PaqRunHook` command", "`PaqBuild`", "3.0", "Paq", false)
         run_build(Packages[a.args])
     end, build_cmd_opts)
 end
 
 return paq
 
 -- }}}
 -- vim: foldmethod=marker foldlevel=1