raf/neovim-flake
1
0
Fork 0
mirror of https://github.com/NotAShelf/neovim-flake.git synced 2025-01-07 07:49:49 +01:00
Code Issues Projects Releases Packages Wiki Activity

Merge e7cdd3c8a4 into 8febf44422

Browse source
This commit is contained in:
Ching Pei Yang 2025-01-01 09:48:20 +00:00 committed by GitHub
commit 7b21e10b88
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
32 changed files with 786 additions and 427 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
docs/release-notes/rl-0.8.md
View file

@ -19,6 +19,12 @@
- Add Haskell support under `vim.languages.haskell` using [haskell-tools.nvim].
[horriblename](https://github.com/horriblename):
[blink.cmp]: https://github.com/saghen/blink.cmp
- Add [blink.cmp] support
[diniamo](https://github.com/diniamo):
- Add Odin support under `vim.languages.odin`.

34
flake.lock
View file

@ -188,6 +188,38 @@
"type": "github"
}
},
"plugin-blink-cmp": {
"flake": false,
"locked": {
"lastModified": 1734880418,
"narHash": "sha256-jR9fvo+I51DKYQb+N3nFvQ50N+lvYzfFaQtrn7cxDu4=",
"owner": "saghen",
"repo": "blink.cmp",
"rev": "f93af0f486ada13e8c34f42c911788b9232b811f",
"type": "github"
},
"original": {
"owner": "saghen",
"repo": "blink.cmp",
"type": "github"
}
},
"plugin-blink-compat": {
"flake": false,
"locked": {
"lastModified": 1734896240,
"narHash": "sha256-Rrrh+O3FbBnaAnCHwPuQyfhH+XueSkQp6ipEkn6esGY=",
"owner": "saghen",
"repo": "blink.compat",
"rev": "74b251a1e9478c4fa6d7c6bc2921d7124e6f6cbb",
"type": "github"
},
"original": {
"owner": "saghen",
"repo": "blink.compat",
"type": "github"
}
},
"plugin-bufdelete-nvim": {
"flake": false,
"locked": {
@ -2092,6 +2124,8 @@
"nmd": "nmd",
"plugin-alpha-nvim": "plugin-alpha-nvim",
"plugin-base16": "plugin-base16",
"plugin-blink-cmp": "plugin-blink-cmp",
"plugin-blink-compat": "plugin-blink-compat",
"plugin-bufdelete-nvim": "plugin-bufdelete-nvim",
"plugin-catppuccin": "plugin-catppuccin",
"plugin-ccc": "plugin-ccc",

14
flake.nix
View file

@ -31,7 +31,7 @@
};
homeManagerModules = {
nvf = import ./flake/modules/home-manager.nix self.packages lib;
nvf = import ./flake/modules/home-manager.nix {inherit lib self;};
default = self.homeManagerModules.nvf;
neovim-flake =
lib.warn ''
@ -42,7 +42,7 @@
};
nixosModules = {
nvf = import ./flake/modules/nixos.nix self.packages lib;
nvf = import ./flake/modules/nixos.nix {inherit lib self;};
default = self.nixosModules.nvf;
neovim-flake =
lib.warn ''
@ -288,6 +288,16 @@
flake = false;
};
plugin-blink-cmp = {
url = "github:saghen/blink.cmp";
flake = false;
};
plugin-blink-compat = {
url = "github:saghen/blink.compat";
flake = false;
};
plugin-nvim-cmp = {
url = "github:hrsh7th/nvim-cmp";
flake = false;

24
flake/modules/home-manager.nix
View file

@ -1,22 +1,28 @@
# Home Manager module
packages: lib: {
{
self,
lib,
}: {
config,
pkgs,
...
}: let
inherit (self) packages inputs;
inherit (lib) maintainers;
inherit (lib.modules) mkIf mkAliasOptionModule;
inherit (lib.lists) optional;
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.types) attrsOf anything bool;
inherit (lib.nvim) neovimConfiguration;
inherit (lib.nvim.types) anythingConcatLists;
inherit (lib.types) anything bool submoduleWith;
cfg = config.programs.nvf;
neovimConfigured = neovimConfiguration {
inherit pkgs;
modules = [cfg.settings];
nvfModule = submoduleWith {
description = "Nvf module";
class = "nvf";
specialArgs = {
inherit pkgs lib inputs;
};
modules = import ../../modules/modules.nix {inherit pkgs lib;};
};
in {
imports = [
@ -55,7 +61,7 @@ in {
};
settings = mkOption {
type = attrsOf anythingConcatLists;
type = nvfModule;
default = {};
description = "Attribute set of nvf preferences.";
example = literalExpression ''
@ -78,7 +84,7 @@ in {
};
config = mkIf cfg.enable {
programs.nvf.finalPackage = neovimConfigured.neovim;
programs.nvf.finalPackage = cfg.settings.vim.build.finalPackage;
home = {
sessionVariables = mkIf cfg.defaultEditor {EDITOR = "nvim";};

24
flake/modules/nixos.nix
View file

@ -1,22 +1,28 @@
# NixOS module
packages: lib: {
{
self,
lib,
}: {
config,
pkgs,
...
}: let
inherit (self) inputs packages;
inherit (lib) maintainers;
inherit (lib.modules) mkIf mkOverride mkAliasOptionModule;
inherit (lib.lists) optional;
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.types) attrsOf anything bool;
inherit (lib.nvim) neovimConfiguration;
inherit (lib.nvim.types) anythingConcatLists;
inherit (lib.types) anything bool submoduleWith;
cfg = config.programs.nvf;
neovimConfigured = neovimConfiguration {
inherit pkgs;
modules = [cfg.settings];
nvfModule = submoduleWith {
description = "Nvf module";
class = "nvf";
specialArgs = {
inherit pkgs lib inputs;
};
modules = import ../../modules/modules.nix {inherit pkgs lib;};
};
in {
imports = [
@ -55,7 +61,7 @@ in {
};
settings = mkOption {
type = attrsOf anythingConcatLists;
type = nvfModule;
default = {};
description = "Attribute set of nvf preferences.";
example = literalExpression ''
@ -78,7 +84,7 @@ in {
};
config = mkIf cfg.enable {
programs.nvf.finalPackage = neovimConfigured.neovim;
programs.nvf.finalPackage = cfg.settings.vim.build.finalPackage;
environment = {
variables.EDITOR = mkIf cfg.defaultEditor (mkOverride 900 "nvim");

7
flake/packages.nix
View file

@ -6,6 +6,7 @@
...
}: let
docs = import ../docs {inherit pkgs inputs lib;};
pluginVersion = input: input.shortRev or input.shortDirtyRev or "dirty";
in {
packages = {
inherit (docs.manual) htmlOpenTool;
@ -66,6 +67,12 @@
Volumes = {"/home/neovim/demo" = {};};
};
};
# Plugins that need a compile step
blink-cmp = pkgs.callPackage ./packages/blink-cmp.nix {
src = inputs.plugin-blink-cmp;
version = pluginVersion inputs.plugin-blink-cmp;
};
};
};
}

38
flake/packages/blink-cmp.nix Normal file
View file

@ -0,0 +1,38 @@
{
rustPlatform,
hostPlatform,
src,
version,
vimUtils,
}: {
blink-cmp = let
inherit version src;
blink-fuzzy-lib = rustPlatform.buildRustPackage {
pname = "blink-fuzzy-lib";
inherit version src;
env = {
# TODO: remove this if plugin stops using nightly rust
RUSTC_BOOTSTRAP = true;
};
cargoLock = {
lockFile = "${src}/Cargo.lock";
outputHashes = {
"frizbee-0.1.0" = "sha256-pt6sMsRyjXrbrTK7t/YvWeen/n3nU8UUaiNYTY1LczE=";
};
};
};
libExt =
if hostPlatform.isDarwin
then "dylib"
else "so";
in
vimUtils.buildVimPlugin {
pname = "blink-cmp";
inherit version src;
preInstall = ''
mkdir -p target/release
ln -s ${blink-fuzzy-lib}/lib/libblink_cmp_fuzzy.${libExt} target/release/libblink_cmp_fuzzy.${libExt}
'';
};
}

55
lib/types/custom.nix
View file

@ -1,57 +1,8 @@
{lib}: let
inherit (lib.options) showOption showFiles getFiles mergeOneOption mergeEqualOption;
inherit (lib.strings) isString isStringLike;
inherit (lib.types) anything attrsOf listOf mkOptionType;
inherit (lib.nvim.types) anythingConcatLists;
inherit (builtins) typeOf isAttrs any head concatLists stringLength match;
inherit (lib.options) mergeEqualOption;
inherit (lib.strings) isString stringLength match;
inherit (lib.types) listOf mkOptionType;
in {
# HACK: Does this break anything in our case?
# A modified version of the nixpkgs anything type that concatenates lists
# This isn't the default because the order in which the lists are concatenated depends on the order in which the modules are imported,
# which makes it non-deterministic
anythingConcatLists =
anything
// {
merge = loc: defs: let
getType = value:
if isAttrs value && isStringLike value
then "stringCoercibleSet"
else typeOf value;
# Throw an error if not all defs have the same type
checkType = getType (head defs).value;
commonType =
if any (def: getType def.value != checkType) defs
then throw "The option `${showOption loc}' has conflicting option types in ${showFiles (getFiles defs)}"
else checkType;
mergeFunctions = {
# Recursively merge attribute sets
set = (attrsOf anythingConcatLists).merge;
# Overridden behavior for lists, that concatenates lists
list = _: defs: concatLists (map (e: e.value) defs);
# This means it's a package, only accept a single definition
stringCoercibleSet = mergeOneOption;
# This works by passing the argument to the functions,
# and merging their returns values instead
lambda = loc: defs: arg:
anythingConcatLists.merge
(loc ++ ["<function body>"])
(map (def: {
inherit (def) file;
value = def.value arg;
})
defs);
};
in
# Merge the defs with the correct function from above, if available
# otherwise only allow equal values
(mergeFunctions.${commonType} or mergeEqualOption) loc defs;
};
mergelessListOf = elemType: let
super = listOf elemType;
in

2
lib/types/default.nix
View file

@ -11,5 +11,5 @@ in {
inherit (typesDag) dagOf;
inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
inherit (typesLanguage) diagnostics mkGrammarOption;
inherit (customTypes) anythingConcatLists char hexColor mergelessListOf;
inherit (customTypes) char hexColor mergelessListOf;
}

105
modules/default.nix
View file

@ -9,9 +9,8 @@
extraModules ? [],
configuration ? {},
}: let
inherit (pkgs) vimPlugins;
inherit (lib.strings) isString toString;
inherit (lib.lists) filter map concatLists;
inherit (lib.strings) toString;
inherit (lib.lists) concatLists;
# import modules.nix with `check`, `pkgs` and `lib` as arguments
# check can be disabled while calling this file is called
@ -21,7 +20,12 @@
# evaluate the extended library with the modules
# optionally with any additional modules passed by the user
module = lib.evalModules {
specialArgs = extraSpecialArgs // {modulesPath = toString ./.;};
specialArgs =
extraSpecialArgs
// {
inherit inputs;
modulesPath = toString ./.;
};
modules = concatLists [
nvimModules
modules
@ -36,102 +40,11 @@
extraModules))
];
};
# alias to the internal configuration
vimOptions = module.config.vim;
noBuildPlug = {pname, ...} @ attrs: let
src = inputs."plugin-${attrs.pname}";
in
{
version = src.shortRev or src.shortDirtyRev or "dirty";
outPath = src;
passthru.vimPlugin = false;
}
// attrs;
# build a vim plugin with the given name and arguments
# if the plugin is nvim-treesitter, warn the user to use buildTreesitterPlug
# instead
buildPlug = attrs: let
src = inputs."plugin-${attrs.pname}";
in
pkgs.vimUtils.buildVimPlugin (
{
version = src.shortRev or src.shortDirtyRev or "dirty";
inherit src;
}
// attrs
);
buildTreesitterPlug = grammars: vimPlugins.nvim-treesitter.withPlugins (_: grammars);
pluginBuilders = {
nvim-treesitter = buildTreesitterPlug vimOptions.treesitter.grammars;
flutter-tools-patched = buildPlug {
pname = "flutter-tools";
patches = [../patches/flutter-tools.patch];
};
};
buildConfigPlugins = plugins:
map (
plug:
if (isString plug)
then pluginBuilders.${plug} or (noBuildPlug {pname = plug;})
else plug
) (filter (f: f != null) plugins);
# built (or "normalized") plugins that are modified
builtStartPlugins = buildConfigPlugins vimOptions.startPlugins;
builtOptPlugins = map (package: package // {optional = true;}) (buildConfigPlugins vimOptions.optPlugins);
# additional Lua and Python3 packages, mapped to their respective functions
# to conform to the format mnw expects. end user should
# only ever need to pass a list of packages, which are modified
# here
extraLuaPackages = ps: map (x: ps.${x}) vimOptions.luaPackages;
extraPython3Packages = ps: map (x: ps.${x}) vimOptions.python3Packages;
# Wrap the user's desired (unwrapped) Neovim package with arguments that'll be used to
# generate a wrapped Neovim package.
neovim-wrapped = inputs.mnw.lib.wrap pkgs {
neovim = vimOptions.package;
plugins = builtStartPlugins ++ builtOptPlugins;
appName = "nvf";
extraBinPath = vimOptions.extraPackages;
initLua = vimOptions.builtLuaConfigRC;
luaFiles = vimOptions.extraLuaFiles;
inherit (vimOptions) viAlias vimAlias withRuby withNodeJs withPython3;
inherit extraLuaPackages extraPython3Packages;
};
dummyInit = pkgs.writeText "nvf-init.lua" vimOptions.builtLuaConfigRC;
# Additional helper scripts for printing and displaying nvf configuration
# in your commandline.
printConfig = pkgs.writers.writeDashBin "nvf-print-config" "cat ${dummyInit}";
printConfigPath = pkgs.writers.writeDashBin "nvf-print-config-path" "echo -n ${dummyInit}";
in {
inherit (module) options config;
inherit (module._module.args) pkgs;
# Expose wrapped neovim-package for userspace
# or module consumption.
neovim = pkgs.symlinkJoin {
name = "nvf-with-helpers";
paths = [neovim-wrapped printConfig printConfigPath];
postBuild = "echo Helpers added";
# Allow evaluating vimOptions, i.e., config.vim from the packages' passthru
# attribute. For example, packages.x86_64-linux.neovim.passthru.neovimConfig
# will return the configuration in full.
passthru.neovimConfig = vimOptions;
meta =
neovim-wrapped.meta
// {
description = "Wrapped Neovim package with helper scripts to print the config (path)";
};
};
neovim = module.config.vim.build.finalPackage;
}

1
modules/modules.nix
View file

@ -49,6 +49,7 @@
# using the configuration passed in `neovim` and `plugins` modules.
wrapper = map (p: ./wrapper + "/${p}") [
"build"
"environment"
"rc"
"warnings"
"lazy"

4
modules/plugins/assistant/copilot/config.nix
View file

@ -58,8 +58,8 @@ in {
};
};
autocomplete.nvim-cmp = {
sources = {copilot = "[Copilot]";};
autocomplete = {
nvim-cmp.sources = {copilot = "[Copilot]";};
sourcePlugins = ["copilot-cmp"];
};

98
modules/plugins/completion/blink-cmp/blink-cmp.nix Normal file
View file

@ -0,0 +1,98 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption mkOption literalMD;
inherit (lib.types) listOf str either attrsOf submodule enum anything int nullOr;
inherit (lib.nvim.types) mkPluginSetupOption luaInline;
inherit (lib.nvim.binds) mkMappingOption;
inherit (lib.nvim.config) mkBool;
keymapType = submodule {
freeformType = attrsOf (listOf (either str luaInline));
options = {
preset = mkOption {
type = enum ["default" "none" "super-tab" "enter"];
default = "none";
description = "keymap presets";
};
};
};
providerType = submodule {
freeformType = anything;
options = {
module = mkOption {
type = str;
description = "module of the provider";
};
};
};
in {
options.vim.autocomplete.blink-cmp = {
enable = mkEnableOption "blink.cmp";
setupOpts = mkPluginSetupOption "blink.cmp" {
sources = {
default = mkOption {
type = listOf str;
default = ["lsp" "path" "snippets" "buffer"];
description = "Default list of sources to enable for completion.";
};
cmdline = mkOption {
type = nullOr (listOf str);
default = [];
description = "List of sources to enable for cmdline. Null means use default source list.";
};
providers = mkOption {
type = attrsOf providerType;
default = {};
description = "Providers";
};
};
completion = {
documentation = {
auto_show = mkBool true "Show documentation whenever an item is selected";
auto_show_delay_ms = mkOption {
type = int;
default = 200;
description = "Delay before auto show triggers";
};
};
};
keymap = mkOption {
type = keymapType;
default = {};
description = "blink.cmp keymap";
example = literalMD ''
```nix
vim.autocomplete.blink-cmp.setupOpts.keymap = {
preset = "none";
"<Up>" = ["select_prev" "fallback"];
"<C-n>" = [
(lib.generators.mkLuaInline ''''
function(cmp)
if some_condition then return end -- runs the next command
return true -- doesn't run the next command
end,
'''')
"select_next"
];
};
```
'';
};
};
mappings = {
complete = mkMappingOption "Complete [blink.cmp]" "<C-Space>";
confirm = mkMappingOption "Confirm [blink.cmp]" "<CR>";
next = mkMappingOption "Next item [blink.cmp]" "<Tab>";
previous = mkMappingOption "Previous item [blink.cmp]" "<S-Tab>";
close = mkMappingOption "Close [blink.cmp]" "<C-e>";
scrollDocsUp = mkMappingOption "Scroll docs up [blink.cmp]" "<C-d>";
scrollDocsDown = mkMappingOption "Scroll docs down [blink.cmp]" "<C-f>";
};
};
}

105
modules/plugins/completion/blink-cmp/config.nix Normal file
View file

@ -0,0 +1,105 @@
{
lib,
config,
...
}: let
inherit (lib.modules) mkIf mkDefault;
inherit (lib.strings) optionalString;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.lua) toLuaObject;
inherit (builtins) concatStringsSep typeOf tryEval attrNames mapAttrs;
cfg = config.vim.autocomplete.blink-cmp;
autocompleteCfg = config.vim.autocomplete;
inherit (cfg) mappings;
getPluginName = plugin:
if typeOf plugin == "string"
then plugin
else if (plugin ? pname && (tryEval plugin.pname).success)
then plugin.pname
else plugin.name;
in {
vim = mkIf cfg.enable {
startPlugins = ["blink-compat"];
lazy.plugins = {
blink-cmp = {
package = "blink-cmp";
setupModule = "blink.cmp";
inherit (cfg) setupOpts;
# TODO: lazy disabled until lspconfig is lazy loaded
#
# event = ["InsertEnter" "CmdlineEnter"];
after = ''
${optionalString config.vim.lazy.enable
(concatStringsSep "\n" (map
(package: "require('lz.n').trigger_load(${toLuaObject (getPluginName package)})")
autocompleteCfg.sourcePlugins))}
'';
};
};
autocomplete = {
enableSharedCmpSources = true;
blink-cmp.setupOpts = {
sources = {
default = ["lsp" "path" "snippets" "buffer"] ++ (attrNames autocompleteCfg.nvim-cmp.sources);
providers =
mapAttrs (name: _: {
inherit name;
module = "blink.compat.source";
})
autocompleteCfg.nvim-cmp.sources;
};
snippets = mkIf config.vim.snippets.luasnip.enable {
expand = mkLuaInline ''
function(snippet)
return require("luasnip").lsp_expand(snippet)
end
'';
active = mkLuaInline ''
function(filter)
if filter and filter.direction then
return require('luasnip').jumpable(filter.direction)
end
return require('luasnip').in_snippet()
end
'';
jump = mkLuaInline "function(direction) require('luasnip').jump(direction) end";
};
keymap = {
${mappings.complete} = ["show" "fallback"];
${mappings.close} = ["hide" "fallback"];
${mappings.scrollDocsUp} = ["scroll_documentation_up" "fallback"];
${mappings.scrollDocsDown} = ["scroll_documentation_down" "fallback"];
${mappings.confirm} = ["accept" "fallback"];
${mappings.next} = [
"select_next"
"snippet_forward"
(mkLuaInline ''
function(cmp)
local line, col = unpack(vim.api.nvim_win_get_cursor(0))
has_words_before = col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
if has_words_before then
return cmp.show()
end
end
'')
"fallback"
];
${mappings.previous} = [
"select_prev"
"snippet_backward"
"fallback"
];
};
};
};
};
}

3
modules/plugins/completion/blink-cmp/default.nix Normal file
View file

@ -0,0 +1,3 @@
{
imports = [./blink-cmp.nix ./config.nix];
}

34
modules/plugins/completion/config.nix Normal file
View file

@ -0,0 +1,34 @@
{
lib,
config,
...
}: let
inherit (builtins) typeOf tryEval;
inherit (lib.modules) mkIf;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.autocomplete;
getPluginName = plugin:
if typeOf plugin == "string"
then plugin
else if (plugin ? pname && (tryEval plugin.pname).success)
then plugin.pname
else plugin.name;
in {
vim = mkIf cfg.enableSharedCmpSources {
startPlugins = ["rtp-nvim"];
lazy.plugins =
mapListToAttrs (package: {
name = getPluginName package;
value = {
inherit package;
lazy = true;
after = ''
local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/${getPluginName package}')
require("rtp_nvim").source_after_plugin_dir(path)
'';
};
})
cfg.sourcePlugins;
};
}

4
modules/plugins/completion/default.nix
View file

@ -1,5 +1,9 @@
{
imports = [
./config.nix
./options.nix
./nvim-cmp
./blink-cmp
];
}

176
modules/plugins/completion/nvim-cmp/config.nix
View file

@ -3,16 +3,16 @@
config,
...
}: let
inherit (lib.modules) mkIf mkMerge;
inherit (lib.modules) mkIf;
inherit (lib.strings) optionalString;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (builtins) attrNames typeOf tryEval concatStringsSep;
borders = config.vim.ui.borders.plugins.nvim-cmp;
cfg = config.vim.autocomplete.nvim-cmp;
autocompleteCfg = config.vim.autocomplete;
luasnipEnable = config.vim.snippets.luasnip.enable;
getPluginName = plugin:
if typeOf plugin == "string"
@ -24,114 +24,102 @@
in {
config = mkIf cfg.enable {
vim = {
startPlugins = ["rtp-nvim"];
lazy.plugins = mkMerge [
(mapListToAttrs (package: {
name = getPluginName package;
value = {
inherit package;
lazy = true;
after = ''
local path = vim.fn.globpath(vim.o.packpath, 'pack/*/opt/${getPluginName package}')
require("rtp_nvim").source_after_plugin_dir(path)
'';
};
})
cfg.sourcePlugins)
{
nvim-cmp = {
package = "nvim-cmp";
after = ''
${optionalString luasnipEnable "local luasnip = require('luasnip')"}
local cmp = require("cmp")
lazy.plugins = {
nvim-cmp = {
package = "nvim-cmp";
after = ''
${optionalString luasnipEnable "local luasnip = require('luasnip')"}
local cmp = require("cmp")
local kinds = require("cmp.types").lsp.CompletionItemKind
local deprio = function(kind)
return function(e1, e2)
if e1:get_kind() == kind then
return false
end
if e2:get_kind() == kind then
return true
end
return nil
local kinds = require("cmp.types").lsp.CompletionItemKind
local deprio = function(kind)
return function(e1, e2)
if e1:get_kind() == kind then
return false
end
if e2:get_kind() == kind then
return true
end
return nil
end
end
cmp.setup(${toLuaObject cfg.setupOpts})
cmp.setup(${toLuaObject cfg.setupOpts})
${optionalString config.vim.lazy.enable
(concatStringsSep "\n" (map
(package: "require('lz.n').trigger_load(${toLuaObject (getPluginName package)})")
cfg.sourcePlugins))}
'';
${optionalString config.vim.lazy.enable
(concatStringsSep "\n" (map
(package: "require('lz.n').trigger_load(${toLuaObject (getPluginName package)})")
autocompleteCfg.sourcePlugins))}
'';
event = ["InsertEnter" "CmdlineEnter"];
};
}
];
autocomplete.nvim-cmp = {
sources = {
nvim-cmp = null;
buffer = "[Buffer]";
path = "[Path]";
event = ["InsertEnter" "CmdlineEnter"];
};
};
autocomplete = {
enableSharedCmpSources = true;
sourcePlugins = ["cmp-buffer" "cmp-path"];
setupOpts = {
sources = map (s: {name = s;}) (attrNames cfg.sources);
window = mkIf borders.enable {
completion.border = borders.style;
documentation.border = borders.style;
nvim-cmp = {
sources = {
nvim-cmp = null;
buffer = "[Buffer]";
path = "[Path]";
};
formatting.format = cfg.format;
setupOpts = {
sources = map (s: {name = s;}) (attrNames cfg.sources);
# `cmp` and `luasnip` are defined above, in the `nvim-cmp` section
mapping = {
${mappings.complete} = mkLuaInline "cmp.mapping.complete()";
${mappings.close} = mkLuaInline "cmp.mapping.abort()";
${mappings.scrollDocsUp} = mkLuaInline "cmp.mapping.scroll_docs(-4)";
${mappings.scrollDocsDown} = mkLuaInline "cmp.mapping.scroll_docs(4)";
${mappings.confirm} = mkLuaInline "cmp.mapping.confirm({ select = true })";
window = mkIf borders.enable {
completion.border = borders.style;
documentation.border = borders.style;
};
${mappings.next} = mkLuaInline ''
cmp.mapping(function(fallback)
local has_words_before = function()
local line, col = unpack(vim.api.nvim_win_get_cursor(0))
return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
end
formatting.format = cfg.format;
if cmp.visible() then
cmp.select_next_item()
${optionalString luasnipEnable ''
elseif luasnip.locally_jumpable(1) then
luasnip.jump(1)
''}
elseif has_words_before() then
cmp.complete()
else
fallback()
end
end)
'';
# `cmp` and `luasnip` are defined above, in the `nvim-cmp` section
mapping = {
${mappings.complete} = mkLuaInline "cmp.mapping.complete()";
${mappings.close} = mkLuaInline "cmp.mapping.abort()";
${mappings.scrollDocsUp} = mkLuaInline "cmp.mapping.scroll_docs(-4)";
${mappings.scrollDocsDown} = mkLuaInline "cmp.mapping.scroll_docs(4)";
${mappings.confirm} = mkLuaInline "cmp.mapping.confirm({ select = true })";
${mappings.previous} = mkLuaInline ''
cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_prev_item()
${optionalString luasnipEnable ''
elseif luasnip.locally_jumpable(-1) then
luasnip.jump(-1)
''}
else
fallback()
end
end)
'';
${mappings.next} = mkLuaInline ''
cmp.mapping(function(fallback)
local has_words_before = function()
local line, col = unpack(vim.api.nvim_win_get_cursor(0))
return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
end
if cmp.visible() then
cmp.select_next_item()
${optionalString luasnipEnable ''
elseif luasnip.locally_jumpable(1) then
luasnip.jump(1)
''}
elseif has_words_before() then
cmp.complete()
else
fallback()
end
end)
'';
${mappings.previous} = mkLuaInline ''
cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_prev_item()
${optionalString luasnipEnable ''
elseif luasnip.locally_jumpable(-1) then
luasnip.jump(-1)
''}
else
fallback()
end
end)
'';
};
};
};
};

10
modules/plugins/completion/nvim-cmp/nvim-cmp.nix
View file

@ -4,10 +4,10 @@
...
}: let
inherit (lib.options) mkEnableOption mkOption literalExpression literalMD;
inherit (lib.types) str attrsOf nullOr either listOf;
inherit (lib.types) str attrsOf nullOr either;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.binds) mkMappingOption;
inherit (lib.nvim.types) mkPluginSetupOption luaInline mergelessListOf pluginType;
inherit (lib.nvim.types) mkPluginSetupOption luaInline mergelessListOf;
inherit (lib.nvim.lua) toLuaObject;
inherit (builtins) isString;
@ -107,11 +107,5 @@ in {
}
'';
};
sourcePlugins = mkOption {
type = listOf pluginType;
default = [];
description = "List of source plugins used by nvim-cmp.";
};
};
}

15
modules/plugins/completion/options.nix Normal file
View file

@ -0,0 +1,15 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) listOf;
inherit (lib.nvim.types) pluginType;
in {
options.vim.autocomplete = {
enableSharedCmpSources = mkEnableOption "cmp sources shared by nvim-cmp and blink.cmp";
sourcePlugins = mkOption {
type = listOf pluginType;
default = [];
description = "List of cmp source plugins.";
};
};
}

9
modules/plugins/lsp/config.nix
View file

@ -11,6 +11,7 @@
cfg = config.vim.lsp;
usingNvimCmp = config.vim.autocomplete.nvim-cmp.enable;
usingBlinkCmp = config.vim.autocomplete.blink-cmp.enable;
self = import ./module.nix {inherit config lib pkgs;};
mappingDefinitions = self.options.vim.lsp.mappings;
@ -22,8 +23,8 @@
in {
config = mkIf cfg.enable {
vim = {
autocomplete.nvim-cmp = {
sources = {nvim_lsp = "[LSP]";};
autocomplete = mkIf usingNvimCmp {
nvim-cmp.sources = {nvim_lsp = "[LSP]";};
sourcePlugins = ["cmp-nvim-lsp"];
};
@ -170,6 +171,10 @@ in {
},
}
''}
${optionalString usingBlinkCmp ''
capabilities = require('blink.cmp').get_lsp_capabilities()
''}
'';
};
};

10
modules/plugins/lsp/lsp-signature/config.nix
View file

@ -10,6 +10,16 @@
cfg = config.vim.lsp;
in {
config = mkIf (cfg.enable && cfg.lspSignature.enable) {
assertions = [
{
assertion = !config.vim.autocomplete.blink-cmp.enable;
message = ''
lsp-signature does not work with blink.cmp. Please use blink.cmp's builtin signature feature:
vim.autocomplete.blink-cmp.setupOpts.signature.enabled = true;
'';
}
];
vim = {
startPlugins = [
"lsp-signature"

3
modules/plugins/lsp/lspkind/config.nix
View file

@ -8,11 +8,12 @@
inherit (lib.nvim.lua) toLuaObject;
cfg = config.vim.lsp.lspkind;
inherit (config.vim) autocomplete;
in {
config = mkIf cfg.enable {
assertions = [
{
assertion = config.vim.autocomplete.nvim-cmp.enable;
assertion = autocomplete.nvim-cmp.enable || autocomplete.blink-cmp.enable;
message = ''
While lspkind supports Neovim's native lsp upstream, using that over
nvim-cmp isn't recommended, nor supported by nvf.

2
modules/plugins/notes/obsidian/obsidian.nix
View file

@ -48,7 +48,7 @@ in {
# If using nvim-cmp, otherwise set to false
type = bool;
description = "If using nvim-cmp, otherwise set to false";
default = config.vim.autocomplete.nvim-cmp.enable;
default = config.vim.autocomplete.enableSharedCmpSources;
};
};
};

4
modules/plugins/snippets/luasnip/config.nix
View file

@ -17,8 +17,8 @@ in {
};
};
startPlugins = cfg.providers;
autocomplete.nvim-cmp = {
sources = {luasnip = "[LuaSnip]";};
autocomplete = {
nvim-cmp.sources = {luasnip = "[LuaSnip]";};
sourcePlugins = ["cmp-luasnip"];
};
};

5
modules/plugins/treesitter/config.nix
View file

@ -20,8 +20,9 @@ in {
vim = {
startPlugins = ["nvim-treesitter"];
autocomplete.nvim-cmp = {
sources = {treesitter = "[Treesitter]";};
# cmp-treesitter doesn't work on blink.cmp
autocomplete = mkIf config.vim.autocomplete.nvim-cmp.enable {
nvim-cmp.sources = {treesitter = "[Treesitter]";};
sourcePlugins = ["cmp-treesitter"];
};

110
modules/wrapper/build/config.nix
View file

@ -1,13 +1,111 @@
{
config,
inputs,
lib,
config,
pkgs,
...
}: let
inherit (lib.attrsets) attrValues;
}
: let
inherit (pkgs) vimPlugins;
inherit (lib.strings) isString;
inherit (lib.lists) filter map;
cfg = config.vim;
# alias to the internal configuration
vimOptions = config.vim;
noBuildPlug = {pname, ...} @ attrs: let
src = inputs."plugin-${attrs.pname}";
in
{
version = src.shortRev or src.shortDirtyRev or "dirty";
outPath = src;
passthru.vimPlugin = false;
}
// attrs;
# build a vim plugin with the given name and arguments
# if the plugin is nvim-treesitter, warn the user to use buildTreesitterPlug
# instead
buildPlug = attrs: let
src = inputs."plugin-${attrs.pname}";
in
pkgs.vimUtils.buildVimPlugin (
{
version = src.shortRev or src.shortDirtyRev or "dirty";
inherit src;
}
// attrs
);
buildTreesitterPlug = grammars: vimPlugins.nvim-treesitter.withPlugins (_: grammars);
pluginBuilders = {
nvim-treesitter = buildTreesitterPlug vimOptions.treesitter.grammars;
flutter-tools-patched = buildPlug {
pname = "flutter-tools";
patches = [../patches/flutter-tools.patch];
};
};
buildConfigPlugins = plugins:
map (
plug:
if (isString plug)
then pluginBuilders.${plug} or (noBuildPlug {pname = plug;})
else plug
) (filter (f: f != null) plugins);
# built (or "normalized") plugins that are modified
builtStartPlugins = buildConfigPlugins vimOptions.startPlugins;
builtOptPlugins = map (package: package // {optional = true;}) (buildConfigPlugins vimOptions.optPlugins);
# additional Lua and Python3 packages, mapped to their respective functions
# to conform to the format mnw expects. end user should
# only ever need to pass a list of packages, which are modified
# here
extraLuaPackages = ps: map (x: ps.${x}) vimOptions.luaPackages;
extraPython3Packages = ps: map (x: ps.${x}) vimOptions.python3Packages;
# Wrap the user's desired (unwrapped) Neovim package with arguments that'll be used to
# generate a wrapped Neovim package.
neovim-wrapped = inputs.mnw.lib.wrap pkgs {
neovim = vimOptions.package;
plugins = builtStartPlugins ++ builtOptPlugins;
appName = "nvf";
extraBinPath = vimOptions.extraPackages;
initLua = vimOptions.builtLuaConfigRC;
luaFiles = vimOptions.extraLuaFiles;
inherit (vimOptions) viAlias vimAlias withRuby withNodeJs withPython3;
inherit extraLuaPackages extraPython3Packages;
};
dummyInit = pkgs.writeText "nvf-init.lua" vimOptions.builtLuaConfigRC;
# Additional helper scripts for printing and displaying nvf configuration
# in your commandline.
printConfig = pkgs.writers.writeDashBin "nvf-print-config" "cat ${dummyInit}";
printConfigPath = pkgs.writers.writeDashBin "nvf-print-config-path" "echo -n ${dummyInit}";
# Expose wrapped neovim-package for userspace
# or module consumption.
neovim = pkgs.symlinkJoin {
name = "nvf-with-helpers";
paths = [neovim-wrapped printConfig printConfigPath];
postBuild = "echo Helpers added";
# Allow evaluating vimOptions, i.e., config.vim from the packages' passthru
# attribute. For example, packages.x86_64-linux.neovim.passthru.neovimConfig
# will return the configuration in full.
passthru.neovimConfig = vimOptions;
meta =
neovim-wrapped.meta
// {
description = "Wrapped Neovim package with helper scripts to print the config (path)";
};
};
in {
config = {
vim.startPlugins = map (x: x.package) (attrValues cfg.extraPlugins);
config.vim.build = {
finalPackage = neovim;
};
}

2
modules/wrapper/build/default.nix
View file

@ -1,6 +1,6 @@
{
imports = [
./config.nix
./options.nix
./config.nix
];
}

146
modules/wrapper/build/options.nix
View file

@ -1,144 +1,12 @@
{
pkgs,
lib,
...
}: let
inherit (lib.options) mkOption mkEnableOption literalMD;
inherit (lib.types) package bool str listOf attrsOf;
inherit (lib.nvim.types) pluginsOpt extraPluginType;
{lib, ...}: let
inherit (lib.types) package;
inherit (lib.options) mkOption;
in {
options.vim = {
package = mkOption {
options.vim.build = {
finalPackage = mkOption {
type = package;
default = pkgs.neovim-unwrapped;
description = ''
The neovim package to use for the wrapper. This
corresponds to the package that will be wrapped
with your plugins and settings.
::: {.warning}
You will need to use an unwrapped package for this
option to work as intended. Using an already wrapped
package here may yield undesirable results.
:::
'';
};
viAlias = mkOption {
type = bool;
default = true;
description = "Enable the `vi` alias for `nvim`";
};
vimAlias = mkOption {
type = bool;
default = true;
description = "Enable the `vim` alias for `nvim`";
};
startPlugins = pluginsOpt {
default = ["plenary-nvim"];
example = ''
[pkgs.vimPlugins.telescope-nvim]
'';
description = ''
List of plugins to load on startup. This is used
internally to add plugins to Neovim's runtime.
To add additional plugins to your configuration, consider
using the [{option}`vim.extraPlugins`](#opt-vim.extraPlugins)
option.
'';
};
optPlugins = pluginsOpt {
default = [];
example = ''
[pkgs.vimPlugins.vim-ghost]
'';
description = ''
List of plugins to optionally load on startup.
This option has the same type definition as {option}`vim.startPlugins`
and plugins in this list are appended to {option}`vim.startPlugins` by
the wrapper during the build process.
To avoid overriding packages and dependencies provided by startPlugins, you
are recommended to use this option or {option}`vim.extraPlugins` option.
'';
};
extraPlugins = mkOption {
type = attrsOf extraPluginType;
default = {};
description = ''
A list of plugins and their configurations that will be
set up after builtin plugins.
This option takes a special type that allows you to order
your custom plugins using nvf's modified DAG library.
'';
example = literalMD ''
```nix
with pkgs.vimPlugins; {
aerial = {
package = aerial-nvim;
setup = "require('aerial').setup {}";
};
harpoon = {
package = harpoon;
setup = "require('harpoon').setup {}";
after = ["aerial"]; # place harpoon configuration after aerial
};
}
```
'';
};
extraPackages = mkOption {
type = listOf package;
default = [];
example = ''[pkgs.fzf pkgs.ripgrep]'';
description = ''
List of additional packages to make available to the Neovim
wrapper.
'';
};
# this defaults to `true` in the wrapper
# and since we pass this value to the wrapper
# with an inherit, it should be `true` here as well
withRuby =
mkEnableOption ''
Ruby support in the Neovim wrapper.
''
// {
default = true;
};
withNodeJs = mkEnableOption ''
NodeJs support in the Neovim wrapper
'';
luaPackages = mkOption {
type = listOf str;
default = [];
example = ''["magick" "serpent"]'';
description = "List of lua packages to install";
};
withPython3 = mkEnableOption ''
Python3 support in the Neovim wrapper
'';
python3Packages = mkOption {
type = listOf str;
default = [];
example = ''["pynvim"]'';
description = "List of python packages to install";
readOnly = true;
description = "final output package";
};
};
}

13
modules/wrapper/environment/config.nix Normal file
View file

@ -0,0 +1,13 @@
{
config,
lib,
...
}: let
inherit (lib.attrsets) attrValues;
cfg = config.vim;
in {
config = {
vim.startPlugins = map (x: x.package) (attrValues cfg.extraPlugins);
};
}

6
modules/wrapper/environment/default.nix Normal file
View file

@ -0,0 +1,6 @@
{
imports = [
./config.nix
./options.nix
];
}

144
modules/wrapper/environment/options.nix Normal file
View file

@ -0,0 +1,144 @@
{
pkgs,
lib,
...
}: let
inherit (lib.options) mkOption mkEnableOption literalMD;
inherit (lib.types) package bool str listOf attrsOf;
inherit (lib.nvim.types) pluginsOpt extraPluginType;
in {
options.vim = {
package = mkOption {
type = package;
default = pkgs.neovim-unwrapped;
description = ''
The neovim package to use for the wrapper. This
corresponds to the package that will be wrapped
with your plugins and settings.
::: {.warning}
You will need to use an unwrapped package for this
option to work as intended. Using an already wrapped
package here may yield undesirable results.
:::
'';
};
viAlias = mkOption {
type = bool;
default = true;
description = "Enable the `vi` alias for `nvim`";
};
vimAlias = mkOption {
type = bool;
default = true;
description = "Enable the `vim` alias for `nvim`";
};
startPlugins = pluginsOpt {
default = ["plenary-nvim"];
example = ''
[pkgs.vimPlugins.telescope-nvim]
'';
description = ''
List of plugins to load on startup. This is used
internally to add plugins to Neovim's runtime.
To add additional plugins to your configuration, consider
using the [{option}`vim.extraPlugins`](#opt-vim.extraPlugins)
option.
'';
};
optPlugins = pluginsOpt {
default = [];
example = ''
[pkgs.vimPlugins.vim-ghost]
'';
description = ''
List of plugins to optionally load on startup.
This option has the same type definition as {option}`vim.startPlugins`
and plugins in this list are appended to {option}`vim.startPlugins` by
the wrapper during the build process.
To avoid overriding packages and dependencies provided by startPlugins, you
are recommended to use this option or {option}`vim.extraPlugins` option.
'';
};
extraPlugins = mkOption {
type = attrsOf extraPluginType;
default = {};
description = ''
A list of plugins and their configurations that will be
set up after builtin plugins.
This option takes a special type that allows you to order
your custom plugins using nvf's modified DAG library.
'';
example = literalMD ''
```nix
with pkgs.vimPlugins; {
aerial = {
package = aerial-nvim;
setup = "require('aerial').setup {}";
};
harpoon = {
package = harpoon;
setup = "require('harpoon').setup {}";
after = ["aerial"]; # place harpoon configuration after aerial
};
}
```
'';
};
extraPackages = mkOption {
type = listOf package;
default = [];
example = ''[pkgs.fzf pkgs.ripgrep]'';
description = ''
List of additional packages to make available to the Neovim
wrapper.
'';
};
# this defaults to `true` in the wrapper
# and since we pass this value to the wrapper
# with an inherit, it should be `true` here as well
withRuby =
mkEnableOption ''
Ruby support in the Neovim wrapper.
''
// {
default = true;
};
withNodeJs = mkEnableOption ''
NodeJs support in the Neovim wrapper
'';
luaPackages = mkOption {
type = listOf str;
default = [];
example = ''["magick" "serpent"]'';
description = "List of lua packages to install";
};
withPython3 = mkEnableOption ''
Python3 support in the Neovim wrapper
'';
python3Packages = mkOption {
type = listOf str;
default = [];
example = ''["pynvim"]'';
description = "List of python packages to install";
};
};
}