NotAShelf/nvf
2
1
Fork 0
mirror of https://github.com/NotAShelf/nvf.git synced 2026-06-10 15:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'main' into main

Browse source
This commit is contained in:
raf 2026-05-28 11:36:05 +00:00 • committed by GitHub
commit 7383a3999b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
39 changed files with 1768 additions and 612 deletions
Download patch file Download diff file Expand all files Collapse all files

7
configuration.nix
View file

@ -79,6 +79,8 @@ isMaximal: {
toml.enable = isMaximal;
xml.enable = isMaximal;
tex.enable = isMaximal;
docker.enable = isMaximal;
env.enable = isMaximal;
# Language modules that are not as common.
openscad.enable = false;
@ -106,16 +108,19 @@ isMaximal: {
jinja.enable = false;
svelte.enable = false;
vue.enable = false;
tsx.enable = false;
liquid.enable = false;
tera.enable = false;
twig.enable = false;
gettext.enable = false;
fluent.enable = false;
jq.enable = false;
fish.enable = false;
standard-ml.enable = false;
# Nim LSP is broken on Darwin and therefore
# should be disabled by default. Users may still enable
# `vim.languages.vim` to enable it, this does not restrict
# `vim.languages.nim` to enable it, this does not restrict
# that.
# See: <https://github.com/PMunch/nimlsp/issues/178#issue-2128106096>
nim.enable = false;

75
docs/manual/configuring/languages/lsp.md
View file

@ -1,28 +1,4 @@
# LSP Custom Packages/Command {#sec-languages-custom-lsp-packages}
One of the strengths of **nvf** is convenient aliases to quickly configure LSP
servers through the Nix module system. By default the LSP packages for relevant
language modules will be pulled into the closure. If this is not desirable, you
may provide **a custom LSP package** (e.g., a Bash script that calls a command)
or **a list of strings** to be interpreted as the command to launch the language
server. By using a list of strings, you can use this to skip automatic
installation of a language server, and instead use the one found in your `$PATH`
during runtime, for example:
```nix
vim.languages.java = {
lsp = {
enable = true;
# This expects 'jdt-language-server' to be in your PATH or in
# 'vim.extraPackages.' There are no additional checks performed to see
# if the command provided is valid.
package = ["jdt-language-server" "-data" "~/.cache/jdtls/workspace"];
};
}
```
## Custom LSP Servers {#ch-custom-lsp-servers}
# LSP Customizations {#sec-lsp-customization}
Neovim 0.11, in an effort to improve the out-of-the-box experience of Neovim,
has introduced a new `vim.lsp` API that can be used to register custom LSP
@ -30,18 +6,50 @@ servers with ease. In **nvf**, this translates to the custom `vim.lsp` API that
can be used to register servers that are not present in existing language
modules.
The {option}`vim.lsp.servers` submodule can be used to modify existing LSP
definitions OR register your own custom LSPs respectively. For example, if you'd
like to avoid having NVF pull the LSP packages you may modify the start command
to use a string, which will cause the LSP API to discover LSP servers from
{env}`PATH`. For example:
The {option}`vim.lsp.servers` submodule mirrors the `vim.lsp.config` lua API,
and can be used to modify existing LSP definitions OR register your own custom
LSPs.
## Configuring LSP presets {#ch-configuring-lsp-presets}
LSP presets provided by NVF via `vim.languages.*.lsp` can be further customized
with the {option}`vim.lsp.servers` submodule.
For example, if you'd like to avoid having NVF pull the LSP packages you may
modify the start command to use a string, which will cause the LSP API to
discover LSP servers from {env}`PATH`.
An example for **modifying a preset** provided by NVF via `vim.languages.*.lsp`:
```nix
{lib, ...}: {
vim.languages.python = {
enable = true;
lsp = {
enable = true;
# This is already the default value, we're just writing this down for
# clarity
servers = ["basedpyright"]
};
};
vim.lsp.servers = {
# Get `basedpyright-langserver` from PATH, e.g., a dev shell.
basedpyright.cmd = lib.mkForce ["basedpyright-langserver" "--stdio"];
};
}
```
## Adding custom LSP Servers {#ch-custom-lsp}
{option}`vim.lsp.servers` is also used to add your custom LSP definitions.
Example:
```nix
{lib, ...}: {
vim.lsp.servers = {
# Define a custom LSP entry using `vim.lsp.servers`:
ty = {
cmd = lib.mkDefault [(lib.getExe pkgs.ty) "server"];
@ -55,9 +63,10 @@ to use a string, which will cause the LSP API to discover LSP servers from
"pyrightconfig.json"
];
# If your LSP accepts custom settings. See `:help lsp-config` for more details
# on available fields. This is a freeform field.
settings.ty = { /* ... */ };
# If your LSP accepts custom settings. See `:help lsp-config` for more
# details on available fields. This is a freeform field.
settings.ty = { /* ... */ };
};
};
}
```

51
docs/manual/release-notes/rl-0.9.md
View file

@ -118,6 +118,10 @@
SCSS/SASS. This also changes the default LSP to `some-sass-language-server`
for SCSS/SASS.
- Split React/TSX from `languages.typescript` into `languages.tsx`. This new
module provides jsx/tsx support. This is a step of cleaning up the Typescript
module for the future.
[CaueAnjos](https://github.com/caueanjos)
- Renamed `roslyn_ls` to `roslyn-ls`
@ -299,6 +303,12 @@
[Snoweuph](https://github.com/snoweuph)
- Allow the usage of `pks.tree-sitter-grammars` in
{option}`vim.treesitter.grammars` and language module tree-sitter package
options created via `mkGrammarOption`.
- Add `emmet-ls` to the supported LSPs for all languages it supports.
- Added {option}`vim.treesitter.queries` to support adding custom queries.
- Added injections for `query = '' ... ''` as `query` and `mkLualine '' ... ''`,
@ -323,13 +333,15 @@
more flexibility in nvf and reuse of LSPs across languages. Dropped
`deprecatedSingleOrListOf` in favor of `listOf` for the affected LSP options.
- Added {option}`vim.lsp.presets.docker-language-server.enable` for Docker
support.
- Added {option}`vim.lsp.presets.angular-language-server.enable` for Angular
Template support.
- Added {option}`vim.lsp.presets.vtsls.enable` for Vue TypeScript support.
- Added {option}`vim.lsp.presets.vue-language-server.enable` for Vue Template
support.
- Added {option}`vim.lsp.presets.some-sass-language-server.enable`.
@ -347,6 +359,10 @@
- Added [Selenen](https://github.com/kampfkarren/selene) for more diagnostics in
`languages.lua`.
- Added `languages.docker` for Docker and Docker-Compose support. Thanks to
[poseidon-rises](https://github.com/poseidon-rises) for creating most of it in
[!1104](https://github.com/NotAShelf/nvf/pull/1104).
- Added [`mdformat`](https://mdformat.rtfd.io/) support to `languages.markdown`
with the extensions for [GFM](https://github.github.com/gfm/),
[front matter](https://www.markdownlang.com/advanced/frontmatter.html) and
@ -396,11 +412,17 @@
- Fix `languages.ts` registration of formatters.
- Added `asmfmt` and `nasmfmt` formatters to `languages.asm`.
- Added `astyle`, `indent` and `clang-format` to `languages.clang` formatters.
- Added `biome-check` and `biome-organize-imports` formatters to `languages.ts`.
- Added [`biomejs`](https://biomejs.dev/) as extra diagnostics provider to
`languages.ts`.
- Added `languages.standard-ml`.
- Added `languages.vue`.
- Add `languages.fluent` using the official plugin. This only provides
@ -408,6 +430,8 @@
- Add `languages.gettext`. This only provides highlighting.
- Add `languages.env`. This provides extra filetype hooks and diagnostics.
- Add `languages.openscad` using
[`openscad-lsp`](https://github.com/Leathong/openscad-LSP). This currently
relies on neovim builtin syntax for highlighting, and the lsp for formatting
@ -479,10 +503,23 @@ https://github.com/gorbit99/codewindow.nvim
[neocmakelsp]: https://github.com/neocmakelsp/neocmakelsp
[arduino-language-server]: https://github.com/arduino/arduino-language-server
[glsl_analyzer]: https://github.com/nolanderc/glsl_analyzer
[fish-lsp]: https://www.fish-lsp.dev/
[fish_indent]: https://fishshell.com/docs/current/cmds/fish_indent.html
- Add CMake support with [neocmakelsp].
- Add Arduino support with [arduino-language-server].
- Add GLSL support with [glsl_analyzer].
- Update fidget-nvim setupOpts and fix NvimTree issue.
- Add Fish support via {option}`vim.languages.fish.enable` using [fish-lsp] and
[fish_indent]. Most of the work done by
[poseidon-rises](https://github.com/poseidon-rises) in
[!1107](https://github.com/NotAShelf/nvf/pull/1107).
[emo-mruczek](https://emo-mruczek.pet):
[vhdl-ls]: https://github.com/VHDL-LS/rust_hdl
- Add VHDL support with [vhdl-ls].
[itscrystalline](https://github.com/itscrystalline):
@ -528,4 +565,16 @@ https://github.com/gorbit99/codewindow.nvim
- Allow `vim.treesitter.context.setupOpts.max_lines` to also be given as a
string in order to allow percentage values like `"20%"`
[RoastedCheese](https://github.com/roastedcheese):
- Fix `golangci-lint` to lint at the package level.
[Poseidon](https://github.com/poseidon-rises)
[PHPStan]: https://github.com/phpstan/phpstan
- Add [PHPStan] as a formatter for `vim.languages.php`.
- Add `prettier` and `prettierd` as supported formatters to
`vim.languages.json`.
<!-- vim: set textwidth=80: -->

34
flake.lock generated
View file

@ -3,11 +3,11 @@
"flake-compat": {
"flake": false,
"locked": {
"lastModified": 1751685974,
"narHash": "sha256-NKw96t+BgHIYzHUjkTK95FqYRVKB8DHpVhefWSz/kTw=",
"lastModified": 1777699697,
"narHash": "sha256-Eg9b/rq/ECYwNwEXs5i9wHyhxNI0JrYx2srdI2uZMaQ=",
"ref": "refs/heads/main",
"rev": "549f2762aebeff29a2e5ece7a7dc0f955281a1d1",
"revCount": 92,
"rev": "382052b74656a369c5408822af3f2501e9b1af81",
"revCount": 94,
"type": "git",
"url": "https://git.lix.systems/lix-project/flake-compat.git"
},
@ -23,11 +23,11 @@
]
},
"locked": {
"lastModified": 1769996383,
"narHash": "sha256-AnYjnFWgS49RlqX7LrC4uA+sCCDBj0Ry/WOJ5XWAsa0=",
"lastModified": 1778716662,
"narHash": "sha256-m1Yf0wZ8j1OHjTc2UwHwyQRSnNeSgLJOd7q5Y45hzi4=",
"owner": "hercules-ci",
"repo": "flake-parts",
"rev": "57928607ea566b5db3ad13af0e57e921e6b12381",
"rev": "f7c1a2d347e4c52d5fb8d10cb4d94b5884e546fb",
"type": "github"
},
"original": {
@ -38,11 +38,11 @@
},
"mnw": {
"locked": {
"lastModified": 1777828893,
"narHash": "sha256-gVWVnmyNr74BVKfhMMZDWkhx2699dhmZ2g0W8TTHtkk=",
"lastModified": 1778541201,
"narHash": "sha256-n0twkzWexzjsoDycOTvvQNuGEdg62UiNHYcFCduYpKI=",
"owner": "Gerg-L",
"repo": "mnw",
"rev": "c1c0b544bfabe6669b5a6a0383ccb475fe60258b",
"rev": "1a3573fc9d2486738fe0b2cacc5cd10dd5f3a445",
"type": "github"
},
"original": {
@ -58,27 +58,27 @@
]
},
"locked": {
"lastModified": 1776882296,
"narHash": "sha256-DWZozXwMsgvUqfVlL1mQ8dOxW7GJ/8CdyaDN+1niZRg=",
"lastModified": 1779233504,
"narHash": "sha256-YIKEyzh0NFQlD0O92LQQNMoVCDwV8yw1Xz0Iu+4ZC5U=",
"owner": "feel-co",
"repo": "ndg",
"rev": "ab7d78d4884b3a34968cf9fa3d16c0c1246d5c6e",
"rev": "86f6644411a64d5413711895b7cf6e0e1be465b6",
"type": "github"
},
"original": {
"owner": "feel-co",
"ref": "refs/tags/v2.6.0",
"ref": "refs/tags/v2.8.0",
"repo": "ndg",
"type": "github"
}
},
"nixpkgs": {
"locked": {
"lastModified": 1774386573,
"narHash": "sha256-4hAV26quOxdC6iyG7kYaZcM3VOskcPUrdCQd/nx8obc=",
"lastModified": 1778869304,
"narHash": "sha256-30sZNZoA1cqF5JNO9fVX+wgiQYjB7HJqqJ4ztCDeBZE=",
"owner": "nixos",
"repo": "nixpkgs",
"rev": "46db2e09e1d3f113a13c0d7b81e2f221c63b8ce9",
"rev": "d233902339c02a9c334e7e593de68855ad26c4cb",
"type": "github"
},
"original": {

2
flake.nix
View file

@ -139,7 +139,7 @@
# Alternative documentation generator
ndg = {
url = "github:feel-co/ndg?ref=refs/tags/v2.6.0";
url = "github:feel-co/ndg?ref=refs/tags/v2.8.0";
inputs.nixpkgs.follows = "nixpkgs";
};
};

25
flake/pkgs/by-name/prettier-plugin-astro/package.nix
View file

@ -1,14 +1,16 @@
{
pins,
stdenv,
fetchFromGitHub,
nodejs,
pnpm_9,
pnpmConfigHook,
zstd,
fetchPnpmDeps,
pins,
writableTmpDirAsHomeHook,
}: let
pin = pins.prettier-plugin-astro;
pnpm = pnpm_9;
in
stdenv.mkDerivation (finalAttrs: {
pname = "prettier-plugin-astro";
@ -21,18 +23,20 @@ in
};
pnpmDeps = fetchPnpmDeps {
pnpm = pnpm_9;
inherit (finalAttrs) pname src;
fetcherVersion = 2;
hash = "sha256-K7pIWLkIIbUKDIcysfEtcf/eVMX9ZgyFHdqcuycHCNE=";
inherit pnpm;
inherit (finalAttrs) pname version src;
hash = "sha256-vs7KOsX+jmnY2+RKJlhSWDVyTUxAO2af3lyao9AYFr8=";
fetcherVersion = 3; # https://nixos.org/manual/nixpkgs/stable/#javascript-pnpm-fetcherVersion
};
nativeBuildInputs = [
nodejs
writableTmpDirAsHomeHook
(pnpmConfigHook.overrideAttrs {
propagatedBuildInputs = [pnpm_9];
(pnpmConfigHook.override {
inherit pnpm;
})
pnpm
zstd
];
buildPhase = ''
@ -43,13 +47,8 @@ in
runHook postBuild
'';
installPhase = ''
runHook preInstall
# mkdir -p $out/dist
preInstall = ''
cp -r dist/ $out
cp -r node_modules $out
runHook postInstall
'';
})

2
flake/pkgs/by-name/prettier-plugin-svelte/package.nix
View file

@ -15,7 +15,7 @@ in
sha256 = pin.hash;
};
npmDepsHash = "sha256-XVyLW0XDCvZCZxu8g1fP7fRfeU3Hz81o5FCi/i4BKQw=";
npmDepsHash = "sha256-zejYnwkj6CBWOqA6LBYBEXMg0jT2vJqinBwzKdWIqpY=";
dontNpmPrune = true;

2
lib/types/default.nix
View file

@ -10,7 +10,7 @@
in {
inherit (typesDag) dagOf;
inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
inherit (typesLanguage) diagnostics mkGrammarOption;
inherit (typesLanguage) diagnostics mkGrammarOption mkTreesitterGrammarOption;
inherit (typesLsp) mkLspPresetEnableOption;
inherit (customTypes) char hexColor mergelessListOf deprecatedSingleOrListOf enumWithRename;
}

13
lib/types/languages.nix
View file

@ -33,6 +33,17 @@
default = ["vimPlugins" "nvim-treesitter" "grammarPlugins" grammar];
nullable = true;
};
# Prefer using `mkGrammarOption` and only use this, for grammars,
# not in `vimPlugins.nvim-treesitter.grammarPlugins`.
# Grammars from `tree-sitter-grammars.tree-sitter-<name>` should mostly
# just work, but should be tested extra, as we currently only use them
# for a small subset of language modules.
mkTreesitterGrammarOption = pkgs: grammar:
mkPackageOption pkgs ["${grammar} treesitter"] {
default = ["tree-sitter-grammars" "tree-sitter-${grammar}"];
nullable = true;
};
in {
inherit diagnostics diagnosticSubmodule mkGrammarOption;
inherit diagnostics diagnosticSubmodule mkGrammarOption mkTreesitterGrammarOption;
}

5
modules/extra/deprecations.nix
View file

@ -373,5 +373,10 @@ in {
<https://strongly-typed-thoughts.net/blog/final-bye-github>
'')
]
# 2026-05-16
[
(mkRenamedOptionModule ["vim" "languages" "typescript" "treesitter" "tsxPackage"] ["vim" "languages" "tsx" "treesitter" "package"])
]
];
}

2
modules/plugins/filetree/nvimtree/config.nix
View file

@ -19,6 +19,8 @@ in {
"<leader>t" = "+NvimTree";
};
visuals.fidget-nvim.setupOpts.notification.window.avoid = ["NvimTree"];
lazy.plugins.nvim-tree-lua = {
package = "nvim-tree-lua";
setupModule = "nvim-tree";

75
modules/plugins/languages/asm.nix
View file

@ -4,15 +4,36 @@
lib,
...
}: let
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) enum listOf;
inherit (lib) genAttrs;
inherit (lib.attrsets) attrNames genAttrs;
inherit (lib.generators) mkLuaInline;
inherit (lib.meta) getExe;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.assembly;
defaultServers = ["asm-lsp"];
servers = ["asm-lsp"];
defaultFormat = ["asmfmt"];
formats = {
asmfmt = {
command = getExe pkgs.asmfmt;
};
nasmfmt = {
command = getExe pkgs.nasmfmt;
args = mkLuaInline ''
function(self, ctx)
return {
"--ii", ctx.shiftwidth,
"$FILENAME",
}
end
'';
};
};
in {
options.vim.languages.assembly = {
enable = mkEnableOption "Assembly support";
@ -42,6 +63,20 @@ in {
description = "Assembly LSP server to use";
};
};
format = {
enable =
mkEnableOption "Assembly formatting"
// {
default = config.vim.languages.enableFormat;
defaultText = literalExpression "config.vim.languages.enableFormat";
};
type = mkOption {
type = listOf (enum (attrNames formats));
default = defaultFormat;
description = "Assembly formatter to use";
};
};
};
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.treesitter.enable {
@ -57,9 +92,43 @@ in {
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["asm" "nasm" "masm" "vmasm" "fasm" "tasm" "tiasm" "asm68k" "asm8300"];
filetypes = [
"asm"
"nasm"
"masm"
"vmasm"
"fasm"
"tasm"
"tiasm"
"asm68k"
"asmh8300"
];
});
};
})
(mkIf cfg.format.enable {
vim.formatter.conform-nvim = {
enable = true;
setupOpts = {
formatters_by_ft = {
asm = cfg.format.type;
nasm = cfg.format.type;
masm = cfg.format.type;
vmasm = cfg.format.type;
tasm = cfg.format.type;
tiasm = cfg.format.type;
asm68k = cfg.format.type;
asmh8300 = cfg.format.type;
};
formatters =
mapListToAttrs (name: {
inherit name;
value = formats.${name};
})
cfg.format.type;
};
};
})
]);
}

84
modules/plugins/languages/clang.nix
View file

@ -8,9 +8,12 @@
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) bool enum package listOf;
inherit (lib) genAttrs;
inherit (lib.meta) getExe getExe';
inherit (lib.modules) mkIf mkMerge;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.dag) entryAfter;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.clang;
@ -45,6 +48,54 @@
'';
};
};
defaultFormat = ["clang-format"];
formats = {
astyle = {
command = getExe pkgs.astyle;
stdin = false;
args = mkLuaInline ''
function(self, ctx)
local args = {
"$FILENAME",
}
if not vim.bo[ctx.buf].expandtab then
table.insert(args, "--indent=tab=" .. ctx.shiftwidth)
else
table.insert(args, "--indent=spaces=" .. ctx.shiftwidth)
end
return args
end
'';
};
indent = {
command = getExe pkgs.indent;
stdin = true;
args = mkLuaInline ''
function(self, ctx)
local args = {
"--indent-level", ctx.shiftwidth,
"--tab-size", ctx.shiftwidth,
}
if not vim.bo[ctx.buf].expandtab then
table.insert(args, "--use-tabs")
else
table.insert(args, "--no-tabs")
end
return args
end
'';
# Default is GNU style. Nobody likes that one.
# This is under `append_args`, to allow easy editing of this argument,
# without having to redefine everything as a user.
append_args = ["--linux-style"];
};
clang-format.command = getExe' pkgs.clang-tools "clang-format";
};
in {
options.vim.languages.clang = {
enable = mkEnableOption "C/C++ language support";
@ -102,6 +153,21 @@ in {
default = debuggers.${cfg.dap.debugger}.package;
};
};
format = {
enable =
mkEnableOption "C formatting"
// {
default = config.vim.languages.enableFormat;
defaultText = literalExpression "config.vim.languages.enableFormat";
};
type = mkOption {
type = listOf (enum (attrNames formats));
default = defaultFormat;
description = "C formatter to use";
};
};
};
config = mkIf cfg.enable (mkMerge [
@ -127,5 +193,23 @@ in {
vim.debugger.nvim-dap.enable = true;
vim.debugger.nvim-dap.sources.clang-debugger = debuggers.${cfg.dap.debugger}.dapConfig;
})
(mkIf cfg.format.enable {
vim.formatter.conform-nvim = {
enable = true;
setupOpts = {
formatters_by_ft = {
c = cfg.format.type;
cpp = cfg.format.type;
};
formatters =
mapListToAttrs (name: {
inherit name;
value = formats.${name};
})
cfg.format.type;
};
};
})
]);
}

2
modules/plugins/languages/css.nix
View file

@ -16,7 +16,7 @@
cfg = config.vim.languages.css;
defaultServer = ["vscode-css-language-server"];
servers = ["vscode-css-language-server"];
servers = ["vscode-css-language-server" "emmet-ls"];
defaultFormat = ["prettier"];
formats = {

55
modules/plugins/languages/default.nix
View file

@ -7,65 +7,72 @@ in {
./asm.nix
./astro.nix
./bash.nix
./cue.nix
./dart.nix
./clang.nix
./clojure.nix
./cmake.nix
./csharp.nix
./css.nix
./scss.nix
./cue.nix
./dart.nix
./docker.nix
./elixir.nix
./elm.nix
./env.nix
./fish.nix
./fluent.nix
./fsharp.nix
./gettext.nix
./gleam.nix
./glsl.nix
./go.nix
./haskell.nix
./hcl.nix
./helm.nix
./kotlin.nix
./html.nix
./tera.nix
./twig.nix
./liquid.nix
./haskell.nix
./java.nix
./jinja.nix
./jq.nix
./json.nix
./julia.nix
./just.nix
./kotlin.nix
./liquid.nix
./lua.nix
./make.nix
./markdown.nix
./tex.nix
./nim.nix
./vala.nix
./nix.nix
./nu.nix
./ocaml.nix
./odin.nix
./openscad.nix
./php.nix
./python.nix
./qml.nix
./r.nix
./ruby.nix
./rust.nix
./scala.nix
./scss.nix
./scss.nix
./sql.nix
./standard-ml.nix
./svelte.nix
./vue.nix
./tera.nix
./terraform.nix
./tex.nix
./toml.nix
./tsx.nix
./twig.nix
./typescript.nix
./typst.nix
./zig.nix
./csharp.nix
./julia.nix
./nu.nix
./odin.nix
./vala.nix
./vhdl.nix
./vue.nix
./wgsl.nix
./yaml.nix
./ruby.nix
./just.nix
./make.nix
./xml.nix
./gettext.nix
./fluent.nix
./openscad.nix
./jq.nix
./yaml.nix
./zig.nix
# This is now a hard deprecation.
(mkRenamedOptionModule ["vim" "languages" "enableLSP"] ["vim" "lsp" "enable"])

163
modules/plugins/languages/docker.nix Normal file
View file

@ -0,0 +1,163 @@
{
config,
pkgs,
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.docker;
defaultServers = ["docker-language-server"];
servers = ["docker-language-server"];
defaultFormat = ["dockerfmt"];
formats = {
dockerfmt = {
command = getExe pkgs.dockerfmt;
};
};
defaultDiagnosticsProvider = ["hadolint"];
diagnosticsProviders = {
hadolint = {
config.cmd = getExe (
pkgs.writeShellApplication {
name = "hadolint";
runtimeInputs = [pkgs.hadolint];
text = "hadolint -";
}
);
};
};
in {
options.vim.languages.docker = {
enable = mkEnableOption "Docker language support";
treesitter = {
enable =
mkEnableOption "Docker treesitter support"
// {
default = config.vim.languages.enableTreesitter;
defaultText = literalExpression "config.vim.languages.enableTreesitter";
};
package = mkGrammarOption pkgs "dockerfile";
};
lsp = {
enable =
mkEnableOption "Docker LSP support"
// {
default = config.vim.lsp.enable;
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum servers);
default = defaultServers;
description = "Docker LSP server to use";
};
};
format = {
enable =
mkEnableOption "Dockerfile formatting"
// {
default = config.vim.languages.enableFormat;
defaultText = literalExpression "config.vim.languages.enableFormat";
};
type = mkOption {
type = listOf (enum (attrNames formats));
default = defaultFormat;
description = "Dockerfile formatter to use";
};
};
extraDiagnostics = {
enable =
mkEnableOption "extra Dockerfile diagnostics"
// {
default = config.vim.languages.enableExtraDiagnostics;
};
types = diagnostics {
langDesc = "Dockerfile";
inherit diagnosticsProviders;
inherit defaultDiagnosticsProvider;
};
};
};
config = mkIf cfg.enable (mkMerge [
{
vim.autocmds = [
# Without this the LSP doesn't understand them correctly
# and there are conflicts with the YAML LSP
{
desc = "Set Docker Compose filetype";
event = ["BufRead" "BufNewFile"];
pattern = [
"compose.yml"
"compose.yaml"
"docker-compose.yml"
"docker-compose.yaml"
];
command = "set filetype=dockercompose";
}
];
}
(mkIf cfg.treesitter.enable {
vim.treesitter = {
enable = true;
grammars = [cfg.treesitter.package];
};
})
(mkIf cfg.lsp.enable {
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = [
"dockerfile"
"dockercompose"
];
});
};
})
(mkIf cfg.format.enable {
vim.formatter.conform-nvim = {
enable = true;
setupOpts = {
formatters_by_ft.dockerfile = cfg.format.type;
formatters =
mapListToAttrs (name: {
inherit name;
value = formats.${name};
})
cfg.format.type;
};
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.dockerfile = cfg.extraDiagnostics.types;
linters = mkMerge (
map (name: {
${name} = diagnosticsProviders.${name}.config;
})
cfg.extraDiagnostics.types
);
};
})
]);
}

70
modules/plugins/languages/env.nix Normal file
View file

@ -0,0 +1,70 @@
{
config,
pkgs,
lib,
...
}: let
inherit (lib.options) mkEnableOption literalExpression;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.nvim.types) diagnostics;
cfg = config.vim.languages.env;
defaultDiagnosticsProvider = ["dotenv-linter"];
diagnosticsProviders = {
dotenv-linter = let
pkg = pkgs.dotenv-linter;
in {
package = pkg;
config = {
cmd = getExe pkg;
};
};
};
in {
options.vim.languages.env = {
enable = mkEnableOption "Env language support";
extraDiagnostics = {
enable =
mkEnableOption "extra Env diagnostics"
// {
default = config.vim.languages.enableExtraDiagnostics;
defaultText = literalExpression "config.vim.languages.enableExtraDiagnostics";
};
types = diagnostics {
langDesc = "Env";
inherit diagnosticsProviders;
inherit defaultDiagnosticsProvider;
};
};
};
config = mkIf cfg.enable (mkMerge [
{
vim.autocmds = [
{
event = ["BufRead" "BufNewFile"];
pattern = [
# support common names like `dist.env`
"*.env"
# support weird env files names like symfony ones.
".env.*"
];
command = "set filetype=env";
}
];
}
(mkIf cfg.extraDiagnostics.enable {
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.env = cfg.extraDiagnostics.types;
linters =
mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
cfg.extraDiagnostics.types);
};
})
]);
}

102
modules/plugins/languages/fish.nix Normal file
View file

@ -0,0 +1,102 @@
{
config,
pkgs,
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.meta) getExe';
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum bool listOf;
inherit (lib) genAttrs;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.fish;
defaultServers = ["fish-lsp"];
servers = ["fish-lsp"];
defaultFormat = ["fish_indent"];
formats = {
fish_indent = {
command = getExe' pkgs.fish "fish_indent";
};
};
in {
options.vim.languages.fish = {
enable = mkEnableOption "Fish language support";
treesitter = {
enable =
mkEnableOption "Fish treesitter"
// {
default = config.vim.languages.enableTreesitter;
defaultText = literalExpression "config.vim.languages.enableTreesitter";
};
package = mkGrammarOption pkgs "fish";
};
lsp = {
enable =
mkEnableOption "Fish LSP support"
// {
default = config.vim.lsp.enable;
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum servers);
default = defaultServers;
description = "Fish LSP server to use";
};
};
format = {
enable = mkOption {
type = bool;
default = config.vim.languages.enableFormat;
defaultText = literalExpression "config.vim.languages.enableFormat";
description = "Enable Fish formatting";
};
type = mkOption {
type = listOf (enum (attrNames formats));
default = defaultFormat;
description = "Fish formatter to use";
};
};
};
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.treesitter.enable {
vim.treesitter = {
enable = true;
grammars = [cfg.treesitter.package];
};
})
(mkIf cfg.lsp.enable {
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["fish"];
});
};
})
(mkIf cfg.format.enable {
vim.formatter.conform-nvim = {
enable = true;
setupOpts = {
formatters_by_ft.fish = cfg.format.type;
formatters =
mapListToAttrs (name: {
inherit name;
value = formats.${name};
})
cfg.format.type;
};
};
})
]);
}

36
modules/plugins/languages/go.nix
View file

@ -67,7 +67,21 @@
"--output.junit-xml.path="
"--output.teamcity.path="
"--output.sarif.path="
(mkLuaInline ''
-- Run on current file only if go.mod is missing
function()
local fnmod = ":p";
local cmd = {"${getExe pkgs.go}", "env", "GOMOD"};
local ok, gomod = pcall(vim.fn.system, cmd);
gomod = gomod:gsub("%s+", "")
if ok and gomod ~= "" and gomod ~= "/dev/null" then
fnmod = ":h";
end
return vim.fn.fnamemodify(vim.api.nvim_buf_get_name(0), fnmod)
end
'')
];
append_fname = false;
parser = mkLuaInline ''
function(output, bufnr)
local SOURCE = "golangci-lint";
@ -111,15 +125,19 @@
local normalized = issue.Severity:lower()
sev = severity_map[normalized] or vim.diagnostic.severity.ERROR
end
table.insert(diagnostics, {
bufnr = bufnr,
lnum = issue.Pos.Line - 1,
col = issue.Pos.Column - 1,
message = issue.Text,
code = issue.FromLinter,
severity = sev,
source = SOURCE,
})
local buffer = vim.fn.fnamemodify(vim.api.nvim_buf_get_name(bufnr), ":p")
if vim.fs.normalize(buffer) == vim.fs.normalize(issue.Pos.Filename) then
table.insert(diagnostics, {
bufnr = bufnr,
lnum = issue.Pos.Line - 1,
col = issue.Pos.Column - 1,
message = issue.Text,
code = issue.FromLinter,
severity = sev,
source = SOURCE,
})
end
end
return diagnostics
end

2
modules/plugins/languages/hcl.nix
View file

@ -16,7 +16,7 @@
cfg = config.vim.languages.hcl;
defaultServers = ["tofu-ls"];
servers = ["terraform-ls" "tofu-ls"];
servers = ["terraform-ls" "tofu-ls" "docker-language-server"];
defaultFormat = ["hclfmt"];
formats = {

8
modules/plugins/languages/json.nix
View file

@ -25,6 +25,14 @@
command = getExe pkgs.jsonfmt;
args = ["-w" "-"];
};
prettier = {
command = getExe pkgs.prettier;
};
prettierd = {
command = getExe pkgs.prettierd;
};
};
in {
options.vim.languages.json = {

35
modules/plugins/languages/php.nix
View file

@ -11,7 +11,7 @@
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum int attrs listOf;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.php;
@ -33,6 +33,14 @@
command = "${pkgs.php84Packages.php-cs-fixer}/bin/php-cs-fixer";
};
};
defaultDiagnosticsProvider = ["phpstan"];
diagnosticsProviders = {
phpstan = {
config.cmd = getExe pkgs.phpstan;
};
};
in {
options.vim.languages.php = {
enable = mkEnableOption "PHP language support";
@ -103,6 +111,21 @@ in {
};
};
};
extraDiagnostics = {
enable =
mkEnableOption "extra PHP diagnostics"
// {
default = config.vim.languages.enableExtraDiagnostics;
defaultText = literalExpression "config.vim.languages.enableExtraDiagnostic";
};
types = diagnostics {
langDesc = "PHP";
inherit diagnosticsProviders;
inherit defaultDiagnosticsProvider;
};
};
};
config = mkIf cfg.enable (mkMerge [
@ -154,5 +177,15 @@ in {
};
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.php = cfg.extraDiagnostics.types;
linters =
mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
cfg.extraDiagnostics.types);
};
})
]);
}

2
modules/plugins/languages/scss.nix
View file

@ -16,7 +16,7 @@
cfg = config.vim.languages.scss;
defaultServer = ["some-sass-language-server"];
servers = ["some-sass-language-server" "vscode-css-language-server"];
servers = ["some-sass-language-server" "vscode-css-language-server" "emmet-ls"];
defaultFormat = ["prettier"];
formats = {

114
modules/plugins/languages/standard-ml.nix Normal file
View file

@ -0,0 +1,114 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) literalExpression mkEnableOption mkOption;
inherit (lib.types) enum listOf;
inherit (lib.attrsets) attrNames genAttrs;
inherit (lib.generators) mkLuaInline;
inherit (lib.meta) getExe;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) mkTreesitterGrammarOption;
cfg = config.vim.languages.standard-ml;
defaultServers = ["millet"];
servers = ["millet"];
defaultFormat = ["smlfmt"];
formats = {
smlfmt = {
command = getExe pkgs.smlfmt;
stdin = false;
args = mkLuaInline ''
function(self, ctx)
return {
"--force",
"-tab-width", ctx.shiftwidth,
"-indent-width", ctx.shiftwidth,
"$FILENAME",
}
end
'';
};
};
in {
options.vim.languages.standard-ml = {
enable = mkEnableOption "Standard ML support";
treesitter = {
enable =
mkEnableOption "Standard ML treesitter"
// {
default = config.vim.languages.enableTreesitter;
defaultText = literalExpression "config.vim.languages.enableTreesitter";
};
package = mkTreesitterGrammarOption pkgs "sml";
};
lsp = {
enable =
mkEnableOption "Standard ML LSP support"
// {
default = config.vim.lsp.enable;
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum servers);
default = defaultServers;
description = "Standard ML LSP server to use";
};
};
format = {
enable =
mkEnableOption "Standard ML formatting"
// {
default = config.vim.languages.enableFormat;
defaultText = literalExpression "config.vim.languages.enableFormat";
};
type = mkOption {
description = "Standard ML formatter to use";
type = listOf (enum (attrNames formats));
default = defaultFormat;
};
};
};
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.treesitter.enable {
vim.treesitter = {
enable = true;
grammars = [cfg.treesitter.package];
};
})
(mkIf cfg.lsp.enable {
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["sml"];
});
};
})
(mkIf cfg.format.enable {
vim.formatter.conform-nvim = {
enable = true;
setupOpts = {
formatters_by_ft.sml = cfg.format.type;
formatters =
mapListToAttrs (name: {
inherit name;
value = formats.${name};
})
cfg.format.type;
};
};
})
]);
}

2
modules/plugins/languages/svelte.nix
View file

@ -17,7 +17,7 @@
cfg = config.vim.languages.svelte;
defaultServers = ["svelte-language-server"];
servers = ["svelte-language-server"];
servers = ["svelte-language-server" "emmet-ls"];
defaultFormat = ["prettier"];
formats = let

159
modules/plugins/languages/tsx.nix Normal file
View file

@ -0,0 +1,159 @@
{
config,
pkgs,
lib,
...
}: let
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) enum listOf;
inherit (lib.attrsets) attrNames genAttrs;
inherit (lib.meta) getExe;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
cfg = config.vim.languages.tsx;
defaultServers = ["typescript-language-server"];
servers = ["typescript-language-server" "deno" "typescript-go" "emmet-ls"];
defaultFormat = ["prettier"];
formats = {
prettier = {
command = getExe pkgs.prettier;
};
prettierd = {
command = getExe pkgs.prettierd;
};
biome = {
command = getExe pkgs.biome;
};
biome-check = {
command = getExe pkgs.biome;
};
biome-organize-imports = {
command = getExe pkgs.biome;
};
};
defaultDiagnosticsProvider = ["biomejs"];
diagnosticsProviders = {
biomejs = let
pkg = pkgs.biome;
in {
package = pkg;
config = {
cmd = getExe pkg;
};
};
};
in {
options.vim.languages.tsx = {
enable = mkEnableOption "Typescript XML (TSX) language support";
treesitter = {
enable =
mkEnableOption "Typescript XML (TSX) treesitter"
// {
default = config.vim.languages.enableTreesitter;
defaultText = literalExpression "config.vim.languages.enableTreesitter";
};
package = mkGrammarOption pkgs "tsx";
};
lsp = {
enable =
mkEnableOption "Typescript XML (TSX) LSP support"
// {
default = config.vim.lsp.enable;
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum servers);
default = defaultServers;
description = "Typescript XML (TSX) LSP server to use";
};
};
format = {
enable =
mkEnableOption "Typescript XML (TSX) formatting"
// {
default = config.vim.languages.enableFormat;
defaultText = literalExpression "config.vim.languages.enableFormat";
};
type = mkOption {
description = "Typescript XML (TSX) formatter to use";
type = listOf (enum (attrNames formats));
default = defaultFormat;
};
};
extraDiagnostics = {
enable = mkEnableOption "extra Typescript XML (TSX) diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
types = diagnostics {
langDesc = "Typescript XML (TSX)";
inherit diagnosticsProviders;
inherit defaultDiagnosticsProvider;
};
};
};
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.treesitter.enable {
vim.treesitter = {
enable = true;
grammars = [cfg.treesitter.package];
};
})
(mkIf cfg.lsp.enable {
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = [
"typescriptreact"
"javascriptreact"
];
});
};
})
(mkIf cfg.format.enable {
vim.formatter.conform-nvim = {
enable = true;
setupOpts = {
formatters_by_ft = {
typescriptreact = cfg.format.type;
javascriptreact = cfg.format.type;
};
formatters =
mapListToAttrs (name: {
inherit name;
value = formats.${name};
})
cfg.format.type;
};
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft = {
typescriptreact = cfg.extraDiagnostics.types;
javascriptreact = cfg.extraDiagnostics.types;
};
linters =
mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
cfg.extraDiagnostics.types);
};
})
]);
}

13
modules/plugins/languages/typescript.nix
View file

@ -18,7 +18,7 @@
cfg = config.vim.languages.typescript;
defaultServers = ["typescript-language-server"];
servers = ["typescript-language-server" "deno" "typescript-go" "angular-language-server"];
servers = ["typescript-language-server" "deno" "typescript-go" "angular-language-server" "emmet-ls"];
# TODO: specify packages
defaultFormat = ["prettier"];
@ -85,7 +85,6 @@ in {
defaultText = literalExpression "config.vim.languages.enableTreesitter";
};
tsPackage = mkGrammarOption pkgs "typescript";
tsxPackage = mkGrammarOption pkgs "tsx";
jsPackage = mkGrammarOption pkgs "javascript";
};
@ -162,7 +161,6 @@ in {
vim.treesitter.enable = true;
vim.treesitter.grammars = [
cfg.treesitter.tsPackage
cfg.treesitter.tsxPackage
cfg.treesitter.jsPackage
];
})
@ -173,11 +171,6 @@ in {
servers = genAttrs cfg.lsp.servers (_: {
filetypes = [
"typescript"
# TODO: move to a React module
"typescriptreact"
"typescript.tsx"
"javascriptreact"
"javascript.jsx"
# TODO: move to a JavaScript module
"javascript"
];
@ -192,8 +185,6 @@ in {
formatters_by_ft = {
typescript = cfg.format.type;
javascript = cfg.format.type;
# .tsx/.jsx files
typescriptreact = cfg.format.type;
};
formatters =
mapListToAttrs (name: {
@ -209,8 +200,6 @@ in {
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.typescript = cfg.extraDiagnostics.types;
linters_by_ft.typescriptreact = cfg.extraDiagnostics.types;
linters =
mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
cfg.extraDiagnostics.types);

65
modules/plugins/languages/vhdl.nix Normal file
View file

@ -0,0 +1,65 @@
{
config,
pkgs,
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum bool listOf;
inherit (lib) genAttrs;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.vhdl;
defaultServers = ["vhdl-ls"];
servers = ["vhdl-ls"];
in {
options.vim.languages.vhdl = {
enable = mkEnableOption "VHDL language support";
treesitter = {
enable =
mkEnableOption "VHDL treesitter"
// {
default = config.vim.languages.enableTreesitter;
defaultText = literalExpression "config.vim.languages.enableTreesitter";
};
package = mkGrammarOption pkgs "vhdl";
};
lsp = {
enable =
mkEnableOption "VHDL LSP support"
// {
default = config.vim.lsp.enable;
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum servers);
default = defaultServers;
description = "VHDL LSP server to use";
};
};
};
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.treesitter.enable {
vim.treesitter = {
enable = true;
grammars = [cfg.treesitter.package];
};
})
(mkIf cfg.lsp.enable {
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["vhdl"];
});
};
})
]);
}

2
modules/plugins/languages/vue.nix
View file

@ -16,7 +16,7 @@
cfg = config.vim.languages.vue;
defaultServers = ["vue-language-server" "vtsls"];
servers = ["vue-language-server" "vtsls" "typescript-language-server"];
servers = ["vue-language-server" "vtsls" "typescript-language-server" "emmet-ls"];
defaultFormat = ["biome" "biome-check" "biome-organize-imports"];
formats = {

4
modules/plugins/lsp/presets/default.nix
View file

@ -13,9 +13,11 @@
./cue.nix
./dart.nix
./deno.nix
./docker-language-server.nix
./elixir-ls.nix
./elm-language-server.nix
./emmet-ls.nix
./fish-lsp.nix
./fsautocomplete.nix
./gleam.nix
./glsl_analyzer.nix
@ -33,6 +35,7 @@
./lua-language-server.nix
./markdown-oxide.nix
./marksman.nix
./millet.nix
./neocmakelsp.nix
./nil.nix
./nimlsp.nix
@ -70,6 +73,7 @@
./typescript-go.nix
./typescript-language-server.nix
./vala-language-server.nix
./vhdl-ls.nix
./vscode-css-language-server.nix
./vscode-json-language-server.nix
./vtsls.nix

33
modules/plugins/lsp/presets/docker-language-server.nix Normal file
View file

@ -0,0 +1,33 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
cfg = config.vim.lsp.presets.docker-language-server;
in {
options.vim.lsp.presets.docker-language-server = {
enable = mkLspPresetEnableOption "docker-language-server" "Docker" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.docker-language-server = {
enable = true;
cmd = [(getExe pkgs.docker-language-server) "start" "--stdio"];
root_markers = [
".git"
"Dockerfile"
"docker-compose.yaml"
"docker-compose.yml"
"compose.yaml"
"compose.yml"
"docker-bake.json"
"docker-bake.hcl"
];
};
};
}

24
modules/plugins/lsp/presets/fish-lsp.nix Normal file
View file

@ -0,0 +1,24 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
cfg = config.vim.lsp.presets.fish-lsp;
in {
options.vim.lsp.presets.fish-lsp = {
enable = mkLspPresetEnableOption "fish-lsp" "Fish" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.fish-lsp = {
enable = true;
cmd = [(getExe pkgs.fish-lsp) "start"];
root_markers = ["config.fish" ".git"];
};
};
}

24
modules/plugins/lsp/presets/millet.nix Normal file
View file

@ -0,0 +1,24 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
cfg = config.vim.lsp.presets.millet;
in {
options.vim.lsp.presets.millet = {
enable = mkLspPresetEnableOption "millet" "Millet Standard ML" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.millet = {
enable = true;
cmd = [(getExe pkgs.millet)];
root_markers = [".git" "millet.toml"];
};
};
}

24
modules/plugins/lsp/presets/vhdl-ls.nix Normal file
View file

@ -0,0 +1,24 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
cfg = config.vim.lsp.presets.vhdl-ls;
in {
options.vim.lsp.presets.vhdl-ls = {
enable = mkLspPresetEnableOption "vhdl-ls" "VHDL" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.vhdl-ls = {
enable = true;
cmd = [(getExe pkgs.vhdl-ls)];
root_markers = [".git" "vhdl_ls.toml"];
};
};
}

8
modules/plugins/treesitter/treesitter.nix
View file

@ -41,8 +41,12 @@ in {
'';
description = ''
List of treesitter grammars to install. For grammars to be installed properly,
you must use grammars from `pkgs.vimPlugins.nvim-treesitter.parsers` or `pkgs.vimPlugins.nvim-treesitter.grammarPlugins`.
You can use `pkgs.vimPlugins.nvim-treesitter.allGrammars` to install all grammars.
you must use grammars from one of those:
- `pkgs.vimPlugins.nvim-treesitter.parsers`
- `pkgs.vimPlugins.nvim-treesitter.grammarPlugins`
- `pkgs.tree-sitter-grammars` (mostly untested)
You can use `pkgs.vimPlugins.nvim-treesitter.allGrammars` to install all grammars shipped with `nvim-treesitter`.
For languages already supported by nvf, you may use
{option}`vim.language.<lang>.treesitter` options, which will automatically add

507
modules/plugins/visuals/fidget-nvim/fidget.nix
View file

@ -25,69 +25,86 @@ in {
setupOpts = mkPluginSetupOption "Fidget" {
progress = {
poll_rate = mkOption {
description = "How frequently to poll for LSP progress messages";
type = int;
default = 0;
description = "How frequently to poll for LSP progress messages";
};
suppress_on_insert = mkOption {
description = "Suppress new messages when in insert mode";
type = bool;
default = false;
description = "Suppress new messages when in insert mode";
};
ignore_done_already = mkOption {
description = "Ignore new tasks that are already done";
type = bool;
default = false;
description = "Ignore new tasks that are already done";
};
ignore_empty_message = mkOption {
description = "Ignore new tasks with empty messages";
type = bool;
default = false;
description = "Ignore new tasks with empty messages";
};
notification_group = mkOption {
description = "How to get a progress message's notification group key";
type = luaInline;
default = mkLuaInline ''
function(msg)
return msg.lsp_client.name
end
'';
description = "How to get a progress message's notification group key";
};
clear_on_detach = mkOption {
type = nullOr luaInline;
default = mkLuaInline ''
function(client_id)
local client = vim.lsp.get_client_by_id(client_id)
return client and client.name or nil
end
'';
defaultText = literalExpression ''
default = mkLuaInline '''
function(client_id)
local client = vim.lsp.get_client_by_id(client_id)
return client and client.name or nil
end
''';
'';
description = "Clear notification group when LSP server detaches";
};
ignore = mkOption {
description = "Ignore LSP servers by name";
type = listOf str;
default = [];
description = "Ignore LSP servers by name";
};
display = {
render_limit = mkOption {
description = "Maximum number of messages to render";
type = int;
default = 16;
description = "Maximum number of messages to render";
};
done_ttl = mkOption {
description = "How long a message should persist when complete";
type = int;
default = 3;
description = "How long a message should persist when complete";
};
done_icon = mkOption {
description = "Icon shown when LSP progress tasks are completed";
type = str;
default = "✓";
description = "Icon shown when LSP progress tasks are completed";
};
done_style = mkOption {
description = "Highlight group for completed LSP tasks";
type = str;
default = "Constant";
description = "Highlight group for completed LSP tasks";
};
progress_ttl = mkOption {
description = "How long a message should persist when in progress";
type = int;
default = 99999;
description = "How long a message should persist when in progress";
};
progress_icon = {
pattern = mkOption {
description = "Pattern shown when LSP progress tasks are in progress";
type = enum [
"dots"
"dots_negative"
@ -124,60 +141,208 @@ in {
"meter"
];
default = "dots";
description = "Pattern shown when LSP progress tasks are in progress";
};
period = mkOption {
description = "Period of the pattern";
type = int;
default = 1;
description = "Period of the pattern";
};
};
progress_style = mkOption {
description = "Highlight group for in-progress LSP tasks";
type = str;
default = "WarningMsg";
description = "Highlight group for in-progress LSP tasks";
};
group_style = mkOption {
description = "Highlight group for group name (LSP server name)";
type = str;
default = "Title";
description = "Highlight group for group name (LSP server name)";
};
icon_style = mkOption {
description = "Highlight group for group icons";
type = str;
default = "Question";
description = "Highlight group for group icons";
};
priority = mkOption {
description = "Priority of the progress notification";
type = int;
default = 30;
description = "Priority of the progress notification";
};
skip_history = mkOption {
description = "Skip adding messages to history";
type = bool;
default = true;
description = "Skip adding messages to history";
};
format_message = mkOption {
description = "How to format a progress message";
type = luaInline;
default = mkLuaInline ''
require("fidget.progress.display").default_format_message
'';
description = "How to format a progress message";
};
format_annote = mkOption {
description = "How to format a progress annotation";
type = luaInline;
default = mkLuaInline ''
function(msg) return msg.title end
'';
description = "How to format a progress annotation";
};
format_group_name = mkOption {
description = "How to format a progress notification group's name";
type = luaInline;
default = mkLuaInline ''
function(group) return tostring(group) end
'';
description = "How to format a progress notification group's name";
};
overrides = mkOption {
type = attrsOf (submodule {
options = {
name = mkOption {
type = nullOr (oneOf [str luaInline]);
default = null;
description = ''
Name of the group, displayed in the notification window.
Can be a string or a function that returns a string.
If a function, it is invoked every render cycle with the items
list, useful for rendering animations and other dynamic content.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L70-L77)
:::
'';
};
icon = mkOption {
type = nullOr (oneOf [str luaInline]);
default = null;
description = ''
Icon of the group, displayed in the notification window.
Can be a string or a function that returns a string.
If a function, it is invoked every render cycle with the items
list, useful for rendering animations and other dynamic content.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L70-L77)
:::
'';
};
icon_on_left = mkOption {
type = nullOr bool;
default = null;
description = "If true, icon is rendered on the left instead of right";
};
annote_separator = mkOption {
type = nullOr str;
default = " ";
description = "Separator between message from annote";
};
ttl = mkOption {
type = nullOr int;
default = 5;
description = "How long a notification item should exist";
};
render_limit = mkOption {
type = nullOr int;
default = null;
description = "How many notification items to show at once";
};
group_style = mkOption {
type = nullOr str;
default = "Title";
description = "Style used to highlight group name";
};
icon_style = mkOption {
type = nullOr str;
default = null;
description = "Style used to highlight icon, if null, use group_style";
};
annote_style = mkOption {
type = nullOr str;
default = "Question";
description = "Default style used to highlight item annotes";
};
debug_style = mkOption {
type = nullOr str;
default = null;
description = "Style used to highlight debug item annotes";
};
info_style = mkOption {
type = nullOr str;
default = null;
description = "Style used to highlight info item annotes";
};
warn_style = mkOption {
type = nullOr str;
default = null;
description = "Style used to highlight warn item annotes";
};
error_style = mkOption {
type = nullOr str;
default = null;
description = "Style used to highlight error item annotes";
};
debug_annote = mkOption {
type = nullOr str;
default = null;
description = "Default annotation for debug items";
};
info_annote = mkOption {
type = nullOr str;
default = null;
description = "Default annotation for info items";
};
warn_annote = mkOption {
type = nullOr str;
default = null;
description = "Default annotation for warn items";
};
error_annote = mkOption {
type = nullOr str;
default = null;
description = "Default annotation for error items";
};
priority = mkOption {
type = nullOr int;
default = 50;
description = "Order in which group should be displayed";
};
skip_history = mkOption {
type = nullOr bool;
default = null;
description = "Whether messages should be preserved in history";
};
update_hook = mkOption {
type = nullOr (oneOf [bool luaInline]);
default = false;
description = ''
Called when an item is updated.
If false, no action is taken.
If a function, it is invoked with the item being updated.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L114)
:::
'';
};
};
});
default = {};
example = literalExpression ''
{
rust_analyzer = {
name = "Rust Analyzer";
};
}
'';
description = ''
Overrides the default configuration for a notification group defined
in {option}`vim.visuals.fidget-nvim.setupOpts.notification.configs`.
@ -208,199 +373,51 @@ in {
}
```
'';
type = attrsOf (submodule {
options = {
name = mkOption {
description = ''
Name of the group, displayed in the notification window.
Can be a string or a function that returns a string.
If a function, it is invoked every render cycle with the items
list, useful for rendering animations and other dynamic content.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L70-L77)
:::
'';
type = nullOr (oneOf [str luaInline]);
default = null;
};
icon = mkOption {
description = ''
Icon of the group, displayed in the notification window.
Can be a string or a function that returns a string.
If a function, it is invoked every render cycle with the items
list, useful for rendering animations and other dynamic content.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L70-L77)
:::
'';
type = nullOr (oneOf [str luaInline]);
default = null;
};
icon_on_left = mkOption {
description = "If true, icon is rendered on the left instead of right";
type = nullOr bool;
default = null;
};
annote_separator = mkOption {
description = "Separator between message from annote";
type = nullOr str;
default = " ";
};
ttl = mkOption {
description = "How long a notification item should exist";
type = nullOr int;
default = 5;
};
render_limit = mkOption {
description = "How many notification items to show at once";
type = nullOr int;
default = null;
};
group_style = mkOption {
description = "Style used to highlight group name";
type = nullOr str;
default = "Title";
};
icon_style = mkOption {
description = "Style used to highlight icon, if null, use group_style";
type = nullOr str;
default = null;
};
annote_style = mkOption {
description = "Default style used to highlight item annotes";
type = nullOr str;
default = "Question";
};
debug_style = mkOption {
description = "Style used to highlight debug item annotes";
type = nullOr str;
default = null;
};
info_style = mkOption {
description = "Style used to highlight info item annotes";
type = nullOr str;
default = null;
};
warn_style = mkOption {
description = "Style used to highlight warn item annotes";
type = nullOr str;
default = null;
};
error_style = mkOption {
description = "Style used to highlight error item annotes";
type = nullOr str;
default = null;
};
debug_annote = mkOption {
description = "Default annotation for debug items";
type = nullOr str;
default = null;
};
info_annote = mkOption {
description = "Default annotation for info items";
type = nullOr str;
default = null;
};
warn_annote = mkOption {
description = "Default annotation for warn items";
type = nullOr str;
default = null;
};
error_annote = mkOption {
description = "Default annotation for error items";
type = nullOr str;
default = null;
};
priority = mkOption {
description = "Order in which group should be displayed";
type = nullOr int;
default = 50;
};
skip_history = mkOption {
description = "Whether messages should be preserved in history";
type = nullOr bool;
default = null;
};
update_hook = mkOption {
description = ''
Called when an item is updated.
If false, no action is taken.
If a function, it is invoked with the item being updated.
::: {.note}
If you're looking for detailed information into the function
signature, you can refer to the fidget API documentation available
[here](https://github.com/j-hui/fidget.nvim/blob/1ba38e4cbb24683973e00c2e36f53ae64da38ef5/doc/fidget-api.txt#L114)
:::
'';
type = nullOr (oneOf [bool luaInline]);
default = false;
};
};
});
default = {};
example = literalExpression ''
{
rust_analyzer = {
name = "Rust Analyzer";
};
}
'';
};
};
lsp = {
progress_ringbuf_size = mkOption {
description = "Nvim's LSP client ring buffer size";
type = int;
default = 100;
description = "Nvim's LSP client ring buffer size";
};
log_handler = mkOption {
description = "Log `$/progress` handler invocations";
type = bool;
default = false;
description = "Log `$/progress` handler invocations";
};
};
};
notification = {
poll_rate = mkOption {
description = "How frequently to update and render notifications";
type = int;
default = 10;
description = "How frequently to update and render notifications";
};
filter = mkOption {
description = "Minimum notifications level";
type = enum ["debug" "info" "warn" "error"];
default = "info";
description = "Minimum notifications level";
apply = filter: mkLuaInline "vim.log.levels.${toUpper filter}";
};
history_size = mkOption {
description = "Number of removed messages to retain in history";
type = int;
default = 128;
description = "Number of removed messages to retain in history";
};
override_vim_notify = mkOption {
description = "Automatically override vim.notify() with Fidget";
type = bool;
default = false;
description = "Automatically override vim.notify() with Fidget";
};
configs = mkOption {
description = "How to configure notification groups when instantiated";
type = attrsOf luaInline;
default = {default = mkLuaInline "require('fidget.notification').default_config";};
description = "How to configure notification groups when instantiated";
};
redirect = mkOption {
description = "Conditionally redirect notifications to another backend";
type = luaInline;
default = mkLuaInline ''
function(msg, level, opts)
@ -409,142 +426,206 @@ in {
end
end
'';
description = "Conditionally redirect notifications to another backend";
};
view = {
stack_upwards = mkOption {
description = "Display notification items from bottom to top";
type = bool;
default = true;
description = "Display notification items from bottom to top";
};
align = mkOption {
type = enum ["message" "annote"];
default = "message";
description = "Indent messages longer than a single line";
};
reflow = mkOption {
type = enum ["hard" "hyphenate" "ellipsis" "false"];
default = "false";
description = ''
Reflow (wrap) messages wider than notification window
The various options determine how wrapping is handled mid-word.
'';
};
icon_separator = mkOption {
description = "Separator between group name and icon";
type = str;
default = " ";
description = "Separator between group name and icon";
};
group_separator = mkOption {
description = "Separator between notification groups";
type = str;
default = "---";
description = "Separator between notification groups";
};
group_separator_hl = mkOption {
description = "Highlight group used for group separator";
type = str;
default = "Comment";
description = "Highlight group used for group separator";
};
line_margin = mkOption {
type = int;
default = 1;
description = ''
Spaces to pad both sides of each non-empty line
Useful for adding a visual gap between notification text
and any buffer it may overlap with.
'';
};
render_message = mkOption {
description = "How to render notification messages";
type = luaInline;
default = mkLuaInline ''
function(msg, cnt)
return cnt == 1 and msg or string.format("(%dx) %s", cnt, msg)
end
'';
description = "How to render notification messages";
};
};
window = {
normal_hl = mkOption {
description = "Base highlight group in the notification window";
type = str;
default = "Comment";
description = "Base highlight group in the notification window";
};
winblend = mkOption {
description = "Background color opacity in the notification window";
type = int;
default = 100;
description = "Background color opacity in the notification window";
};
border = mkOption {
description = "Border style of the notification window";
type = borderType;
default =
if config.vim.ui.borders.enable
then config.vim.ui.borders.globalStyle
else "none";
description = "Border style of the notification window";
};
border_hl = mkOption {
type = str;
default = "";
description = ''
Highlight group for notification window border
Set to empty string to keep your theme's default `FloatBorder` highlight.
'';
};
zindex = mkOption {
description = "Stacking priority of the notification window";
type = int;
default = 45;
description = "Stacking priority of the notification window";
};
max_width = mkOption {
description = "Maximum width of the notification window";
type = int;
default = 0;
description = "Maximum width of the notification window";
};
max_height = mkOption {
description = "Maximum height of the notification window";
type = int;
default = 0;
description = "Maximum height of the notification window";
};
x_padding = mkOption {
description = "Padding from right edge of window boundary";
type = int;
default = 1;
description = "Padding from right edge of window boundary";
};
y_padding = mkOption {
description = "Padding from bottom edge of window boundary";
type = int;
default = 0;
description = "Padding from bottom edge of window boundary";
};
align = mkOption {
description = "How to align the notification window";
type = enum ["top" "bottom"];
default = "bottom";
description = "How to align the notification window";
};
relative = mkOption {
description = "What the notification window position is relative to";
type = enum ["editor" "win"];
default = "editor";
description = "What the notification window position is relative to";
};
};
};
integration = {
nvim-tree = {
enable = mkOption {
description = "Integrate with nvim-tree/nvim-tree.lua (if enabled)";
type = bool;
default =
if config.vim.filetree.nvimTree.enable
then true
else false;
tabstop = mkOption {
type = int;
default = 8;
description = "Width of each tab character in the notification window";
};
};
xcodebuild-nvim = {
enable = mkOption {
description = "Integrate with wojciech-kulik/xcodebuild.nvim (if enabled)";
type = bool;
default = true;
avoid = mkOption {
type = listOf str;
default = [];
description = "Filetypes the notification window should avoid";
};
};
};
logger = {
level = mkOption {
description = "Minimum logging level";
type = enum ["debug" "error" "info" "trace" "warn" "off"];
default = "warn";
description = "Minimum logging level";
apply = logLevel: mkLuaInline "vim.log.levels.${toUpper logLevel}";
};
max_size = mkOption {
description = "Maximum log file size, in KB";
type = int;
default = 10000;
description = "Maximum log file size, in KB";
};
float_precision = mkOption {
description = "Limit the number of decimals displayed for floats";
type = float;
default = 0.01;
description = "Limit the number of decimals displayed for floats";
};
path = mkOption {
description = "Where Fidget writes its logs to";
type = luaInline;
default = mkLuaInline ''
string.format("%s/fidget.nvim.log", vim.fn.stdpath("cache"))
'';
description = "Where Fidget writes its logs to";
};
};
# removed, see below
integration = {
nvim-tree.enable = mkOption {
default = null;
visible = false;
};
xcodebuild-nvim.enable = mkOption {
default = null;
visible = false;
};
};
};
};
# this can't be done better, I tried
# mostly mostly caused by the deprecated options being inside a submodule
# try improving this if you don't care about your sanity
# ~ poz
config = {
assertions = let
inherit (config.vim.visuals.fidget-nvim.setupOpts) integration;
in [
{
assertion = integration.nvim-tree.enable == null;
message = ''
Option `vim.visuals.fidget-nvim.setupOpts.integration.nvim-tree.enable`
has been deprecated upstream. Use
`vim.visuals.fidget-nvim.setupOpts.notification.window.avoid = ["NvimTree"]` instead.
This is already set if `vim.filetree.nvimTree.enable == true`.
'';
}
{
assertion = integration.xcodebuild-nvim.enable == null;
message = ''
Option `vim.visuals.fidget-nvim.setupOpts.integration.xcodebuild-nvim.enable`
has been deprecated upstream. Use
`vim.visuals.fidget-nvim.setupOpts.notification.window.avoid = ["TestExplorer"]` instead.
'';
}
];
};
}

2
modules/wrapper/rc/config.nix
View file

@ -18,7 +18,7 @@ in {
mapAttrsToList (name: value: "vim.g.${name} = ${toLuaObject value}") cfg.globals;
optionsScript =
mapAttrsToList (name: value: "vim.o.${name} = ${toLuaObject value}") cfg.options;
mapAttrsToList (name: value: "vim.opt.${name} = ${toLuaObject value}") cfg.options;
extraPluginConfigs = resolveDag {
name = "extra plugin configs";

6
modules/wrapper/rc/options.nix
View file

@ -266,9 +266,9 @@ in {
after `basic` and before `pluginConfigs` DAG entries.
::: {.note}
`{foo = "bar";}` will set `vim.o.foo` to "bar", where the type of `bar` in the
resulting Lua value will be inferred from the type of the value in the
`{name = value;}` pair passed to the option.
`{foo = "bar";}` will set `vim.opt.foo` to "bar", where the type of
`bar` in the resulting Lua value will be inferred from the type of the
value in the `{name = value;}` pair passed to the option.
:::
'';
};

729
npins/sources.json
View file

File diff suppressed because it is too large Load diff