436 lines
12 KiB
Nix
436 lines
12 KiB
Nix
{
|
|
lib,
|
|
pkgs,
|
|
...
|
|
}:
|
|
|
|
let
|
|
mkOption = lib.mkOption;
|
|
types = lib.types;
|
|
|
|
vPlugFunctionType = types.mkOptionType {
|
|
name = "vPlugFunction";
|
|
description = "function taking vimPlugins and returning plugin or plugin list";
|
|
check = builtins.isFunction;
|
|
merge = lib.mergeOneOption;
|
|
};
|
|
|
|
keyBind = (
|
|
{ ... }:
|
|
|
|
{
|
|
options = {
|
|
bind = mkOption {
|
|
type = types.str;
|
|
default = "";
|
|
description = ''
|
|
The keys to bind.
|
|
'';
|
|
};
|
|
|
|
cmd = mkOption {
|
|
type = with types; nullOr str;
|
|
default = null;
|
|
description = ''
|
|
The command to execute. If this is a lua function set cmdIsFunction to true.
|
|
'';
|
|
};
|
|
|
|
cmdIsFunction = mkOption {
|
|
type = types.bool;
|
|
default = false;
|
|
description = ''
|
|
Needs to be set to true if cmd is a lua function.
|
|
'';
|
|
};
|
|
|
|
opts = mkOption {
|
|
type = with types; nullOr attrs;
|
|
default = null;
|
|
description = ''
|
|
Additional named parameters passed to the keybind function.
|
|
'';
|
|
};
|
|
};
|
|
}
|
|
);
|
|
|
|
plugin = (
|
|
{ ... }:
|
|
|
|
{
|
|
options = {
|
|
short = mkOption {
|
|
type = with types; nullOr str;
|
|
default = null;
|
|
description = ''
|
|
Short plugin url. (installation is handled by lazy.nvim)
|
|
'';
|
|
};
|
|
|
|
dir = mkOption {
|
|
type = types.nullOr (vPlugFunctionType);
|
|
default = null;
|
|
description = ''
|
|
A vim plugin package or a path pointing to a local plugin.
|
|
'';
|
|
};
|
|
|
|
url = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = ''
|
|
A custom git url where the plugin is hosted. (installation is handled by lazy.nvim)
|
|
'';
|
|
};
|
|
|
|
name = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = ''
|
|
A custom name for the plugin used for the local plugin directory and as the display name.
|
|
'';
|
|
};
|
|
|
|
dev = mkOption {
|
|
type = types.nullOr types.bool;
|
|
default = null;
|
|
description = ''
|
|
When `true`, a local plugin directory will be used instead. See config.dev.
|
|
'';
|
|
};
|
|
|
|
lazy = mkOption {
|
|
type = types.nullOr types.bool;
|
|
default = null;
|
|
description = ''
|
|
When `true`, the plugin will only be loaded when needed.
|
|
Lazy-loaded plugins are automatically loaded when their Lua modules are required,
|
|
or when one of the lazy-loading handlers trigger
|
|
'';
|
|
};
|
|
|
|
enabled = mkOption {
|
|
type =
|
|
with types;
|
|
nullOr (oneOf [
|
|
bool
|
|
str
|
|
]);
|
|
default = null;
|
|
description = ''
|
|
When false, or if the function returns false, then this plugin will not be included in the spec.
|
|
'';
|
|
};
|
|
|
|
cond = mkOption {
|
|
type =
|
|
with types;
|
|
nullOr (oneOf [
|
|
bool
|
|
str
|
|
]);
|
|
default = null;
|
|
description = ''
|
|
When false, or if the function returns false, then this plugin will not be loaded. Useful to disable some plugins in vscode, or firenvim for example.
|
|
'';
|
|
};
|
|
|
|
dependencies = mkOption {
|
|
type = types.nullOr (vPlugFunctionType);
|
|
default = null;
|
|
description = ''
|
|
A list of plugin names or plugin specs that should be loaded when the plugin loads.
|
|
Dependencies are always lazy-loaded unless specified otherwise.
|
|
When specifying a name, make sure the plugin spec has been defined somewhere else.
|
|
'';
|
|
};
|
|
|
|
init = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = ''init functions are always executed during startup'';
|
|
};
|
|
|
|
opts = mkOption {
|
|
type = types.nullOr types.attrs;
|
|
default = null;
|
|
description = ''
|
|
opts should be a table (will be merged with parent specs), return a table (replaces parent specs) or should change a table.
|
|
The table will be passed to the Plugin.config() function. Setting this value will imply Plugin.config()
|
|
'';
|
|
};
|
|
|
|
config = mkOption {
|
|
type =
|
|
with types;
|
|
nullOr (oneOf [
|
|
bool
|
|
str
|
|
]);
|
|
default = null;
|
|
description = ''
|
|
config is executed when the plugin loads.
|
|
The default implementation will automatically run require(MAIN).setup(opts).
|
|
Lazy uses several heuristics to determine the plugin's MAIN module automatically based on the plugin's name.
|
|
See also opts. To use the default implementation without opts set config to true.
|
|
'';
|
|
};
|
|
|
|
main = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = ''
|
|
You can specify the main module to use for config() and opts(), in case it can not be determined automatically. See config()
|
|
'';
|
|
};
|
|
|
|
build = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = ''
|
|
Build is executed when a plugin is installed or updated.
|
|
Before running build, a plugin is first loaded.
|
|
If it's a string it will be ran as a shell command.
|
|
When prefixed with : it is a Neovim command.
|
|
You can also specify a list to executed multiple build commands.
|
|
Some plugins provide their own build.lua which is automatically used by lazy.
|
|
So no need to specify a build step for those plugins.
|
|
'';
|
|
};
|
|
|
|
branch = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = ''
|
|
Branch of the repository
|
|
'';
|
|
};
|
|
|
|
tag = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = ''
|
|
Tag of the repository
|
|
'';
|
|
};
|
|
|
|
commit = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = ''
|
|
Commit of the repository
|
|
'';
|
|
};
|
|
|
|
version = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = ''
|
|
Version to use from the repository. Full Semver ranges are supported.
|
|
'';
|
|
};
|
|
|
|
pin = mkOption {
|
|
type = types.nullOr types.bool;
|
|
default = null;
|
|
description = ''
|
|
When true, this plugin will not be included in updates.
|
|
'';
|
|
};
|
|
|
|
submodules = mkOption {
|
|
type = types.nullOr types.bool;
|
|
default = null;
|
|
description = ''
|
|
When false, git submodules will not be fetched. Defaults to true if unset/null.
|
|
'';
|
|
};
|
|
|
|
event = mkOption {
|
|
type = with types; nullOr (listOf str);
|
|
default = null;
|
|
description = ''
|
|
Lazy-load on event. Events can be specified as BufEnter or with a pattern like BufEnter *.lua
|
|
'';
|
|
};
|
|
|
|
cmd = mkOption {
|
|
type = with types; nullOr (listOf str);
|
|
default = null;
|
|
description = ''
|
|
Lazy-load on command
|
|
'';
|
|
};
|
|
|
|
ft = mkOption {
|
|
type = with types; nullOr (listOf str);
|
|
default = null;
|
|
description = ''
|
|
Lazy-load on filetype
|
|
'';
|
|
};
|
|
|
|
keys = mkOption {
|
|
# TODO: update;
|
|
type = with types; nullOr (listOf (submodule keyBind));
|
|
default = null;
|
|
description = ''
|
|
Lazy-load on key mapping.
|
|
'';
|
|
};
|
|
|
|
module = mkOption {
|
|
type = types.nullOr types.bool;
|
|
default = null;
|
|
description = ''
|
|
Do not automatically load this Lua module when it's required somewhere
|
|
'';
|
|
};
|
|
|
|
priority = mkOption {
|
|
type = types.nullOr types.number;
|
|
default = null;
|
|
description = ''
|
|
Only useful for start plugins (lazy=false) to force loading certain plugins first. Default priority is 50. It's recommended to set this to a high number for colorschemes.
|
|
'';
|
|
};
|
|
|
|
optional = mkOption {
|
|
type = types.nullOr types.bool;
|
|
default = null;
|
|
description = ''
|
|
When a spec is tagged optional, it will only be included in the final spec, when the same plugin has been specified at least once somewhere else without optional.
|
|
This is mainly useful for Neovim distros, to allow setting options on plugins that may/may not be part of the user's plugins
|
|
'';
|
|
};
|
|
};
|
|
}
|
|
);
|
|
in
|
|
{
|
|
options.programs.nvim-lazy = {
|
|
enable = mkOption {
|
|
type = types.bool;
|
|
default = false;
|
|
description = ''
|
|
If set to true nvim will be installed with the plugins defined in programs.nvim-lazy.plugins.
|
|
'';
|
|
};
|
|
|
|
package = lib.mkPackageOption pkgs "neovim" {
|
|
default = "neovim-unwrapped";
|
|
};
|
|
|
|
finalPackage = mkOption {
|
|
type = types.package;
|
|
readOnly = true;
|
|
description = ''
|
|
Neovim wrapped.
|
|
'';
|
|
};
|
|
|
|
defaultEditor = mkOption {
|
|
type = types.bool;
|
|
default = false;
|
|
description = ''
|
|
Sets `EDITOR` environment variable to `nvim`.
|
|
'';
|
|
};
|
|
|
|
vPlug = mkOption {
|
|
type = with types; lazyAttrsOf anything;
|
|
default = pkgs.vimPlugins;
|
|
description = ''
|
|
The vimPlugins attrs to use.
|
|
'';
|
|
};
|
|
|
|
luaRcContent = mkOption {
|
|
type = types.str;
|
|
default = "";
|
|
};
|
|
|
|
# TODO: Map options from lazy.nvim
|
|
lazyConfig = mkOption {
|
|
type = types.attrs;
|
|
default = { };
|
|
description = ''
|
|
Lazy configuration. See: https://lazy.folke.io/configuration
|
|
'';
|
|
};
|
|
|
|
lazyPlugins = mkOption {
|
|
type =
|
|
with types;
|
|
listOf (oneOf [
|
|
str
|
|
(submodule plugin)
|
|
]);
|
|
default = [ ];
|
|
description = ''
|
|
List of plugins to be installed with neovim.
|
|
'';
|
|
};
|
|
|
|
viAlias = mkOption {
|
|
type = types.bool;
|
|
default = false;
|
|
description = ''
|
|
Add `vi` symlink to build output.
|
|
'';
|
|
};
|
|
|
|
vimAlias = mkOption {
|
|
type = types.bool;
|
|
default = false;
|
|
description = ''
|
|
Add `vim` symlink to build output.
|
|
'';
|
|
};
|
|
|
|
withNodeJs = mkOption {
|
|
type = types.bool;
|
|
default = false;
|
|
description = ''
|
|
Enable node support.
|
|
'';
|
|
};
|
|
|
|
withRuby = mkOption {
|
|
type = types.nullOr types.bool;
|
|
default = true;
|
|
description = ''
|
|
Enable ruby support.
|
|
'';
|
|
};
|
|
|
|
withPython3 = mkOption {
|
|
type = types.bool;
|
|
default = true;
|
|
description = ''
|
|
Enable Python 3 support.
|
|
'';
|
|
};
|
|
|
|
extraPython3Packages = mkOption {
|
|
type = with types; functionTo (listOf package);
|
|
default = _: [ ];
|
|
defaultText =
|
|
lib.literalExpression # nix
|
|
"_: [ ]";
|
|
description = ''
|
|
The Python 3 packages to add to the neovim environment.
|
|
Same usage as python3.withPackages.
|
|
'';
|
|
};
|
|
|
|
extraLuaPackages = mkOption {
|
|
type = with types; functionTo (listOf package);
|
|
default = _: [ ];
|
|
defaultText =
|
|
lib.literalExpression # nix
|
|
"_: [ ]";
|
|
};
|
|
};
|
|
}
|