From 8e3e30716d5ab7e28caa8473756283dea946072f Mon Sep 17 00:00:00 2001 From: foxora Date: Fri, 13 Feb 2026 17:34:05 +0000 Subject: [PATCH] not using lz.n --- .../neovim/lua/nixCatsUtils/lzUtils.lua | 135 ------------------ 1 file changed, 135 deletions(-) delete mode 100644 homes/modules/programs/neovim/lua/nixCatsUtils/lzUtils.lua diff --git a/homes/modules/programs/neovim/lua/nixCatsUtils/lzUtils.lua b/homes/modules/programs/neovim/lua/nixCatsUtils/lzUtils.lua deleted file mode 100644 index 0667276..0000000 --- a/homes/modules/programs/neovim/lua/nixCatsUtils/lzUtils.lua +++ /dev/null @@ -1,135 +0,0 @@ ---[[ - This directory is the luaUtils template. - You can choose what things from it that you would like to use. - And then delete the rest. - Everything in this directory is optional. ---]] - -local M = {} --- NOTE: This file contains 2 utilities for making good use of lze and lz.n with nixCats --- The function for loading after directories is useful for both plugins, and also for lazy loading without a plugin, --- but the custom handler will only work with lze. --- If you dont use these plugins, you probably don't need this file. - ----This function is useful for sourcing the after directories of lazily loaded plugins ----because vim.cmd.packadd does not do this for you. ---- ----This might be useful when doing lazy loading the vanilla way ----as well as when using plugins like lz.n for lazy loading ----It is primarily useful for lazily loading nvim-cmp sources, ----as they often rely on the after directory to work ---- ----Recieves the names of directories from a plugin's after directory ----that you wish to source files from. ----Will return a load function that can take a name, or list of names, ----and will load a plugin and its after directories. ----The function returned is a suitable substitute for the load field of a plugin spec. ---- ----Only makes sense for plugins added via optionalPlugins ----or some other opt directory on your packpath ---- ----e.g. in the following example: ----load_with_after_plugin will load the plugin names it is given, and their after/plugin dir ---- ----local load_with_after_plugin = require('nixCatsUtils').make_load_with_after({ 'plugin' }) ----load_with_after_plugin('some_plugin') ----@overload fun(dirs: string[]|string): fun(names: string|string[]) ----It also optionally recieves a function that should load a plugin and return its path ----for if the plugin is not on the packpath, or return nil ----to load from the packpath or nixCats list as normal ----@overload fun(dirs: string[]|string, load: fun(name: string):string|nil): fun(names: string|string[]) -function M.make_load_with_after(dirs, load) - dirs = (type(dirs) == "table" and dirs) or { dirs } - local fromPackpath = function(name) - for _, packpath in ipairs(vim.opt.packpath:get()) do - local plugin_path = vim.fn.globpath(packpath, "pack/*/opt/" .. name, nil, true, true) - if plugin_path[1] then - return plugin_path[1] - end - end - return nil - end - ---@param plugin_names string[]|string - return function(plugin_names) - local names = type(plugin_names) == "table" and plugin_names or { plugin_names } - local to_source = {} - for _, name in ipairs(names) do - if type(name) == "string" then - local path = (type(load) == "function" and load(name)) or nil - if type(path) == "string" then - table.insert(to_source, { name = name, path = path }) - else - local ok, err = pcall(vim.cmd.packadd, name) - if ok then - table.insert(to_source, { name = name, path = nil }) - else - vim.notify( - '"packadd ' - .. name - .. '" failed, and path provided by custom load function (if provided) was not a string\n' - .. err, - vim.log.levels.WARN, - { title = "nixCatsUtils.load_with_after" } - ) - end - end - else - vim.notify( - "plugin name was not a string and was instead of value:\n" .. vim.inspect(name), - vim.log.levels.WARN, - { title = "nixCatsUtils.load_with_after" } - ) - end - end - for _, info in pairs(to_source) do - local plugpath = info.path or vim.tbl_get(package.loaded, "nixCats", "pawsible", "allPlugins", "opt", info.name) or fromPackpath(info.name) - if type(plugpath) == "string" then - local afterpath = plugpath .. "/after" - for _, dir in ipairs(dirs) do - if vim.fn.isdirectory(afterpath) == 1 then - local plugin_dir = afterpath .. "/" .. dir - if vim.fn.isdirectory(plugin_dir) == 1 then - local files = vim.fn.glob(plugin_dir .. "/*", false, true) - for _, file in ipairs(files) do - if vim.fn.filereadable(file) == 1 then - vim.cmd("source " .. file) - end - end - end - end - end - end - end - end -end - --- A nixCats specific lze handler that you can use to conditionally enable by category easier. --- at the start of your config, register with --- require('lze').register_handlers(require('nixCatsUtils.lzUtils').for_cat) --- before any calls to require('lze').load using the handler have been made. --- accepts: --- for_cat = { "your" "cat" }; for_cat = { cat = { "your" "cat" }, default = bool } --- for_cat = "your.cat"; for_cat = { cat = "your.cat", default = bool } --- where default is an alternate value for when nixCats was NOT used to install the config -M.for_cat = { - spec_field = "for_cat", - set_lazy = false, - modify = function(plugin) - if type(plugin.for_cat) == "table" then - if plugin.for_cat.cat ~= nil then - if vim.g[ [[nixCats-special-rtp-entry-nixCats]] ] ~= nil then - plugin.enabled = (nixCats(plugin.for_cat.cat) and true) or false - else - plugin.enabled = nixCats(plugin.for_cat.default) - end - else - plugin.enabled = (nixCats(plugin.for_cat) and true) or false - end - else - plugin.enabled = (nixCats(plugin.for_cat) and true) or false - end - return plugin - end, -} - -return M