Add 'nixCatsUtils' from 'nixCats'

.config/nvim/lua/nixCatsUtils/catPacker.lua

@@ -0,0 +1,41 @@
+-- Source: https://github.com/BirdeeHub/nixCats-nvim/blob/main/templates/example/lua/nixCatsUtils/catPacker.lua
+--[[
+  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 function is for defining a paq.nvim fallback method of downloading plugins
+-- when nixCats was not used to install your config.
+-- If you only ever load your config using nixCats, you don't need this file.
+
+-- it literally just only runs it when not on nixCats
+-- all neovim package managers that use the regular plugin loading scheme
+-- can be used this way, just do whatever the plugin manager needs to put it in the
+-- opt directory for lazy loading, and add the build steps so that when theres no nix the steps are ran
+function M.setup(v)
+  if not vim.g[ [[nixCats-special-rtp-entry-nixCats]] ] then
+    local function clone_paq()
+      local path = vim.fn.stdpath("data") .. "/site/pack/paqs/start/paq-nvim"
+      local is_installed = vim.fn.empty(vim.fn.glob(path)) == 0
+      if not is_installed then
+        vim.fn.system({ "git", "clone", "--depth=1", "https://github.com/savq/paq-nvim.git", path })
+        return true
+      end
+    end
+    local function bootstrap_paq(packages)
+      local first_install = clone_paq()
+      vim.cmd.packadd("paq-nvim")
+      local paq = require("paq")
+      if first_install then
+        vim.notify("Installing plugins... If prompted, hit Enter to continue.")
+      end
+      paq(packages)
+      paq.install()
+    end
+    bootstrap_paq(vim.list_extend({ "savq/paq-nvim" }, v))
+  end
+end
+return M

.config/nvim/lua/nixCatsUtils/init.lua

@@ -0,0 +1,136 @@
+-- Source: https://github.com/BirdeeHub/nixCats-nvim/blob/main/templates/example/lua/nixCatsUtils/init.lua
+--[[
+  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 = {}
+
+--[[
+  This file is for making your config still work WITHOUT nixCats.
+  When you don't use nixCats to load your config,
+  you wont have the nixCats plugin.
+
+  The setup function defined here defines a mock nixCats plugin when nixCats wasnt used to load the config.
+  This will help avoid indexing errors when the nixCats plugin doesnt exist.
+
+  NOTE: If you only ever use nixCats to load your config, you don't need this file.
+--]]
+
+---@type boolean
+M.isNixCats = vim.g[ [[nixCats-special-rtp-entry-nixCats]] ] ~= nil
+
+---@class nixCatsSetupOpts
+---@field non_nix_value boolean|nil
+
+---This function will setup a mock nixCats plugin when not using nix
+---It will help prevent you from running into indexing errors without a nixCats plugin from nix.
+---If you loaded the config via nix, it does nothing
+---non_nix_value defaults to true if not provided or is not a boolean.
+---@param v nixCatsSetupOpts
+function M.setup(v)
+  if not M.isNixCats then
+    local nixCats_default_value
+    if type(v) == "table" and type(v.non_nix_value) == "boolean" then
+      nixCats_default_value = v.non_nix_value
+    else
+      nixCats_default_value = true
+    end
+    local mk_with_meta = function(tbl)
+      return setmetatable(tbl, {
+        __call = function(_, attrpath)
+          local strtable = {}
+          if type(attrpath) == "table" then
+            strtable = attrpath
+          elseif type(attrpath) == "string" then
+            for key in attrpath:gmatch("([^%.]+)") do
+              table.insert(strtable, key)
+            end
+          else
+            print("function requires a table of strings or a dot separated string")
+            return
+          end
+          return vim.tbl_get(tbl, unpack(strtable))
+        end,
+      })
+    end
+    package.preload["nixCats"] = function()
+      local ncsub = {
+        get = function(_)
+          return nixCats_default_value
+        end,
+        cats = mk_with_meta({
+          nixCats_config_location = vim.fn.stdpath("config"),
+          wrapRc = false,
+        }),
+        settings = mk_with_meta({
+          nixCats_config_location = vim.fn.stdpath("config"),
+          configDirName = os.getenv("NVIM_APPNAME") or "nvim",
+          wrapRc = false,
+        }),
+        petShop = mk_with_meta({}),
+        extra = mk_with_meta({}),
+        pawsible = mk_with_meta({
+          allPlugins = {
+            start = {},
+            opt = {},
+          },
+        }),
+        configDir = vim.fn.stdpath("config"),
+        packageBinPath = os.getenv("NVIM_WRAPPER_PATH_NIX") or vim.v.progpath,
+      }
+      return setmetatable(ncsub, {
+        __call = function(_, cat)
+          return ncsub.get(cat)
+        end,
+      })
+    end
+    _G.nixCats = require("nixCats")
+  end
+end
+
+---allows you to guarantee a boolean is returned, and also declare a different
+---default value than specified in setup when not using nix to load the config
+---@overload fun(v: string|string[]): boolean
+---@overload fun(v: string|string[], default: boolean): boolean
+function M.enableForCategory(v, default)
+  if M.isNixCats or default == nil then
+    if nixCats(v) then
+      return true
+    else
+      return false
+    end
+  else
+    return default
+  end
+end
+
+---if nix, return value of nixCats(v) else return default
+---Exists to specify a different non_nix_value than the one in setup()
+---@param v string|string[]
+---@param default any
+---@return any
+function M.getCatOrDefault(v, default)
+  if M.isNixCats then
+    return nixCats(v)
+  else
+    return default
+  end
+end
+
+---for conditionally disabling build steps on nix, as they are done via nix
+---I should probably have named it dontAddIfCats or something.
+---@overload fun(v: any): any|nil
+---Will return the second value if nix, otherwise the first
+---@overload fun(v: any, o: any): any
+function M.lazyAdd(v, o)
+  if M.isNixCats then
+    return o
+  else
+    return v
+  end
+end
+
+return M

.config/nvim/lua/nixCatsUtils/lzUtils.lua

@@ -0,0 +1,37 @@
+-- Source: https://github.com/BirdeeHub/nixCats-nvim/blob/main/templates/example/lua/nixCatsUtils/lzUtils.lua
+--[[
+  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 = {}
+-- 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" and plugin.for_cat.cat ~= nil then
+      if vim.g[ [[nixCats-special-rtp-entry-nixCats]] ] ~= nil then
+        plugin.enabled = nixCats(plugin.for_cat.cat) or false
+      else
+        plugin.enabled = plugin.for_cat.default
+      end
+    else
+      plugin.enabled = nixCats(plugin.for_cat) or false
+    end
+    return plugin
+  end,
+}
+
+return M