Is it possible to import subfolders with lzextras.mod_dir_to_spec?

[NovaViper]

Hey, I'm currently moving over some plugins, and I want to group them all under a folder like the example structure

nvim/lua/lazy
├── cmp
│   ├── blink.lua
│   └── blink-plugin-extension-example.lua
└── yazi.lua

Currently im importing the entire lazy directory with require("lze").load({ import = require("lzextras").mod_dir_to_spec("lazy")}). Is that something possible to do?

[BirdeeHub]

So, require("lzextras").mod_dir_to_spec("lazy") will make a list of specs.

You can put it in an import spec, or just pass it straight to lze.load

In that list of specs, it will create 1 import spec for each *.lua file in the lua/lazy directory.

It will also make an entry for each directory with an init.lua in it.

So, to import a subfolder, make the lua/lazy/yourfolder/init.lua return specs from another call to mod_dir_to_spec (and use its filter functionality to not include that "init" file in that list)

So, in the scenario where you do

require("lze").load(require("lzextras").mod_dir_to_spec("lazy"))

lua/lazy/cmp/init.lua would look like

return mod_dir_to_spec(..., function(name) return name ~= "init" end)

(the first argument of modules which have been called via require is the name used to require it, hence the ...)

There are actually quite a few ways to do it, but that is one of them.

Alternatively

require("lze").load({
  { import = require("lzextras").mod_dir_to_spec("lazy", function(name) return name ~= "cmp" end)) },
  { import = require("lzextras").mod_dir_to_spec("lazy.cmp") }
})

But, import just takes the name of something which can be required to receive specs, or 1 or more specs just like you might pass to lze.load, or a function which returns such specs when called with no arguments.

And lzextras.mod_dir_to_spec just finds all the things on the neovim runtimepath which are within a directory with that lua module name, and makes a list of import specs out of them.

Sorry, took me a few days to notice this one, I think I accidentally dismissed the notification for it or something.

The relevant source code for these is actually quite self-contained and easy to read.

Here is the parsing for the import spec in lze, in the file which defines the parse function it uses to normalize 1 or more specs to a list of specs with a name field, importing any import specs as it goes.

lze/lua/lze/c/parse.lua

Lines 11 to 60 in 7276233

	local function import_spec(spec, result)
	if is_disabled(spec) then
	return
	end
	local import_type = type(spec.import)
	if import_type == "table" then
	---@diagnostic disable-next-line: param-type-mismatch
	lib.normalize(spec.import, result)
	return
	elseif import_type == "function" then
	---@diagnostic disable-next-line: param-type-mismatch
	lib.normalize(spec.import(), result)
	return
	elseif import_type ~= "string" then
	vim.schedule(function()
	vim.notify(
	"Invalid import spec. The 'import' field should be a module name (or more specs, or a function that returns specs), but was instead of type `"
	.. import_type
	.. "`: "
	.. vim.inspect(spec),
	vim.log.levels.ERROR,
	{ title = "lze" }
	)
	end)
	return
	end
	local ok, mod = pcall(require, spec.import)
	if not ok then
	vim.schedule(function()
	local err = type(mod) == "string" and "': " .. mod or ""
	vim.notify(
	"Failed to load module '" .. tostring(spec.import) .. err,
	vim.log.levels.ERROR,
	{ title = "lze" }
	)
	end)
	return
	end
	if type(mod) ~= "table" then
	vim.schedule(function()
	vim.notify(
	"Invalid plugin spec module '" .. tostring(spec.import) .. "' of type '" .. type(mod) .. "'",
	vim.log.levels.ERROR,
	{ title = "lze" }
	)
	end)
	return
	end
	lib.normalize(mod, result)
	end

And in lzextras, the function mod_dir_to_spec is defined here. When you index into the main module from lzextras, it requires that from lzextras.src.<name> (and then stores the reference to it so it only calls that once)

https://github.com/BirdeeHub/lzextras/blob/master/lua/lzextras/src/mod_dir_to_spec.lua