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

Merge pull request #1514 from snoweuph/feat/lsp

Browse source 
LSP Refactoring
This commit is contained in:
Snoweuph 2026-04-15 18:15:51 +02:00 • committed by GitHub
commit a173237430
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
136 changed files with 3554 additions and 2415 deletions
Download patch file Download diff file Expand all files Collapse all files

3
configuration.nix
View file

@ -34,7 +34,7 @@ isMaximal: {
lspSignature.enable = !isMaximal; # conflicts with blink in maximal
otter-nvim.enable = isMaximal;
nvim-docs-view.enable = isMaximal;
harper-ls.enable = isMaximal;
presets.harper.enable = isMaximal;
};
debugger = {
@ -103,7 +103,6 @@ isMaximal: {
make.enable = false;
qml.enable = false;
jinja.enable = false;
tailwind.enable = false;
svelte.enable = false;
liquid.enable = false;
tera.enable = false;

2
docs/manual/configuring/languages.md
View file

@ -75,8 +75,6 @@ languages have sections under the `vim.languages` attribute.
[vim.languages.scala.enable](./options.html#option-vim-languages-scala-enable)
- Svelte:
[vim.languages.svelte.enable](./options.html#option-vim-languages-svelte-enable)
- Tailwind:
[vim.languages.tailwind.enable](./options.html#option-vim-languages-tailwind-enable)
- Terraform:
[vim.languages.terraform.enable](./options.html#option-vim-languages-terraform-enable)
- Typst:

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

@ -63,6 +63,45 @@
- Added `json5` into `languages.json`. Some options where renamed.
- Moved `vim.lsp.harper-ls` to `vim.lsp.presets.haper`.
- Removed `typst_lsp` from `languages.typst.lsp.servers`, because it is
deprecated and thus was pulled from nixpkgs.
<https://github.com/NixOS/nixpkgs/commit/bf24296bbe2e31ac7147b02ea645922390ca8f4b>
- Renamed `ts_ls` to `typescript-language-server`.
- Renamed `denols` to `deno`.
- Renamed `tsgo` to `typescript-go`.
- Renamed `vala_ls` to `vala-language-server`.
- Renamed `terraformls-tf` and `terraformls-hcl` to `terraform-ls`.
- Renamed `tofuls-tf` and `tofuls-hcl` to `tofu-ls`.
- Renamed `ruby_lsp` to `ruby-lsp`.
- Renamed `r_language_server` to `r-languageserver`.
- Renamed `julials` to `julia-languageserver`.
- Renamed `astro` to `astro-language-server`.
- Renamed `bash-ls` to `bash-language-server`.
- Renamed `jsonls` to `vscode-json-language-server`.
- Renamed `cssls` to `vscode-css-language-server`.
- Renamed `jdtls` to `jdt-language-server`.
- Renamed `elixirls` to `elixir-ls`.
- Removed `languages.tailwind` which only provided an LSP. Use
`lsp.presets.tailwindcss-language-server` instead.
## Changelog {#sec-release-0-9-changelog}
[SecBear](https://github.com/SecBear):
@ -195,6 +234,7 @@
{command}`:healthcheck` doesn't know that.
- Remove [which-key.nvim] `<leader>o` `+Notes` description which did not
actually correspond to any keybinds.
- Allow disabling nvf's vendored keymaps by toggling `vendoredKeymaps.enable`.
[pyrox0](https://github.com/pyrox0):
@ -229,6 +269,13 @@
[Snoweuph](https://github.com/snoweuph)
- Added `vim.lsp.presets.<name>` to contain LSP configurations. This allows for
more flexibility in nvf and reuse of LSPs across languages. Dropped
`deprecatedSingleOrListOf` in favor of `listOf` for the affected LSP options.
- Fix `vim.lsp.presets.vala-language-server` to be wrapped correctly with
`uncrustify`.
- Fix `tressiter` to allow `null` in grammar options, so they can be filtered
out.

28
lib/types/custom.nix
View file

@ -1,9 +1,9 @@
{lib}: let
inherit (builtins) toJSON;
inherit (builtins) toJSON attrNames;
inherit (lib.options) mergeEqualOption;
inherit (lib.lists) singleton;
inherit (lib.strings) isString stringLength match;
inherit (lib.types) listOf mkOptionType coercedTo;
inherit (lib.types) listOf mkOptionType coercedTo enum;
inherit (lib.trivial) warn;
in {
mergelessListOf = elemType:
@ -39,4 +39,28 @@ in {
''
(singleton x))
(listOf t);
# Create an enum type for `values`, which additionally accepts deprecated
# values listed in the `renames` attrset as `old = new` pairs.
#
# Example:
#
# vim.languages.typescript.lsp.servers = mkOption {
# type = renamedEnum
# "vim.languages.typescript.lsp.servers"
# ["typescript-language-server" "some-other-server"]
# { ts_ls = "typescript-language-server"; };
# }
#
# With this option definition, when users enter `ts_ls`, they
# get a warning "`ts_ls` is deprecated, use `typescript-language-server`
# instead", and typescript-language-server is automatically used.
enumWithRename = option: values: renames:
coercedTo (enum (attrNames renames)) (
old:
warn
"${option}: `${old}` is deprecated, use `${renames.${old}}` instead"
renames.${old}
)
(enum values);
}

4
lib/types/default.nix
View file

@ -5,10 +5,12 @@
typesDag = import ./dag.nix {inherit lib;};
typesPlugin = import ./plugins.nix {inherit lib self;};
typesLanguage = import ./languages.nix {inherit lib;};
typesLsp = import ./lsp.nix {inherit lib;};
customTypes = import ./custom.nix {inherit lib;};
in {
inherit (typesDag) dagOf;
inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
inherit (typesLanguage) diagnostics mkGrammarOption;
inherit (customTypes) char hexColor mergelessListOf deprecatedSingleOrListOf;
inherit (typesLsp) mkLspPresetEnableOption;
inherit (customTypes) char hexColor mergelessListOf deprecatedSingleOrListOf enumWithRename;
}

12
lib/types/lsp.nix Normal file
View file

@ -0,0 +1,12 @@
{lib}: let
inherit (lib.options) mkEnableOption;
mkLspPresetEnableOption = option: display: fileTypes:
mkEnableOption ''
the ${display} Language Server.
Default `filetypes = ${lib.generators.toPretty {} fileTypes}`.
Use {option}`vim.lsp.servers.${option}` for customization
'';
in {
inherit mkLspPresetEnableOption;
}

9
modules/extra/deprecations.nix
View file

@ -242,9 +242,6 @@ in {
(mkRenamedLspServer "svelte")
(mkRemovedLspPackage "svelte")
(mkRenamedLspServer "tailwind")
(mkRemovedLspPackage "tailwind")
(mkRemovedLspPackage "terraform")
(mkRenamedLspServer "ts")
@ -347,5 +344,11 @@ in {
[
(mkRenamedOptionModule ["vim" "treesitter" "foldByDefault"] ["vim" "options" "foldenable"])
]
# 2026-13-04
[
(mkRenamedOptionModule ["vim" "lsp" "harper-ls" "enable"] ["vim" "lsp" "presets" "harper" "enable"])
(mkRenamedOptionModule ["vim" "lsp" "harper-ls" "settings"] ["vim" "lsp" "servers" "harper" "settings"])
]
];
}

56
modules/plugins/languages/arduino.nix
View file

@ -4,54 +4,16 @@
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.generators) mkLuaInline;
inherit (lib.meta) getExe getExe';
inherit (lib) genAttrs;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) enum listOf str;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.arduino;
defaultServers = ["arduino-language-server"];
servers = {
arduino-language-server = {
enable = true;
cmd =
[
(getExe pkgs.arduino-language-server)
"-clangd"
(getExe' pkgs.clang-tools "clangd")
"-cli"
(getExe pkgs.arduino-cli)
"-cli-config"
"$HOME/.arduino15/arduino-cli.yaml"
]
++ cfg.lsp.extraArgs;
filetypes = ["arduino"];
root_dir =
mkLuaInline
/*
lua
*/
''
function(bufnr, on_dir)
local fname = vim.api.nvim_buf_get_name(bufnr)
on_dir(util.root_pattern("*.ino")(fname))
end
'';
capabilities = {
textDocument = {
semanticTokens = mkLuaInline "vim.NIL";
};
workspace = {
semanticTokens = mkLuaInline "vim.NIL";
};
};
};
};
servers = ["arduino-language-server"];
in {
options.vim.languages.arduino = {
enable = mkEnableOption "Arduino support";
@ -74,7 +36,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Arduino LSP servers to use";
};
@ -94,12 +56,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["arduino"];
});
};
})
]);
}

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

@ -4,24 +4,15 @@
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.meta) getExe;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.types) enum listOf;
inherit (lib) genAttrs;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.assembly;
defaultServers = ["asm-lsp"];
servers = {
asm-lsp = {
enable = true;
cmd = [(getExe pkgs.asm-lsp)];
filetypes = ["asm" "nasm" "masm" "vmasm" "fasm" "tasm" "tiasm" "asm68k" "asm8300"];
root_markers = [".asm-lsp.toml" ".git"];
};
};
servers = ["asm-lsp"];
in {
options.vim.languages.assembly = {
enable = mkEnableOption "Assembly support";
@ -46,7 +37,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.asm.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Assembly LSP server to use";
};
@ -63,12 +54,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["asm" "nasm" "masm" "vmasm" "fasm" "tasm" "tiasm" "asm68k" "asm8300"];
});
};
})
]);
}

51
modules/plugins/languages/astro.nix
View file

@ -9,37 +9,15 @@
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib.types) enum coercedTo;
inherit (lib.types) enum coercedTo listOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf enumWithRename;
inherit (lib) genAttrs;
cfg = config.vim.languages.astro;
defaultServers = ["astro"];
servers = {
astro = {
enable = true;
cmd = [(getExe pkgs.astro-language-server) "--stdio"];
filetypes = ["astro"];
root_markers = ["package.json" "tsconfig.json" "jsconfig.json" ".git"];
init_options = {
typescript = {};
};
before_init =
mkLuaInline
/*
lua
*/
''
function(_, config)
if config.init_options and config.init_options.typescript and not config.init_options.typescript.tsdk then
config.init_options.typescript.tsdk = util.get_typescript_server_path(config.root_dir)
end
end
'';
};
};
defaultServers = ["astro-language-server"];
servers = ["astro-language-server"];
defaultFormat = ["prettier"];
formats = let
@ -107,7 +85,12 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.astro.lsp.servers" (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.astro.lsp.servers"
servers
{
astro = "astro-language-server";
});
default = defaultServers;
description = "Astro LSP server to use";
};
@ -151,12 +134,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["astro"];
});
};
})
(mkIf cfg.format.enable {

41
modules/plugins/languages/bash.nix
View file

@ -8,27 +8,15 @@
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum bool;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.types) diagnostics mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.types) enum bool listOf;
inherit (lib) genAttrs;
inherit (lib.nvim.types) diagnostics mkGrammarOption deprecatedSingleOrListOf enumWithRename;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.bash;
defaultServers = ["bash-ls"];
servers = {
bash-ls = {
enable = true;
cmd = [(getExe pkgs.bash-language-server) "start"];
filetypes = ["bash" "sh"];
root_markers = [".git"];
settings = {
basheIde = {
globPattern = mkLuaInline "vim.env.GLOB_PATTERN or '*@(.sh|.inc|.bash|.command)'";
};
};
};
};
defaultServers = ["bash-language-server"];
servers = ["bash-language-server"];
defaultFormat = ["shfmt"];
formats = {
@ -65,7 +53,12 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.bash.lsp.servers" (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.bash.lsp.servers"
servers
{
bash-ls = "bash-language-server";
});
default = defaultServers;
description = "Bash LSP server to use";
};
@ -107,12 +100,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["bash" "sh" "zsh"];
});
};
})
(mkIf cfg.format.enable {

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

@ -6,141 +6,16 @@
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) bool enum package;
inherit (lib.meta) getExe;
inherit (lib.types) bool enum package listOf;
inherit (lib) genAttrs;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.dag) entryAfter;
cfg = config.vim.languages.clang;
defaultServers = ["clangd"];
servers = {
ccls = {
cmd = [(getExe pkgs.ccls)];
filetypes = ["c" "cpp" "objc" "objcpp" "cuda"];
offset_encoding = "utf-32";
root_markers = ["compile_commands.json" ".ccls" ".git"];
workspace_required = true;
on_attach = mkLuaInline ''
function(client, bufnr)
local function switch_source_header(bufnr)
local method_name = "textDocument/switchSourceHeader"
local params = vim.lsp.util.make_text_document_params(bufnr)
client:request(method_name, params, function(err, result)
if err then
error(tostring(err))
end
if not result then
vim.notify('corresponding file cannot be determined')
return
end
vim.cmd.edit(vim.uri_to_fname(result))
end, bufnr)
end
vim.api.nvim_buf_create_user_command(
bufnr,
"LspCclsSwitchSourceHeader",
function(arg)
switch_source_header(client, 0)
end,
{desc = "Switch between source/header"}
)
end
'';
};
clangd = {
cmd = ["${pkgs.clang-tools}/bin/clangd"];
filetypes = ["c" "cpp" "objc" "objcpp" "cuda" "proto"];
root_markers = [
".clangd"
".clang-tidy"
".clang-format"
"compile_commands.json"
"compile_flags.txt"
"configure.ac"
".git"
];
capabilities = {
textDocument = {
completion = {
editsNearCursor = true;
};
};
offsetEncoding = ["utf-8" "utf-16"];
};
on_attach = mkLuaInline ''
function(client, bufnr)
local function switch_source_header(bufnr)
local method_name = "textDocument/switchSourceHeader"
local client = vim.lsp.get_clients({ bufnr = bufnr, name = "clangd", })[1]
if not client then
return vim.notify(('method %s is not supported by any servers active on the current buffer'):format(method_name))
end
local params = vim.lsp.util.make_text_document_params(bufnr)
client.request(method_name, params, function(err, result)
if err then
error(tostring(err))
end
if not result then
vim.notify('corresponding file cannot be determined')
return
end
vim.cmd.edit(vim.uri_to_fname(result))
end, bufnr)
end
local function symbol_info()
local bufnr = vim.api.nvim_get_current_buf()
local clangd_client = vim.lsp.get_clients({ bufnr = bufnr, name = "clangd" })[1]
if not clangd_client or not clangd_client:supports_method 'textDocument/symbolInfo' then
return vim.notify('Clangd client not found', vim.log.levels.ERROR)
end
local win = vim.api.nvim_get_current_win()
local params = vim.lsp.util.make_position_params(win, clangd_client.offset_encoding)
clangd_client:request('textDocument/symbolInfo', params, function(err, res)
if err or #res == 0 then
-- Clangd always returns an error, there is not reason to parse it
return
end
local container = string.format('container: %s', res[1].containerName) ---@type string
local name = string.format('name: %s', res[1].name) ---@type string
vim.lsp.util.open_floating_preview({ name, container }, "", {
height = 2,
width = math.max(string.len(name), string.len(container)),
focusable = false,
focus = false,
border = 'single',
title = 'Symbol Info',
})
end, bufnr)
end
vim.api.nvim_buf_create_user_command(
bufnr,
"ClangdSwitchSourceHeader",
function(arg)
switch_source_header(0)
end,
{desc = "Switch between source/header"}
)
vim.api.nvim_buf_create_user_command(
bufnr,
"ClangdShowSymbolInfo",
function(arg)
symbol_info()
end,
{desc = "Show symbol info"}
)
end
'';
};
};
servers = ["ccls" "clangd"];
defaultDebugger = "lldb-vscode";
debuggers = {
@ -204,7 +79,7 @@ in {
servers = mkOption {
description = "The clang LSP server to use";
type = deprecatedSingleOrListOf "vim.language.clang.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
};
};
@ -240,12 +115,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (name: {
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["c" "cpp" "objc" "objcpp" "cuda" "proto"];
});
};
})
(mkIf cfg.dap.enable {

28
modules/plugins/languages/clojure.nix
View file

@ -4,25 +4,16 @@
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib) genAttrs;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.clojure;
defaultServers = ["clojure-lsp"];
servers = {
clojure-lsp = {
enable = true;
cmd = [(getExe pkgs.clojure-lsp)];
filetypes = ["clojure" "edn"];
root_markers = ["project.clj" "deps.edn" "build.boot" "shadow-cljs.edn" ".git" "bb.edn"];
};
};
servers = ["clojure-lsp"];
in {
options.vim.languages.clojure = {
enable = mkEnableOption "Clojure language support";
@ -45,7 +36,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Clojure LSP server to use";
};
@ -54,12 +45,13 @@ in {
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["clojure" "edn"];
root_markers = ["deps.edn" "build.boot" "shadow-cljs.edn" "bb.edn"];
});
};
})
(mkIf cfg.treesitter.enable {

29
modules/plugins/languages/cmake.nix
View file

@ -7,25 +7,15 @@
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.types) enum listOf package;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.cmake;
defaultServers = ["neocmakelsp"];
servers = {
neocmakelsp = {
enable = true;
cmd = [(getExe pkgs.neocmakelsp) "stdio"];
filetypes = ["cmake"];
root_markers = [".gersemirc" ".git" "build" "cmake"];
capabilities = {
textDocument.completion.completionItem.snippetSupport = true;
};
};
};
servers = ["neocmakelsp"];
defaultFormat = "gersemi";
formats = {
@ -55,7 +45,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "CMake LSP servers to use";
};
@ -90,12 +80,13 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["cmake"];
root_markers = ["build" "cmake"];
});
};
})
(mkIf cfg.format.enable {

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

@ -6,29 +6,17 @@
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf enumWithRename;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.css;
defaultServer = ["cssls"];
servers = {
cssls = {
cmd = ["${pkgs.vscode-langservers-extracted}/bin/vscode-css-language-server" "--stdio"];
filetypes = ["css" "scss" "less"];
# needed to enable formatting
init_options = {provideFormatter = true;};
root_markers = [".git" "package.json"];
settings = {
css.validate = true;
scss.validate = true;
less.validate = true;
};
};
};
defaultServer = ["vscode-css-language-server"];
servers = ["vscode-css-language-server"];
defaultFormat = ["prettier"];
formats = {
@ -68,7 +56,12 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.css.lsp.servers" (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.css.lsp.servers"
servers
{
cssls = "vscode-css-language-server";
});
default = defaultServer;
description = "CSS LSP server to use";
};
@ -92,12 +85,17 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (name: {
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = [
"css"
# TODO: split in their own modules
"scss"
"less"
];
});
};
})
(mkIf cfg.format.enable {

25
modules/plugins/languages/cue.nix
View file

@ -4,16 +4,14 @@
lib,
...
}: let
inherit (lib.options) mkEnableOption literalExpression;
inherit (lib.meta) getExe;
inherit (lib.options) mkEnableOption literalExpression mkOption;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.types) enum listOf;
inherit (lib) genAttrs;
lspOptions = {
cmd = [(getExe pkgs.cue) "lsp"];
filetypes = ["cue"];
root_markers = ["cue.mod" ".git"];
};
defaultServers = ["cue"];
servers = ["cue"];
cfg = config.vim.languages.cue;
in {
@ -38,6 +36,12 @@ in {
default = config.vim.lsp.enable;
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum servers);
default = defaultServers;
description = "CUE LSP server to use";
};
};
};
@ -48,7 +52,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers.cue = lspOptions;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["cue"];
});
};
})
]);
}

44
modules/plugins/languages/dart.nix
View file

@ -4,42 +4,20 @@
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib) genAttrs;
inherit (lib.trivial) boolToString;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) enum package nullOr str bool;
inherit (lib.types) enum package nullOr str bool listOf;
inherit (lib.strings) optionalString;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.dag) entryAfter;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.dart;
ftcfg = cfg.flutter-tools;
defaultServers = ["dart"];
servers = {
dart = {
enable = true;
cmd = [(getExe pkgs.dart) "language-server" "--protocol=lsp"];
filetypes = ["dart"];
root_markers = ["pubspec.yaml"];
init_options = {
onlyAnalyzeProjectsWithOpenFiles = true;
suggestFromUnimportedLibraries = true;
closingLabels = true;
outline = true;
flutterOutline = true;
};
settings = {
dart = {
completeFunctionCalls = true;
showTodos = true;
};
};
};
};
servers = ["dart"];
in {
options.vim.languages.dart = {
enable = mkEnableOption "Dart language support";
@ -62,7 +40,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.dart.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Dart LSP server to use";
};
@ -142,12 +120,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["dart"];
});
};
})
(mkIf ftcfg.enable {

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

@ -45,7 +45,6 @@ in {
./scala.nix
./sql.nix
./svelte.nix
./tailwind.nix
./terraform.nix
./toml.nix
./ts.nix

51
modules/plugins/languages/elixir.nix
View file

@ -7,38 +7,16 @@
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib.types) enum;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib) genAttrs;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf enumWithRename;
inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.elixir;
defaultServers = ["elixirls"];
servers = {
elixirls = {
enable = true;
cmd = [(getExe pkgs.elixir-ls)];
filetypes = ["elixir" "eelixir" "heex" "surface"];
root_dir =
mkLuaInline
/*
lua
*/
''
function(bufnr, on_dir)
local fname = vim.api.nvim_buf_get_name(bufnr)
local matches = vim.fs.find({ 'mix.exs' }, { upward = true, limit = 2, path = fname })
local child_or_root_path, maybe_umbrella_path = unpack(matches)
local root_dir = vim.fs.dirname(maybe_umbrella_path or child_or_root_path)
on_dir(root_dir)
end
'';
};
};
defaultServers = ["elixir-ls"];
servers = ["elixir-ls"];
defaultFormat = ["mix"];
formats = {
@ -70,7 +48,12 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.elixir.lsp.servers" (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.elixir.lsp.servers"
servers
{
elixirls = "elixir-ls";
});
default = defaultServers;
description = "Elixir LSP server to use";
};
@ -102,12 +85,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["elixir" "eelixir" "heex" "surface"];
});
};
})
(mkIf cfg.format.enable {

32
modules/plugins/languages/elm.nix
View file

@ -4,26 +4,16 @@
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.meta) getExe;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib) genAttrs;
cfg = config.vim.languages.elm;
defaultServers = ["elm-language-server"];
servers = {
elm-language-server = {
enable = true;
cmd = [(getExe pkgs.elmPackages.elm-language-server)];
filetypes = ["elm"];
root_markers = ["elm.json"];
workspace_required = false;
};
};
servers = ["elm-language-server"];
in {
options.vim.languages.elm = {
enable = mkEnableOption "Elm language support";
@ -47,7 +37,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.elm.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Elm LSP servers to use";
};
@ -63,13 +53,11 @@ in {
})
(mkIf cfg.lsp.enable {
vim = {
lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["elm"];
});
};
})
]);

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

@ -6,50 +6,15 @@
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) enum;
inherit (lib.types) enum listOf;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
defaultServer = ["fsautocomplete"];
servers = {
fsautocomplete = {
cmd = [(getExe pkgs.fsautocomplete) "--adaptive-lsp-server-enabled"];
filetypes = ["fsharp"];
root_dir = mkLuaInline ''
function(bufnr, on_dir)
on_dir(vim.fs.root(bufnr, function(name, path)
return name == ".git" or name:match("%.sln$") or name:match("%.fsproj$")
end))
end
'';
init_options = {
AutomaticWorkspaceInit = true;
};
settings = {
FSharp = {
keywordsAutocomplete = true;
ExternalAutocomplete = false;
Linter = true;
UnionCaseStubGeneration = true;
UnionCaseStubGenerationBody = ''failwith "Not Implemented"'';
RecordStubGeneration = true;
RecordStubGenerationBody = ''failwith "Not Implemented"'';
InterfaceStubGeneration = true;
InterfaceStubGenerationObjectIdentifier = "this";
InterfaceStubGenerationMethodBody = ''failwith "Not Implemented"'';
UnusedOpensAnalyzer = true;
UnusedDeclarationsAnalyzer = true;
UseSdkScripts = true;
SimplifyNameAnalyzer = true;
ResolveNamespaces = true;
EnableReferenceCodeLens = true;
};
};
};
};
servers = ["fsautocomplete"];
defaultFormat = ["fantomas"];
formats = {
@ -82,7 +47,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.fsharp.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServer;
description = "F# LSP server to use";
};
@ -106,12 +71,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (name: {
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["fsharp"];
});
};
})
(mkIf cfg.format.enable {

31
modules/plugins/languages/gleam.nix
View file

@ -4,25 +4,16 @@
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib.types) enum;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib) genAttrs;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.gleam;
defaultServers = ["gleam"];
servers = {
gleam = {
enable = true;
cmd = [(getExe pkgs.gleam) "lsp"];
filetypes = ["gleam"];
root_markers = ["gleam.toml" ".git"];
};
};
servers = ["gleam"];
in {
options.vim.languages.gleam = {
enable = mkEnableOption "Gleam language support";
@ -45,7 +36,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.gleam.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Gleam LSP server to use";
};
@ -59,12 +50,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["gleam"];
});
};
})
]);
}

27
modules/plugins/languages/glsl.nix
View file

@ -4,25 +4,16 @@
pkgs,
...
}: let
inherit (builtins) attrNames;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) enum listOf;
inherit (lib.meta) getExe;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib) genAttrs;
cfg = config.vim.languages.glsl;
defaultServers = ["glsl_analyzer"];
servers = {
glsl_analyzer = {
enable = true;
cmd = [(getExe pkgs.glsl_analyzer)];
filetypes = ["glsl" "vert" "tesc" "tese" "frag" "geom" "comp"];
root_markers = [".git"];
};
};
servers = ["glsl_analyzer"];
in {
options.vim.languages.glsl = {
enable = mkEnableOption "GLSL language support";
@ -46,7 +37,7 @@ in {
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "GLSL LSP server to use";
};
@ -62,12 +53,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["glsl" "vert" "tesc" "tese" "frag" "geom" "comp"];
});
};
})
]);
}

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

@ -9,8 +9,9 @@
inherit (lib.options) mkEnableOption mkOption literalMD literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib) genAttrs;
inherit (lib.generators) mkLuaInline;
inherit (lib.types) bool enum package str;
inherit (lib.types) enum package str listOf;
inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf mkPluginSetupOption;
inherit (lib.nvim.dag) entryAfter;
inherit (lib.nvim.attrsets) mapListToAttrs;
@ -18,47 +19,7 @@
cfg = config.vim.languages.go;
defaultServers = ["gopls"];
servers = {
gopls = {
cmd = [(getExe pkgs.gopls)];
filetypes = ["go" "gomod" "gosum" "gowork" "gotmpl"];
root_dir = mkLuaInline ''
function(bufnr, on_dir)
local fname = vim.api.nvim_buf_get_name(bufnr)
local function get_root(fname)
if _G.nvf_gopls_mod_cache and fname:sub(1, #_G.nvf_gopls_mod_cache) == _G.nvf_gopls_mod_cache then
local clients = vim.lsp.get_clients { name = 'gopls' }
if #clients > 0 then
return clients[#clients].config.root_dir
end
end
return vim.fs.root(fname, 'go.work') or vim.fs.root(fname, 'go.mod') or vim.fs.root(fname, '.git')
end
-- see: https://github.com/neovim/nvim-lspconfig/issues/804
if _G.nvf_gopls_mod_cache then
on_dir(get_root(fname))
return
end
local cmd = { 'go', 'env', 'GOMODCACHE' }
local ok, err = pcall(vim.system, cmd, { text = true }, function(output)
if output.code == 0 then
if output.stdout then
_G.nvf_gopls_mod_cache = vim.trim(output.stdout)
end
on_dir(get_root(fname))
else
vim.schedule(function()
vim.notify(('[gopls] cmd failed with code %d: %s\n%s'):format(output.code, cmd, output.stderr))
end)
end
end)
if not ok then vim.notify(('[gopls] cmd failed: %s\n%s'):format(cmd, err)) end
end
'';
};
};
servers = ["gopls"];
defaultFormat = ["gofmt"];
formats = {
@ -194,7 +155,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.go.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Go LSP server to use";
};
@ -319,12 +280,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (name: {
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["go" "gomod" "gosum" "gowork" "gotmpl"];
});
};
})
(mkIf cfg.format.enable {

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

@ -6,30 +6,17 @@
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.types) mkGrammarOption enumWithRename;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.hcl;
defaultServers = ["tofuls-hcl"];
servers = {
terraformls-hcl = {
enable = true;
cmd = [(getExe pkgs.terraform-ls) "serve"];
filetypes = ["hcl"];
root_markers = [".git"];
};
tofuls-hcl = {
enable = true;
cmd = [(getExe pkgs.tofu-ls) "serve"];
filetypes = ["hcl"];
root_markers = [".terraform" ".git"];
};
# TODO: package nomad-lsp and offer as an option here too
};
defaultServers = ["tofu-ls"];
servers = ["terraform-ls" "tofu-ls"];
defaultFormat = ["hclfmt"];
formats = {
@ -64,7 +51,13 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.hcl.lsp.servers"
servers
{
terraformls-hcl = "terraform-ls";
tofuls-hcl = "tofu-ls";
});
default = defaultServers;
description = "HCL LSP server to use";
};
@ -116,13 +109,11 @@ in {
})
(mkIf cfg.lsp.enable {
vim = {
lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["hcl"];
});
};
})

49
modules/plugins/languages/helm.nix
View file

@ -4,41 +4,16 @@
lib,
...
}: let
inherit (builtins) attrNames head;
inherit (lib.options) literalExpression mkEnableOption mkOption;
inherit (lib.modules) mkDefault mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib.types) enum;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.modules) mkIf mkMerge;
inherit (lib) genAttrs;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.helm;
yamlCfg = config.vim.languages.yaml;
defaultServers = ["helm-ls"];
servers = {
helm-ls = {
enable = true;
cmd = [(getExe pkgs.helm-ls) "serve"];
filetypes = ["helm" "yaml.helm-values"];
root_markers = ["Chart.yaml"];
capabilities = {
didChangeWatchedFiles = {
dynamicRegistration = true;
};
};
settings = mkIf (yamlCfg.enable && yamlCfg.lsp.enable) {
helm-ls = {
yamlls = {
# Without this being enabled, the YAML language module will look broken in helmfiles
# if both modules are enabled at once.
enabled = mkDefault yamlCfg.lsp.enable;
path = head config.vim.lsp.servers.${head yamlCfg.lsp.servers}.cmd;
};
};
};
};
};
servers = ["helm-ls"];
in {
options.vim.languages.helm = {
enable = mkEnableOption "Helm language support";
@ -61,7 +36,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.helm.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Helm LSP server to use";
};
@ -75,12 +50,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["helm" "yaml.helm-values"];
});
};
})
{

30
modules/plugins/languages/html.nix
View file

@ -8,7 +8,8 @@
inherit (lib.meta) getExe;
inherit (lib.options) literalExpression mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) bool enum;
inherit (lib.types) bool enum listOf;
inherit (lib) genAttrs;
inherit (lib.lists) optional;
inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
inherit (lib.nvim.dag) entryAnywhere;
@ -17,18 +18,7 @@
cfg = config.vim.languages.html;
defaultServers = ["superhtml"];
servers = {
superhtml = {
cmd = [(getExe pkgs.superhtml) "lsp"];
filetypes = ["html" "shtml" "htm"];
root_markers = ["index.html" ".git"];
};
emmet-ls = {
cmd = [(getExe pkgs.emmet-ls) "--stdio"];
filetypes = ["html" "shtml" "htm"];
root_markers = ["index.html" ".git"];
};
};
servers = ["superhtml" "emmet-ls"];
defaultFormat = ["superhtml"];
formats = {
@ -70,7 +60,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.html.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "HTML LSP server to use";
};
@ -124,12 +114,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["html" "shtml" "xhtml" "htm"];
});
};
})
(mkIf (cfg.format.enable && !cfg.lsp.enable) {

159
modules/plugins/languages/java.nix
View file

@ -6,60 +6,14 @@
}: let
inherit (lib.options) literalExpression mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (builtins) attrNames;
inherit (lib.types) listOf enum;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.dag) entryBefore;
inherit (lib.generators) mkLuaInline;
inherit (lib) genAttrs;
inherit (lib.types) listOf;
inherit (lib.nvim.types) mkGrammarOption enumWithRename;
cfg = config.vim.languages.java;
defaultServers = ["jdtls"];
servers = {
jdtls = {
enable = true;
cmd =
mkLuaInline
/*
lua
*/
''
{
'${getExe pkgs.jdt-language-server}',
'-configuration',
get_jdtls_config_dir(),
'-data',
get_jdtls_workspace_dir(),
get_jdtls_jvm_args(),
}
'';
filetypes = ["java"];
root_markers = [
# Multi-module projects
".git"
"build.gradle"
"build.gradle.kts"
# Single-module projects
"build.xml" # Ant
"pom.xml" # Maven
"settings.gradle" # Gradle
"settings.gradle.kts" # Gradle
];
init_options = {
workspace = mkLuaInline "get_jdtls_workspace_dir()";
jvm_args = {};
os_config = mkLuaInline "nil";
};
handlers = {
"textDocument/codeAction" = mkLuaInline "jdtls_on_textdocument_codeaction";
"textDocument/rename" = mkLuaInline "jdtls_on_textdocument_rename";
"workspace/applyEdit" = mkLuaInline "jdtls_on_workspace_applyedit";
"language/status" = mkLuaInline "vim.schedule_wrap(jdtls_on_language_status)";
};
};
};
defaultServers = ["jdt-language-server"];
servers = ["jdt-language-server"];
in {
options.vim.languages.java = {
enable = mkEnableOption "Java language support";
@ -82,7 +36,12 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.java.lsp.servers"
servers
{
jdtls = "jdt-language-server";
});
default = defaultServers;
description = "Java LSP server to use";
};
@ -91,96 +50,12 @@ in {
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.lsp.enable {
vim.luaConfigRC.jdtls-util =
entryBefore ["lsp-servers"]
/*
lua
*/
''
local jdtls_handlers = require 'vim.lsp.handlers'
local jdtls_env = {
HOME = vim.uv.os_homedir(),
XDG_CACHE_HOME = os.getenv 'XDG_CACHE_HOME',
JDTLS_JVM_ARGS = os.getenv 'JDTLS_JVM_ARGS',
}
local function get_cache_dir()
return jdtls_env.XDG_CACHE_HOME and jdtls_env.XDG_CACHE_HOME or jdtls_env.HOME .. '/.cache'
end
local function get_jdtls_cache_dir()
return get_cache_dir() .. '/jdtls'
end
local function get_jdtls_config_dir()
return get_jdtls_cache_dir() .. '/config'
end
local function get_jdtls_workspace_dir()
return get_jdtls_cache_dir() .. '/workspace'
end
local function get_jdtls_jvm_args()
local args = {}
for a in string.gmatch((jdtls_env.JDTLS_JVM_ARGS or '''), '%S+') do
local arg = string.format('--jvm-arg=%s', a)
table.insert(args, arg)
end
return unpack(args)
end
-- TextDocument version is reported as 0, override with nil so that
-- the client doesn't think the document is newer and refuses to update
-- See: https://github.com/eclipse/eclipse.jdt.ls/issues/1695
local function jdtls_fix_zero_version(workspace_edit)
if workspace_edit and workspace_edit.documentChanges then
for _, change in pairs(workspace_edit.documentChanges) do
local text_document = change.textDocument
if text_document and text_document.version and text_document.version == 0 then
text_document.version = nil
end
end
end
return workspace_edit
end
local function jdtls_on_textdocument_codeaction(err, actions, ctx)
for _, action in ipairs(actions) do
-- TODO: (steelsojka) Handle more than one edit?
if action.command == 'java.apply.workspaceEdit' then -- 'action' is Command in java format
action.edit = jdtls_fix_zero_version(action.edit or action.arguments[1])
elseif type(action.command) == 'table' and action.command.command == 'java.apply.workspaceEdit' then -- 'action' is CodeAction in java format
action.edit = jdtls_fix_zero_version(action.edit or action.command.arguments[1])
end
end
jdtls_handlers[ctx.method](err, actions, ctx)
end
local function jdtls_on_textdocument_rename(err, workspace_edit, ctx)
jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
end
local function jdtls_on_workspace_applyedit(err, workspace_edit, ctx)
jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
end
-- Non-standard notification that can be used to display progress
local function jdtls_on_language_status(_, result)
local command = vim.api.nvim_command
command 'echohl ModeMsg'
command(string.format('echo "%s"', result.message))
command 'echohl None'
end
'';
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["java"];
});
};
})
(mkIf cfg.treesitter.enable {

30
modules/plugins/languages/jinja.nix
View file

@ -4,26 +4,16 @@
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.meta) getExe;
inherit (lib) genAttrs;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) literalExpression mkEnableOption mkOption;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.jinja;
defaultServers = ["jinja-lsp"];
servers = {
jinja-lsp = {
enable = true;
cmd = [(getExe pkgs.jinja-lsp)];
filetypes = ["jinja"];
root_markers = [
".git"
];
};
};
servers = ["jinja-lsp"];
in {
options.vim.languages.jinja = {
enable = mkEnableOption "Jinja template language support";
@ -48,7 +38,7 @@ in {
};
servers = mkOption {
description = "Jinja LSP server to use";
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
};
};
@ -64,12 +54,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["jinja"];
});
};
})
]);
}

24
modules/plugins/languages/jq.nix
View file

@ -8,6 +8,7 @@
inherit (lib.options) literalExpression mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib) genAttrs;
inherit (lib.types) enum listOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) mkGrammarOption;
@ -15,14 +16,7 @@
cfg = config.vim.languages.jq;
defaultServers = ["jq-lsp"];
servers = {
jq-lsp = {
enable = true;
cmd = [(getExe pkgs.jq-lsp)];
filetypes = ["jq"];
root_markers = [".git"];
};
};
servers = ["jq-lsp"];
defaultFormat = ["jqfmt"];
formats = {
@ -57,7 +51,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "JQ LSP server to use";
};
@ -88,12 +82,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["jq"];
});
};
})
(mkIf cfg.format.enable {

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

@ -6,23 +6,17 @@
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.meta) getExe' getExe;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.types) enum listOf;
inherit (lib) genAttrs;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf enumWithRename;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.json;
defaultServers = ["jsonls"];
servers = {
jsonls = {
cmd = [(getExe' pkgs.vscode-langservers-extracted "vscode-json-language-server") "--stdio"];
filetypes = ["json" "jsonc" "json5"];
init_options = {provideFormatter = true;};
root_markers = [".git"];
};
};
defaultServers = ["vscode-json-language-server"];
servers = ["vscode-json-language-server"];
defaultFormat = ["jsonfmt"];
@ -57,7 +51,12 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.json.lsp.servers" (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.json.lsp.servers"
servers
{
jsonls = "vscode-json-language-server";
});
default = defaultServers;
description = "JSON LSP server to use";
};
@ -89,12 +88,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (name: {
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["json" "jsonc" "json5"];
});
};
})
(mkIf cfg.format.enable {

161
modules/plugins/languages/julia.nix
View file

@ -4,86 +4,16 @@
config,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) literalExpression mkEnableOption mkOption;
inherit (lib.types) enum;
inherit (lib.types) listOf;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.dag) entryBefore;
defaultServers = ["julials"];
servers = {
julials = {
enable = true;
cmd =
mkLuaInline
/*
lua
*/
''
{
'${getExe (pkgs.julia.withPackages ["LanguageServer"])}',
'--startup-file=no',
'--history-file=no',
'-e',
[[
# Load LanguageServer.jl: attempt to load from ~/.julia/environments/nvim-lspconfig
# with the regular load path as a fallback
ls_install_path = joinpath(
get(DEPOT_PATH, 1, joinpath(homedir(), ".julia")),
"environments", "nvim-lspconfig"
)
pushfirst!(LOAD_PATH, ls_install_path)
using LanguageServer
popfirst!(LOAD_PATH)
depot_path = get(ENV, "JULIA_DEPOT_PATH", "")
project_path = let
dirname(something(
## 1. Finds an explicitly set project (JULIA_PROJECT)
Base.load_path_expand((
p = get(ENV, "JULIA_PROJECT", nothing);
p === nothing ? nothing : isempty(p) ? nothing : p
)),
## 2. Look for a Project.toml file in the current working directory,
## or parent directories, with $HOME as an upper boundary
Base.current_project(),
## 3. First entry in the load path
get(Base.load_path(), 1, nothing),
## 4. Fallback to default global environment,
## this is more or less unreachable
Base.load_path_expand("@v#.#"),
))
end
@info "Running language server" VERSION pwd() project_path depot_path
server = LanguageServer.LanguageServerInstance(stdin, stdout, project_path, depot_path)
server.runlinter = true
run(server)
]],
}
'';
filetypes = ["julia"];
root_markers = ["Project.toml" "JuliaProject.toml"];
on_attach =
mkLuaInline
/*
lua
*/
''
function(_, bufnr)
vim.api.nvim_buf_create_user_command(bufnr, 'LspJuliaActivateEnv', activate_julia_env, {
desc = 'Activate a Julia environment',
nargs = '?',
complete = 'file',
})
end
'';
};
};
inherit (lib) genAttrs;
inherit (lib.nvim.types) mkGrammarOption enumWithRename;
cfg = config.vim.languages.julia;
defaultServers = ["julia-languageserver"];
servers = ["julia-languageserver"];
in {
options = {
vim.languages.julia = {
@ -107,7 +37,12 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.julia.lsp.servers" (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.julia.lsp.servers"
servers
{
julials = "julia-languageserver";
});
default = defaultServers;
description = ''
Julia LSP Server to Use
@ -136,70 +71,14 @@ in {
})
(mkIf cfg.lsp.enable {
vim.luaConfigRC.julia-util =
entryBefore ["lsp-servers"]
/*
lua
*/
''
local function activate_julia_env(path)
assert(vim.fn.has 'nvim-0.10' == 1, 'requires Nvim 0.10 or newer')
local bufnr = vim.api.nvim_get_current_buf()
local julials_clients = vim.lsp.get_clients { bufnr = bufnr, name = 'julials' }
assert(
#julials_clients > 0,
'method julia/activateenvironment is not supported by any servers active on the current buffer'
)
local function _activate_env(environment)
if environment then
for _, julials_client in ipairs(julials_clients) do
julials_client:notify('julia/activateenvironment', { envPath = environment })
end
vim.notify('Julia environment activated: \n`' .. environment .. '`', vim.log.levels.INFO)
end
end
if path then
path = vim.fs.normalize(vim.fn.fnamemodify(vim.fn.expand(path), ':p'))
local found_env = false
for _, project_file in ipairs(root_files) do
local file = vim.uv.fs_stat(vim.fs.joinpath(path, project_file))
if file and file.type then
found_env = true
break
end
end
if not found_env then
vim.notify('Path is not a julia environment: \n`' .. path .. '`', vim.log.levels.WARN)
return
end
_activate_env(path)
else
local depot_paths = vim.env.JULIA_DEPOT_PATH
and vim.split(vim.env.JULIA_DEPOT_PATH, vim.fn.has 'win32' == 1 and ';' or ':')
or { vim.fn.expand '~/.julia' }
local environments = {}
vim.list_extend(environments, vim.fs.find(root_files, { type = 'file', upward = true, limit = math.huge }))
for _, depot_path in ipairs(depot_paths) do
local depot_env = vim.fs.joinpath(vim.fs.normalize(depot_path), 'environments')
vim.list_extend(
environments,
vim.fs.find(function(name, env_path)
return vim.tbl_contains(root_files, name) and string.sub(env_path, #depot_env + 1):match '^/[^/]*$'
end, { path = depot_env, type = 'file', limit = math.huge })
)
end
environments = vim.tbl_map(vim.fs.dirname, environments)
vim.ui.select(environments, { prompt = 'Select a Julia environment' }, _activate_env)
end
end
'';
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim = {
lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["julia"];
});
};
};
})
]);
}

27
modules/plugins/languages/just.nix
View file

@ -4,25 +4,16 @@
pkgs,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) literalExpression mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib) genAttrs;
inherit (lib.types) enum listOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.just;
defaultServers = ["just-lsp"];
servers = {
just-lsp = {
enable = true;
cmd = [(getExe pkgs.just-lsp)];
filetypes = ["just"];
root_markers = [".git" "justfile"];
};
};
servers = ["just-lsp"];
in {
options.vim.languages.just = {
enable = mkEnableOption "Just support";
@ -45,7 +36,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Just LSP server to use";
};
@ -61,12 +52,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["just"];
});
};
})
]);
}

48
modules/plugins/languages/kotlin.nix
View file

@ -6,44 +6,16 @@
}: let
inherit (lib.options) literalExpression mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe' getExe;
inherit (builtins) attrNames;
inherit (lib.meta) getExe;
inherit (lib) genAttrs;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.kotlin;
defaultServers = ["kotlin-language-server"];
servers = {
kotlin-language-server = {
enable = true;
cmd = [(getExe' pkgs.kotlin-language-server "kotlin-language-server")];
filetypes = ["kotlin"];
root_markers = [
"settings.gradle" # Gradle (multi-project)
"settings.gradle.kts" # Gradle (multi-project)
"build.xml" # Ant
"pom.xml" # Maven
"build.gradle" # Gradle
"build.gradle.kts" # gradle
];
init_options = {
storagePath = mkLuaInline "
vim.fs.root(vim.fn.expand '%:p:h',
{
'settings.gradle', -- Gradle (multi-project)
'settings.gradle.kts', -- Gradle (multi-project)
'build.xml', -- Ant
'pom.xml', -- Maven
'build.gradle', -- Gradle
'build.gradle.kts', -- Gradle
}
)";
};
};
};
servers = ["kotlin-language-server"];
defaultDiagnosticsProvider = ["ktlint"];
diagnosticsProviders = {
@ -73,7 +45,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Kotlin LSP server to use";
};
@ -112,12 +84,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["kotlin"];
});
};
})
]);
}

33
modules/plugins/languages/lua.nix
View file

@ -8,6 +8,7 @@
inherit (lib.options) literalExpression mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib) genAttrs;
inherit (lib.types) bool enum listOf;
inherit (lib.nvim.types) diagnostics mkGrammarOption;
inherit (lib.nvim.dag) entryBefore;
@ -16,23 +17,7 @@
cfg = config.vim.languages.lua;
defaultServers = ["lua-language-server"];
servers = {
lua-language-server = {
enable = true;
cmd = [(getExe pkgs.lua-language-server)];
filetypes = ["lua"];
root_markers = [
".luarc.json"
".luarc.jsonc"
".luacheckrc"
".stylua.toml"
"stylua.toml"
"selene.toml"
"selene.yml"
".git"
];
};
};
servers = ["lua-language-server"];
defaultFormat = ["stylua"];
formats = {
@ -77,7 +62,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Lua LSP server to use";
};
@ -122,12 +107,12 @@ in {
(mkIf cfg.enable (mkMerge [
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["lsp"];
});
};
})
(mkIf cfg.lsp.lazydev.enable {

38
modules/plugins/languages/markdown.nix
View file

@ -5,6 +5,7 @@
...
}: let
inherit (builtins) attrNames;
inherit (lib) genAttrs;
inherit (lib.meta) getExe getExe';
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) literalExpression mkEnableOption mkOption;
@ -17,28 +18,7 @@
cfg = config.vim.languages.markdown;
defaultServers = ["marksman"];
servers = {
marksman = {
enable = true;
cmd = [(getExe pkgs.marksman) "server"];
filetypes = ["markdown" "mdx"];
root_markers = [".marksman.toml" ".git"];
};
markdown-oxide = {
enable = true;
cmd = [(getExe pkgs.markdown-oxide)];
filetypes = ["markdown"];
root_markers = [".git" ".obsidian" ".moxide.toml"];
};
rumdl = {
enable = true;
cmd = [(getExe pkgs.rumdl) "server"];
filetypes = ["markdown"];
root_markers = [".git" ".rumdl.toml" "rumdl.toml" ".config/rumdl.toml" "pyproject.toml"];
};
};
servers = ["marksman" "markdown-oxide" "rumdl"];
defaultFormat = ["deno_fmt"];
formats = {
@ -99,7 +79,7 @@ in {
servers = mkOption {
description = "Markdown LSP server to use";
type = deprecatedSingleOrListOf "vim.language.markdown.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
};
};
@ -186,12 +166,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["markdown" "mdx"];
});
};
})
(mkIf cfg.format.enable {

40
modules/plugins/languages/nim.nix
View file

@ -6,36 +6,16 @@
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.meta) getExe';
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum;
inherit (lib.types) enum listOf;
inherit (lib) genAttrs;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.nim;
defaultServers = ["nimlsp"];
servers = {
nimlsp = {
enable = true;
cmd = [(getExe' pkgs.nimlsp "nimlsp")];
filetypes = ["nim"];
root_dir =
mkLuaInline
/*
lua
*/
''
function(bufnr, on_dir)
local fname = vim.api.nvim_buf_get_name(bufnr)
on_dir(
util.root_pattern '*.nimble'(fname) or vim.fs.dirname(vim.fs.find('.git', { path = fname, upward = true })[1])
)
end
'';
};
};
servers = ["nimlsp"];
defaultFormat = ["nimpretty"];
formats = {
@ -66,7 +46,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.nim.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Nim LSP server to use";
};
@ -103,12 +83,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["nim"];
});
};
})
(mkIf cfg.format.enable {

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

@ -5,32 +5,18 @@
...
}: let
inherit (builtins) attrNames;
inherit (lib) concatStringsSep;
inherit (lib) concatStringsSep genAttrs;
inherit (lib.meta) getExe;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.nix;
defaultServers = ["nil"];
servers = {
nil = {
enable = true;
cmd = [(getExe pkgs.nil)];
filetypes = ["nix"];
root_markers = [".git" "flake.nix"];
};
nixd = {
enable = true;
cmd = [(getExe pkgs.nixd)];
filetypes = ["nix"];
root_markers = [".git" "flake.nix"];
};
};
servers = ["nil" "nixd"];
defaultFormat = ["alejandra"];
formats = {
@ -91,7 +77,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.nix.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Nix LSP server to use";
};
@ -147,12 +133,13 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["nix"];
root_markers = ["flake.nix"];
});
};
})
(mkIf cfg.format.enable {

41
modules/plugins/languages/nu.nix
View file

@ -5,32 +5,13 @@
...
}: let
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) enum;
inherit (lib.types) enum listOf;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.meta) getExe;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (builtins) attrNames;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib) genAttrs;
defaultServers = ["nushell"];
servers = {
nushell = {
enable = true;
cmd = [(getExe pkgs.nushell) "--no-config-file" "--lsp"];
filetypes = ["nu"];
root_dir =
mkLuaInline
/*
lua
*/
''
function(bufnr, on_dir)
on_dir(vim.fs.root(bufnr, { '.git' }) or vim.fs.dirname(vim.api.nvim_buf_get_name(bufnr)))
end
'';
};
};
servers = ["nushell"];
cfg = config.vim.languages.nu;
in {
@ -56,7 +37,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.nu.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Nu LSP server to use";
};
@ -70,12 +51,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["nu"];
});
};
})
]);
}

57
modules/plugins/languages/ocaml.nix
View file

@ -7,53 +7,16 @@
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.types) enum;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.ocaml;
defaultServers = ["ocaml-lsp"];
servers = {
ocaml-lsp = {
enable = true;
cmd = [(getExe pkgs.ocamlPackages.ocaml-lsp)];
filetypes = ["ocaml" "menhir" "ocamlinterface" "ocamllex" "reason" "dune"];
root_dir =
mkLuaInline
/*
lua
*/
''
function(bufnr, on_dir)
local fname = vim.api.nvim_buf_get_name(bufnr)
on_dir(util.root_pattern('*.opam', 'esy.json', 'package.json', '.git', 'dune-project', 'dune-workspace')(fname))
end
'';
get_language_id =
mkLuaInline
/*
lua
*/
''
function(_, ftype)
local language_id_of = {
menhir = 'ocaml.menhir',
ocaml = 'ocaml',
ocamlinterface = 'ocaml.interface',
ocamllex = 'ocaml.ocamllex',
reason = 'reason',
dune = 'dune',
}
return language_id_of[ftype]
end
'';
};
};
servers = ["ocaml-lsp"];
defaultFormat = ["ocamlformat"];
formats = {
@ -84,7 +47,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.ocaml.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "OCaml LSP server to use";
};
@ -102,12 +65,12 @@ in {
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["ocaml" "menhir" "ocamlinterface" "ocamllex" "reason" "dune"];
});
};
})
(mkIf cfg.treesitter.enable {

41
modules/plugins/languages/odin.nix
View file

@ -7,34 +7,15 @@
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum package;
inherit (lib.types) enum package listOf;
inherit (lib.nvim.dag) entryAfter;
inherit (lib.meta) getExe;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib) genAttrs;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.odin;
defaultServers = ["ols"];
servers = {
ols = {
enable = true;
cmd = [(getExe pkgs.ols)];
filetypes = ["odin"];
root_dir =
mkLuaInline
/*
lua
*/
''
function(bufnr, on_dir)
local fname = vim.api.nvim_buf_get_name(bufnr)
on_dir(util.root_pattern('ols.json', '.git', '*.odin')(fname))
end'';
};
};
servers = ["ols"];
defaultDebugger = "codelldb";
debuggers = {
codelldb = {
@ -71,7 +52,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.odin.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Odin LSP server to use";
};
@ -106,12 +87,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["odin"];
});
};
})
(mkIf cfg.dap.enable {

26
modules/plugins/languages/openscad.nix
View file

@ -4,12 +4,10 @@
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum listOf;
inherit (lib.meta) getExe;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib) genAttrs;
cfg = config.vim.languages.openscad;
/*
@ -22,13 +20,7 @@
*/
defaultServers = ["openscad-lsp"];
servers = {
openscad-lsp = {
enable = true;
cmd = [(getExe pkgs.openscad-lsp) "--stdio"];
filetypes = ["openscad"];
};
};
servers = ["openscad-lsp"];
in {
options.vim.languages.openscad = {
enable = mkEnableOption "OpenSCAD language support";
@ -42,7 +34,7 @@ in {
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "OpenSCAD LSP server to use";
};
@ -51,12 +43,12 @@ in {
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["openscad"];
});
};
})
]);
}

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

@ -6,65 +6,18 @@
}: let
inherit (builtins) attrNames toString;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum int attrs listOf;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.languages.php;
defaultServers = ["phpactor"];
servers = {
phpactor = {
enable = true;
cmd = [(getExe pkgs.phpactor) "language-server"];
filetypes = ["php"];
root_markers = [".git" "composer.json" ".phpactor.json" ".phpactor.yml"];
workspace_required = true;
};
phan = {
enable = true;
cmd = [
(getExe pkgs.php81Packages.phan)
"-m"
"json"
"--no-color"
"--no-progress-bar"
"-x"
"-u"
"-S"
"--language-server-on-stdin"
"--allow-polyfill-parser"
];
filetypes = ["php"];
root_dir =
mkLuaInline
/*
lua
*/
''
function(bufnr, on_dir)
local fname = vim.api.nvim_buf_get_name(bufnr)
local cwd = assert(vim.uv.cwd())
local root = vim.fs.root(fname, { 'composer.json', '.git' })
-- prefer cwd if root is a descendant
on_dir(root and vim.fs.relpath(cwd, root) and cwd)
end
'';
};
intelephense = {
enable = true;
cmd = [(getExe pkgs.intelephense) "--stdio"];
filetypes = ["php"];
root_markers = ["composer.json" ".git"];
};
};
servers = ["phpactor" "phan" "intelephense"];
defaultFormat = ["php_cs_fixer"];
formats = {
@ -103,7 +56,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.php.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "PHP LSP server to use";
};
@ -159,12 +112,13 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["php"];
root_markers = ["composer.json"];
});
};
})
(mkIf cfg.format.enable {

217
modules/plugins/languages/python.nix
View file

@ -7,185 +7,18 @@
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.lists) flatten;
inherit (lib) genAttrs;
inherit (lib.meta) getExe getExe';
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum package bool;
inherit (lib.types) enum package bool listOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) deprecatedSingleOrListOf diagnostics;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.dag) entryBefore;
inherit (lib.trivial) warn;
cfg = config.vim.languages.python;
defaultServers = ["basedpyright"];
servers = {
pyrefly = {
enable = true;
cmd = [(getExe pkgs.pyrefly) "lsp"];
filetypes = ["python"];
root_markers = [
"pyproject.toml"
"pyrefly.toml"
"setup.py"
"setup.cfg"
"requirements.txt"
"Pipfile"
".git"
];
};
pyright = {
enable = true;
cmd = [(getExe' pkgs.pyright "pyright-langserver") "--stdio"];
filetypes = ["python"];
root_markers = [
"pyproject.toml"
"setup.py"
"setup.cfg"
"requirements.txt"
"Pipfile"
"pyrightconfig.json"
".git"
];
settings = {
python = {
analysis = {
autoSearchPaths = true;
useLibraryCodeForTypes = true;
diagnosticMode = "openFilesOnly";
};
};
};
on_attach = mkLuaInline ''
function(client, bufnr)
vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightOrganizeImports', function()
local params = {
command = 'pyright.organizeimports',
arguments = { vim.uri_from_bufnr(bufnr) },
}
-- Using client.request() directly because "pyright.organizeimports" is private
-- (not advertised via capabilities), which client:exec_cmd() refuses to call.
-- https://github.com/neovim/neovim/blob/c333d64663d3b6e0dd9aa440e433d346af4a3d81/runtime/lua/vim/lsp/client.lua#L1024-L1030
client.request('workspace/executeCommand', params, nil, bufnr)
end, {
desc = 'Organize Imports',
})
vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightSetPythonPath', set_python_path, {
desc = 'Reconfigure basedpyright with the provided python path',
nargs = 1,
complete = 'file',
})
end
'';
};
basedpyright = {
enable = true;
cmd = [(getExe' pkgs.basedpyright "basedpyright-langserver") "--stdio"];
filetypes = ["python"];
root_markers = [
"pyproject.toml"
"setup.py"
"setup.cfg"
"requirements.txt"
"Pipfile"
"pyrightconfig.json"
".git"
];
settings = {
basedpyright = {
analysis = {
autoSearchPaths = true;
useLibraryCodeForTypes = true;
diagnosticMode = "openFilesOnly";
};
};
};
on_attach = mkLuaInline ''
function(client, bufnr)
vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightOrganizeImports', function()
local params = {
command = 'basedpyright.organizeimports',
arguments = { vim.uri_from_bufnr(bufnr) },
}
-- Using client.request() directly because "basedpyright.organizeimports" is private
-- (not advertised via capabilities), which client:exec_cmd() refuses to call.
-- https://github.com/neovim/neovim/blob/c333d64663d3b6e0dd9aa440e433d346af4a3d81/runtime/lua/vim/lsp/client.lua#L1024-L1030
client.request('workspace/executeCommand', params, nil, bufnr)
end, {
desc = 'Organize Imports',
})
vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightSetPythonPath', set_python_path, {
desc = 'Reconfigure basedpyright with the provided python path',
nargs = 1,
complete = 'file',
})
end
'';
};
python-lsp-server = {
enable = true;
cmd = [(getExe pkgs.python3Packages.python-lsp-server)];
filetypes = ["python"];
root_markers = [
"pyproject.toml"
"setup.py"
"setup.cfg"
"requirements.txt"
"Pipfile"
".git"
];
};
ruff = {
enable = true;
cmd = [(getExe pkgs.ruff) "server"];
filetypes = ["python"];
root_markers = [
"pyproject.toml"
"setup.py"
"setup.cfg"
"requirements.txt"
"Pipfile"
".git"
];
};
ty = {
enable = true;
cmd = [(getExe pkgs.ty) "server"];
filetypes = ["python"];
root_markers = [
"pyproject.toml"
"setup.py"
"setup.cfg"
"requirements.txt"
"Pipfile"
".git"
];
};
zuban = {
enable = true;
cmd = [(getExe pkgs.zuban) "server"];
filetypes = ["python"];
root_markers = [
"pyproject.toml"
"setup.py"
"setup.cfg"
"requirements.txt"
"Pipfile"
".git"
"mypy.ini"
".mypy.ini"
];
};
};
servers = ["pyrefly" "pyright" "basedpyright" "python-lsp-server" "ruff" "ty" "zuban"];
defaultFormat = ["black"];
formats = {
@ -313,7 +146,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.python.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Python LSP server to use";
};
@ -382,35 +215,19 @@ in {
})
(mkIf cfg.lsp.enable {
vim.luaConfigRC.python-util =
entryBefore ["lsp-servers"]
/*
lua
*/
''
local function set_python_path(server_name, command)
local path = command.args
local clients = vim.lsp.get_clients {
bufnr = vim.api.nvim_get_current_buf(),
name = server_name,
}
for _, client in ipairs(clients) do
if client.settings then
client.settings.python = vim.tbl_deep_extend('force', client.settings.python or {}, { pythonPath = path })
else
client.config.settings = vim.tbl_deep_extend('force', client.config.settings, { python = { pythonPath = path } })
end
client:notify('workspace/didChangeConfiguration', { settings = nil })
end
end
'';
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["python"];
root_markers = [
"Pipfile"
"pyproject.toml"
"requirements.txt"
"setup.cfg"
"setup.py"
];
});
};
})
(mkIf cfg.format.enable {

27
modules/plugins/languages/qml.nix
View file

@ -5,10 +5,10 @@
...
}: let
inherit (builtins) attrNames;
inherit (lib.meta) getExe';
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum;
inherit (lib) genAttrs;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
@ -17,13 +17,7 @@
qmlPackage = pkgs.kdePackages.qtdeclarative;
defaultServers = ["qmlls"];
servers = {
qmlls = {
cmd = [(getExe' qmlPackage "qmlls")];
filetypes = ["qml" "qmljs"];
rootmarkers = [".git"];
};
};
servers = ["qmlls"];
defaultFormat = ["qmlformat"];
formats = {
@ -54,7 +48,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.qml.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "QML LSP server to use";
};
@ -83,13 +77,14 @@ in {
grammars = [cfg.treesitter.package];
};
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["qml" "qmljs"];
});
};
})
(mkIf (cfg.format.enable && !cfg.lsp.enable) {

45
modules/plugins/languages/r.nix
View file

@ -7,18 +7,13 @@
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum;
inherit (lib.meta) getExe;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.types) enum listOf;
inherit (lib) genAttrs;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf enumWithRename;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.languages.r;
r-with-languageserver = pkgs.rWrapper.override {
packages = [pkgs.rPackages.languageserver];
};
defaultFormat = ["format_r"];
formats = {
styler = {
@ -47,19 +42,8 @@
};
};
defaultServers = ["r_language_server"];
servers = {
r_language_server = {
enable = true;
cmd = [(getExe r-with-languageserver) "--no-echo" "-e" "languageserver::run()"];
filetypes = ["r" "rmd" "quarto"];
root_dir = mkLuaInline ''
function(bufnr, on_dir)
on_dir(vim.fs.root(bufnr, '.git') or vim.uv.os_homedir())
end
'';
};
};
defaultServers = ["r-languageserver"];
servers = ["r-languageserver"];
in {
options.vim.languages.r = {
enable = mkEnableOption "R language support";
@ -83,7 +67,12 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.r.lsp.servers" (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.r.lsp.servers"
servers
{
r_language_server = "r-languageserver";
});
default = defaultServers;
description = "R LSP server to use";
};
@ -127,12 +116,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["r" "rmd" "quarto"];
});
};
})
]);
}

56
modules/plugins/languages/ruby.nix
View file

@ -6,46 +6,17 @@
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
inherit (lib.types) enum;
inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf enumWithRename;
inherit (lib.types) enum listOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.ruby;
defaultServers = ["solargraph"];
servers = {
ruby_lsp = {
enable = true;
cmd = [(getExe pkgs.ruby-lsp)];
filetypes = ["ruby" "eruby"];
root_markers = ["Gemfile" ".git"];
init_options = {
formatter = "auto";
};
};
solargraph = {
enable = true;
cmd = [(getExe pkgs.rubyPackages.solargraph) "stdio"];
filetypes = ["ruby"];
root_markers = ["Gemfile" ".git"];
settings = {
solargraph = {
diagnostics = true;
};
};
flags = {
debounce_text_changes = 150;
};
init_options = {
formatting = true;
};
};
};
servers = ["ruby-lsp" "solargraph"];
# testing
@ -85,7 +56,12 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.ruby.lsp.servers" (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.ruby.lsp.servers"
servers
{
ruby_lsp = "ruby-lsp";
});
default = defaultServers;
description = "Ruby LSP server to use";
};
@ -121,12 +97,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["ruby" "eruby"];
});
};
})
(mkIf cfg.format.enable {

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

@ -6,33 +6,19 @@
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum package str;
inherit (lib.types) enum package str listOf;
inherit (lib.nvim.types) diagnostics deprecatedSingleOrListOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.languages.sql;
sqlfluffDefault = pkgs.sqlfluff;
sqruffDefault = pkgs.sqruff;
defaultServers = ["sqls"];
servers = {
sqls = {
enable = true;
cmd = [(getExe pkgs.sqls)];
filetypes = ["sql" "mysql"];
root_markers = ["config.yml"];
settings = {};
on_attach = mkLuaInline ''
function(client, bufnr)
client.server_capabilities.execute_command = true
require'sqls'.setup{}
end
'';
};
};
servers = ["sqls"];
defaultFormat = ["sqlfluff"];
formats = {
@ -97,7 +83,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.sql.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "SQL LSP server to use";
};
@ -142,14 +128,12 @@ in {
(mkIf cfg.lsp.enable {
vim = {
startPlugins = ["sqls-nvim"];
lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["sql" "mysql" "msql" "plsql"];
});
};
};
})

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

@ -8,51 +8,16 @@
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.types) enum coercedTo;
inherit (lib.types) enum coercedTo listOf;
inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.languages.svelte;
defaultServers = ["svelte"];
servers = {
svelte = {
enable = true;
cmd = [(getExe pkgs.svelte-language-server) "--stdio"];
filetypes = ["svelte"];
root_dir = mkLuaInline ''
function(bufnr, on_dir)
local root_files = { 'package.json', '.git' }
local fname = vim.api.nvim_buf_get_name(bufnr)
-- Svelte LSP only supports file:// schema. https://github.com/sveltejs/language-tools/issues/2777
if vim.uv.fs_stat(fname) ~= nil then
on_dir(vim.fs.dirname(vim.fs.find(root_files, { path = fname, upward = true })[1]))
end
end
'';
on_attach = mkLuaInline ''
function(client, bufnr)
vim.api.nvim_create_autocmd('BufWritePost', {
pattern = { '*.js', '*.ts' },
group = vim.api.nvim_create_augroup('svelte_js_ts_file_watch', {}),
callback = function(ctx)
-- internal API to sync changes that have not yet been saved to the file system
client:notify('$/onDidChangeTsOrJsFile', { uri = ctx.match })
end,
})
vim.api.nvim_buf_create_user_command(bufnr, 'LspMigrateToSvelte5', function()
client:exec_cmd({
command = 'migrate_to_svelte_5',
arguments = { vim.uri_from_bufnr(bufnr) },
})
end, { desc = 'Migrate Component to Svelte 5 Syntax' })
end
'';
};
};
defaultServers = ["svelte-language-server"];
servers = ["svelte-language-server"];
defaultFormat = ["prettier"];
formats = let
@ -123,7 +88,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.svelte.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Svelte LSP server to use";
};
@ -167,12 +132,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["svelte"];
});
};
})
(mkIf cfg.format.enable {

40
modules/plugins/languages/terraform.nix
View file

@ -7,28 +7,16 @@
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.types) mkGrammarOption enumWithRename;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.terraform;
defaultServers = ["tofuls-tf"];
servers = {
terraformls-tf = {
enable = true;
cmd = [(getExe pkgs.terraform-ls) "serve"];
filetypes = ["terraform" "terraform-vars" "tf"];
root_markers = [".terraform" ".git"];
};
tofuls-tf = {
enable = true;
cmd = [(getExe pkgs.tofu-ls) "serve"];
filetypes = ["terraform" "terraform-vars" "tf"];
root_markers = [".terraform" ".git"];
};
};
defaultServers = ["tofu-ls"];
servers = ["terraform-ls" "tofu-ls"];
defaultFormat = ["tofu-fmt"];
formats = {
@ -65,7 +53,13 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.terraform.lsp.servers"
servers
{
terraformls-tf = "terraform-ls";
tofuls-tf = "tofu-ls";
});
default = defaultServers;
description = "Terraform LSP server to use";
};
@ -93,13 +87,11 @@ in {
})
(mkIf cfg.lsp.enable {
vim = {
lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["terraform" "terraform-vars" "tf"];
});
};
})

24
modules/plugins/languages/tex.nix
View file

@ -5,6 +5,7 @@
...
}: let
inherit (builtins) attrNames;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) literalExpression mkEnableOption mkOption;
@ -14,14 +15,7 @@
cfg = config.vim.languages.tex;
defaultServers = ["texlab"];
servers = {
texlab = {
enable = true;
cmd = [(getExe pkgs.texlab) "run"];
filetypes = ["plaintex" "tex" "bib"];
root_markers = [".git" ".latexmkrc" "latexmkrc" ".texlabroot" "texlabroot" ".texstudio" "Tectonic.toml"];
};
};
servers = ["texlab"];
defaultFormat = ["tex-fmt"];
formats = {
@ -57,7 +51,7 @@ in {
servers = mkOption {
description = "TeX LSP server to use";
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
};
};
@ -88,12 +82,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["plaintex" "tex" "bib"];
});
};
})
(mkIf cfg.format.enable {

44
modules/plugins/languages/toml.nix
View file

@ -5,41 +5,17 @@
...
}: let
inherit (builtins) attrNames;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) enum;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) diagnostics mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.toml;
defaultServers = ["taplo"];
servers = {
tombi = {
enable = true;
cmd = [
(getExe pkgs.tombi)
"lsp"
];
filetypes = ["toml"];
root_markers = [
"tombi.toml"
".git"
];
};
taplo = {
enable = true;
cmd = [
(getExe pkgs.taplo)
"lsp"
"stdio"
];
filetypes = ["toml"];
root_markers = [
".git"
];
};
};
servers = ["taplo" "tombi"];
defaultFormat = ["taplo"];
formats = {
@ -93,7 +69,7 @@ in {
servers = mkOption {
description = "TOML LSP server to use";
type = deprecatedSingleOrListOf "vim.language.toml.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
};
};
@ -137,12 +113,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["toml"];
});
};
})
(mkIf cfg.format.enable {

232
modules/plugins/languages/ts.nix
View file

@ -7,183 +7,18 @@
inherit (builtins) attrNames elem;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.types) enum package bool;
inherit (lib.generators) mkLuaInline;
inherit (lib.types) enum bool listOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.types) mkGrammarOption diagnostics mkPluginSetupOption deprecatedSingleOrListOf;
inherit (lib.nvim.dag) entryAnywhere entryBefore;
inherit (lib.nvim.types) mkGrammarOption diagnostics mkPluginSetupOption deprecatedSingleOrListOf enumWithRename;
inherit (lib.nvim.dag) entryAnywhere;
cfg = config.vim.languages.ts;
defaultServers = ["ts_ls"];
servers = let
ts_ls = {
cmd = [(getExe pkgs.typescript-language-server) "--stdio"];
init_options = {hostInfo = "neovim";};
filetypes = [
"javascript"
"javascriptreact"
"javascript.jsx"
"typescript"
"typescriptreact"
"typescript.tsx"
];
root_markers = ["tsconfig.json" "jsconfig.json" "package.json" ".git"];
handlers = {
# handle rename request for certain code actions like extracting functions / types
"_typescript.rename" = mkLuaInline ''
function(_, result, ctx)
local client = assert(vim.lsp.get_client_by_id(ctx.client_id))
vim.lsp.util.show_document({
uri = result.textDocument.uri,
range = {
start = result.position,
['end'] = result.position,
},
}, client.offset_encoding)
vim.lsp.buf.rename()
return vim.NIL
end
'';
};
on_attach = mkLuaInline ''
function(client, bufnr)
-- ts_ls provides `source.*` code actions that apply to the whole file. These only appear in
-- `vim.lsp.buf.code_action()` if specified in `context.only`.
vim.api.nvim_buf_create_user_command(0, 'LspTypescriptSourceAction', function()
local source_actions = vim.tbl_filter(function(action)
return vim.startswith(action, 'source.')
end, client.server_capabilities.codeActionProvider.codeActionKinds)
vim.lsp.buf.code_action({
context = {
only = source_actions,
},
})
end, {})
end
'';
};
in {
inherit ts_ls;
# Here for backwards compatibility. Still consider tsserver a valid
# configuration in the enum, but assert if it's set to *properly*
# redirect the user to the correct server.
tsserver = ts_ls;
denols = {
cmd = [(getExe pkgs.deno) "lsp"];
cmd_env = {NO_COLOR = true;};
filetypes = [
"javascript"
"javascriptreact"
"javascript.jsx"
"typescript"
"typescriptreact"
"typescript.tsx"
];
root_markers = ["deno.json" "deno.jsonc" ".git"];
settings = {
deno = {
enable = true;
suggest = {
imports = {
hosts = {
"https://deno.land" = true;
};
};
};
};
};
handlers = {
"textDocument/definition" = mkLuaInline "nvf_denols_handler";
"textDocument/typeDefinition" = mkLuaInline "nvf_denols_handler";
"textDocument/references" = mkLuaInline "nvf_denols_handler";
};
on_attach = mkLuaInline ''
function(client, bufnr)
vim.api.nvim_buf_create_user_command(0, 'LspDenolsCache', function()
client:exec_cmd({
command = 'deno.cache',
arguments = { {}, vim.uri_from_bufnr(bufnr) },
}, { bufnr = bufnr }, function(err, _result, ctx)
if err then
local uri = ctx.params.arguments[2]
vim.api.nvim_err_writeln('cache command failed for ' .. vim.uri_to_fname(uri))
end
end)
end, {
desc = 'Cache a module and all of its dependencies.',
})
end
'';
};
tsgo = {
cmd = [(getExe pkgs.typescript-go) "--lsp" "--stdio"];
filetypes = [
"javascript"
"javascriptreact"
"javascript.jsx"
"typescript"
"typescriptreact"
"typescript.tsx"
];
root_markers = ["tsconfig.json" "jsconfig.json" "package.json" ".git"];
};
};
denols_handlers = ''
local function nvf_denols_virtual_text_document_handler(uri, res, client)
if not res then
return nil
end
local lines = vim.split(res.result, '\n')
local bufnr = vim.uri_to_bufnr(uri)
local current_buf = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
if #current_buf ~= 0 then
return nil
end
vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
vim.api.nvim_set_option_value('readonly', true, { buf = bufnr })
vim.api.nvim_set_option_value('modified', false, { buf = bufnr })
vim.api.nvim_set_option_value('modifiable', false, { buf = bufnr })
vim.lsp.buf_attach_client(bufnr, client.id)
end
local function nvf_denols_virtual_text_document(uri, client)
local params = {
textDocument = {
uri = uri,
},
}
local result = client.request_sync('deno/virtualTextDocument', params)
nvf_denols_virtual_text_document_handler(uri, result, client)
end
local function nvf_denols_handler(err, result, ctx, config)
if not result or vim.tbl_isempty(result) then
return nil
end
local client = vim.lsp.get_client_by_id(ctx.client_id)
for _, res in pairs(result) do
local uri = res.uri or res.targetUri
if uri:match '^deno:' then
nvf_denols_virtual_text_document(uri, client)
res['uri'] = uri
res['targetUri'] = uri
end
end
vim.lsp.handlers[ctx.method](err, result, ctx, config)
end
'';
defaultServers = ["typescript-language-server"];
servers = ["typescript-language-server" "deno" "typescript-go"];
# TODO: specify packages
defaultFormat = ["prettier"];
@ -264,7 +99,14 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.ts.lsp.servers" (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.ts.lsp.servers"
servers
{
ts_ls = "typescript-language-server";
denols = "deno";
tsgo = "typescript-go";
});
default = defaultServers;
description = "Typescript/Javascript LSP server to use";
};
@ -317,6 +159,8 @@ in {
};
config = mkIf cfg.enable (mkMerge [
{vim.globals.markdown_fenced_languages = ["ts=typescript"];}
(mkIf cfg.treesitter.enable {
vim.treesitter.enable = true;
vim.treesitter.grammars = [
@ -327,17 +171,22 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (name: {
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
})
(mkIf (cfg.lsp.enable && elem "denols" cfg.lsp.servers) {
vim.globals.markdown_fenced_languages = ["ts=typescript"];
vim.luaConfigRC.denols_handlers = entryBefore ["lsp-servers"] denols_handlers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
root_markers = ["tsconfig.json"];
filetypes = [
"typescript"
# TODO: move to a React module
"typescriptreact"
"typescript.tsx"
"javascriptreact"
"javascript.jsx"
# TODO: move to a JavaScript module
"javascript"
];
});
};
})
(mkIf cfg.format.enable {
@ -380,21 +229,20 @@ in {
'';
})
# Warn the user if they have set the default server name to tsserver to match upstream (us)
# The name "tsserver" has been deprecated in lspconfig, and now should be called ts_ls. This
# is a purely cosmetic change, but emits a warning if not accounted for.
# Warn the user if they have set the default server name to "tsserver" to match upstream (us)
# The name "tsserver" has been deprecated, and now should be called "typescript-language-server".
{
assertions = [
{
assertion = cfg.lsp.enable -> !(elem "tsserver" cfg.lsp.servers);
message = ''
As of a recent lspconfig update, the `tsserver` configuration has been renamed
to `ts_ls` to match upstream behaviour of `lspconfig`, and the name `tsserver`
is no longer considered valid by nvf. Please set `vim.languages.ts.lsp.server`
to `"ts_ls"` instead of to `${cfg.lsp.server}`
The name `tsserver` has been deprecated, and now should be called `typescript-language-server`.
Please set `vim.languages.ts.lsp.server` to `["typescript-language-server" ...]` instead of to `["tsserver" ...]`
Please see <https://github.com/neovim/nvim-lspconfig/pull/3232> for more details
about this change.
Please see:
- <https://github.com/neovim/nvim-lspconfig/pull/3232>
- <https://github.com/NotAShelf/nvf/pull/1514>
for more details about this change.
'';
}
];

24
modules/plugins/languages/twig.nix
View file

@ -7,6 +7,7 @@
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.types) listOf enum;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
@ -15,14 +16,7 @@
cfg = config.vim.languages.twig;
defaultServers = ["twig-language-server"];
servers = {
twig-language-server = {
enable = true;
cmd = [(getExe pkgs.twig-language-server) "--stdio"];
filetypes = ["twig"];
root_markers = [".git"];
};
};
servers = ["twig-language-server"];
defaultFormat = ["djlint"];
formats = {
@ -62,7 +56,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Twig LSP server to use";
};
@ -104,12 +98,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["twig"];
});
};
})
(mkIf cfg.format.enable {

91
modules/plugins/languages/typst.nix
View file

@ -6,92 +6,21 @@
}: let
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) nullOr enum attrsOf listOf package str bool int;
inherit (lib.types) nullOr enum attrsOf listOf str bool int;
inherit (lib.attrsets) attrNames;
inherit (lib) genAttrs;
inherit (lib.meta) getExe;
inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption deprecatedSingleOrListOf;
inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.binds) mkKeymap;
inherit (lib.generators) mkLuaInline;
inherit (config.vim.lib) mkMappingOption;
cfg = config.vim.languages.typst;
defaultServers = ["tinymist"];
servers = {
typst_lsp = {
enable = true;
cmd = [(getExe pkgs.typst-lsp)];
filetypes = ["typst"];
root_markers = [".git"];
on_attach = mkLuaInline ''
function(client, bufnr)
-- Disable semantic tokens as a workaround for a semantic token error when using non-english characters
client.server_capabilities.semanticTokensProvider = nil
end
'';
};
tinymist = {
enable = true;
cmd = [(getExe pkgs.tinymist)];
filetypes = ["typst"];
root_markers = [".git"];
on_attach = mkLuaInline ''
function(client, bufnr)
local function create_tinymist_command(command_name, client, bufnr)
local export_type = command_name:match 'tinymist%.export(%w+)'
local info_type = command_name:match 'tinymist%.(%w+)'
if info_type and info_type:match '^get' then
info_type = info_type:gsub('^get', 'Get')
end
local cmd_display = export_type or info_type
local function run_tinymist_command()
local arguments = { vim.api.nvim_buf_get_name(bufnr) }
local title_str = export_type and ('Export ' .. cmd_display) or cmd_display
local function handler(err, res)
if err then
return vim.notify(err.code .. ': ' .. err.message, vim.log.levels.ERROR)
end
vim.notify(export_type and res or vim.inspect(res), vim.log.levels.INFO)
end
if vim.fn.has 'nvim-0.11' == 1 then
return client:exec_cmd({
title = title_str,
command = command_name,
arguments = arguments,
}, { bufnr = bufnr }, handler)
else
return vim.notify('Tinymist commands require Neovim 0.11+', vim.log.levels.WARN)
end
end
local cmd_name = export_type and ('LspTinymistExport' .. cmd_display) or ('LspTinymist' .. cmd_display)
local cmd_desc = export_type and ('Export to ' .. cmd_display) or ('Get ' .. cmd_display)
return run_tinymist_command, cmd_name, cmd_desc
end
for _, command in ipairs {
'tinymist.exportSvg',
'tinymist.exportPng',
'tinymist.exportPdf',
'tinymist.exportMarkdown',
'tinymist.exportText',
'tinymist.exportQuery',
'tinymist.exportAnsiHighlight',
'tinymist.getServerInfo',
'tinymist.getDocumentTrace',
'tinymist.getWorkspaceLabels',
'tinymist.getDocumentMetrics',
} do
local cmd_func, cmd_name, cmd_desc = create_tinymist_command(command, client, bufnr)
vim.api.nvim_buf_create_user_command(bufnr, cmd_name, cmd_func, { nargs = 0, desc = cmd_desc })
end
end
'';
};
};
servers = ["tinymist"];
defaultFormat = ["typstyle"];
formats = {
@ -123,7 +52,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.typst.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Typst LSP server to use";
};
@ -261,12 +190,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["typst"];
});
};
})
# Extensions

77
modules/plugins/languages/vala.nix
View file

@ -4,64 +4,16 @@
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib.types) enum;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.generators) mkLuaInline;
inherit (lib) genAttrs;
inherit (lib.types) listOf;
inherit (lib.nvim.types) mkGrammarOption enumWithRename;
cfg = config.vim.languages.vala;
defaultServers = ["vala_ls"];
servers = {
vala_ls = {
enable = true;
cmd = [
(getExe (pkgs.symlinkJoin {
name = "vala-language-server-wrapper";
paths = [pkgs.vala-language-server];
meta.mainProgram = "vala-language-server-wrapper";
buildInputs = [pkgs.makeBinaryWrapper];
postBuild = ''
wrapProgram $out/bin/vala-language-server \
--prefix PATH : ${pkgs.uncrustify}/bin
'';
}))
];
filetypes = ["vala" "genie"];
root_dir = mkLuaInline ''
function(bufnr, on_dir)
local meson_matcher = function(path)
local pattern = 'meson.build'
local f = vim.fn.glob(table.concat({ path, pattern }, '/'))
if f == ''' then
return nil
end
for line in io.lines(f) do
-- skip meson comments
if not line:match '^%s*#.*' then
local str = line:gsub('%s+', ''')
if str ~= ''' then
if str:match '^project%(' then
return path
else
break
end
end
end
end
end
local fname = vim.api.nvim_buf_get_name(bufnr)
local root = vim.iter(vim.fs.parents(fname)):find(meson_matcher)
on_dir(root or vim.fs.dirname(vim.fs.find('.git', { path = fname, upward = true })[1]))
end
'';
};
};
defaultServers = ["vala-language-server"];
servers = ["vala-language-server"];
in {
options.vim.languages.vala = {
enable = mkEnableOption "Vala language support";
@ -84,7 +36,12 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.vala.lsp.servers" (enum (attrNames servers));
type = listOf (enumWithRename
"vim.languages.vala.lsp.servers"
servers
{
vala_ls = "vala-language-server";
});
default = defaultServers;
description = "Vala LSP server to use";
};
@ -98,12 +55,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["vala"];
});
};
})
]);
}

32
modules/plugins/languages/wgsl.nix
View file

@ -4,26 +4,16 @@
pkgs,
...
}: let
inherit (builtins) attrNames;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.types) enum;
inherit (lib.meta) getExe;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.types) enum listOf;
inherit (lib) genAttrs;
cfg = config.vim.languages.wgsl;
defaultServers = ["wgsl-analyzer"];
servers = {
wgsl-analyzer = {
enable = true;
cmd = [(getExe pkgs.wgsl-analyzer)];
filetypes = ["wgsl"];
root_markers = [".git"];
settings = {};
};
};
servers = ["wgsl-analyzer"];
in {
options.vim.languages.wgsl = {
enable = mkEnableOption "WGSL language support";
@ -47,7 +37,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.wgsl.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "WGSL LSP server to use";
};
@ -63,12 +53,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["wgsl"];
});
};
})
]);
}

29
modules/plugins/languages/xml.nix
View file

@ -4,27 +4,16 @@
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib) genAttrs;
cfg = config.vim.languages.xml;
defaultServers = ["lemminx"];
servers = {
lemminx = {
enable = true;
cmd = [
(getExe pkgs.lemminx)
];
filetypes = ["xml"];
root_markers = [".git"];
};
};
servers = ["lemminx"];
in {
options.vim.languages.xml = {
enable = mkEnableOption "XML language support";
@ -47,7 +36,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = listOf (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "XML LSP server to use";
};
@ -61,12 +50,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (name: {
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["xml"];
});
};
})
]);
}

54
modules/plugins/languages/yaml.nix
View file

@ -4,48 +4,16 @@
lib,
...
}: let
inherit (builtins) attrNames;
inherit (lib.generators) mkLuaInline;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib.types) enum;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib) genAttrs;
inherit (lib.types) enum listOf;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.yaml;
on_attach =
if config.vim.languages.helm.lsp.enable && config.vim.languages.helm.enable
then
mkLuaInline ''
function(client, bufnr)
local filetype = vim.bo[bufnr].filetype
if filetype == "helm" then
client.stop()
end
end
''
else null;
defaultServers = ["yaml-language-server"];
servers = {
yaml-language-server = {
enable = true;
cmd = [(getExe pkgs.yaml-language-server) "--stdio"];
filetypes = ["yaml" "yaml.docker-compose" "yaml.gitlab" "yaml.helm-values"];
root_markers = [".git"];
inherit on_attach;
# -- https://github.com/redhat-developer/vscode-redhat-telemetry#how-to-disable-telemetry-reporting
settings = {
redhat = {
telemetry = {
enabled = false;
};
};
};
};
};
servers = ["yaml-language-server"];
in {
options.vim.languages.yaml = {
enable = mkEnableOption "YAML language support";
@ -69,7 +37,7 @@ in {
defaultText = literalExpression "config.vim.lsp.enable";
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.yaml.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Yaml LSP server to use";
};
@ -83,12 +51,12 @@ in {
})
(mkIf cfg.lsp.enable {
vim.lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
vim.lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
filetypes = ["yaml"];
});
};
})
]);
}

33
modules/plugins/languages/zig.nix
View file

@ -7,23 +7,14 @@
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge mkDefault;
inherit (lib.types) bool package enum;
inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
inherit (lib.meta) getExe;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib) genAttrs;
inherit (lib.types) bool package enum listOf;
inherit (lib.nvim.types) mkGrammarOption;
cfg = config.vim.languages.zig;
defaultServers = ["zls"];
servers = {
zls = {
enable = true;
cmd = [(getExe pkgs.zls)];
filetypes = ["zig" "zir"];
root_markers = ["zls.json" "build.zig" ".git"];
workspace_required = false;
};
};
servers = ["zls"];
# TODO: dap.adapter.lldb is duplicated when enabling the
# vim.languages.clang.dap module. This does not cause
@ -77,7 +68,7 @@ in {
};
servers = mkOption {
type = deprecatedSingleOrListOf "vim.language.zig.lsp.servers" (enum (attrNames servers));
type = listOf (enum servers);
default = defaultServers;
description = "Zig LSP server to use";
};
@ -115,13 +106,13 @@ in {
(mkIf cfg.lsp.enable {
vim = {
lsp.servers =
mapListToAttrs (n: {
name = n;
value = servers.${n};
})
cfg.lsp.servers;
lsp = {
presets = genAttrs cfg.lsp.servers (_: {enable = true;});
servers = genAttrs cfg.lsp.servers (_: {
root_markers = ["build.zig"];
filetypes = ["zig" "zir"];
});
};
# nvf handles autosaving already
globals.zig_fmt_autosave = mkDefault 0;
};

3
modules/plugins/lsp/default.nix
View file

@ -4,10 +4,11 @@
./config.nix
./module.nix
./presets
./lspconfig
./lspsaga
./null-ls
./harper-ls
# lsp plugins
./lspsaga

57
modules/plugins/lsp/harper-ls/config.nix
View file

@ -1,57 +0,0 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.meta) getExe;
cfg = config.vim.lsp;
in {
config = mkIf (cfg.enable && cfg.harper-ls.enable) {
vim.lsp.servers.harper-ls = {
root_markers = [".git" ".harper-dictionary.txt"];
cmd = [(getExe pkgs.harper) "--stdio"];
settings = {harper-ls = cfg.harper-ls.settings;};
filetypes =
# <https://writewithharper.com/docs/integrations/language-server#Supported-Languages>
[
"asciidoc"
"c"
"clojure"
"cmake"
"cpp"
"cs"
"daml"
"dart"
"gitcommit"
"go"
"haskell"
"html"
"ink"
"java"
"javascript"
"javascriptreact"
"kotlin"
"lhaskell"
"lua"
"mail"
"markdown"
"nix"
"php"
"python"
"ruby"
"rust"
"scala"
"sh"
"swift"
"text"
"toml"
"typescript"
"typescriptreact"
"typst"
];
};
};
}

6
modules/plugins/lsp/harper-ls/default.nix
View file

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

35
modules/plugins/lsp/harper-ls/harper-ls.nix
View file

@ -1,35 +0,0 @@
{lib, ...}: let
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.types) anything attrsOf;
in {
options.vim.lsp.harper-ls = {
enable = mkEnableOption "Harper grammar checking LSP";
settings = mkOption {
type = attrsOf anything;
default = {};
example = {
userDictPath = "";
workspaceDictPath = "";
fileDictPath = "";
linters = {
BoringWords = true;
PossessiveNoun = true;
SentenceCapitalization = false;
SpellCheck = false;
};
codeActions = {
ForceStable = false;
};
markdown = {
IgnoreLinkTitle = false;
};
diagnosticSeverity = "hint";
isolateEnglish = false;
dialect = "American";
maxFileLength = 120000;
ignoredLintsPath = {};
};
description = "Settings to pass to harper-ls";
};
};
}

46
modules/plugins/lsp/presets/arduino-language-server.nix Normal file
View file

@ -0,0 +1,46 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe getExe';
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.lsp.presets.arduino-language-server;
in {
options.vim.lsp.presets.arduino-language-server = {
enable = mkLspPresetEnableOption "arduino-language-server" "Arduino" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.arduino-language-server = {
enable = true;
cmd = [
(getExe pkgs.arduino-language-server)
"-clangd"
(getExe' pkgs.clang-tools "clangd")
"-cli"
(getExe pkgs.arduino-cli)
"-cli-config"
"$HOME/.arduino15/arduino-cli.yaml"
];
root_dir = mkLuaInline ''
function(bufnr, on_dir)
local fname = vim.api.nvim_buf_get_name(bufnr)
on_dir(util.root_pattern("*.ino")(fname))
end
'';
capabilities = {
textDocument = {
semanticTokens = mkLuaInline "vim.NIL";
};
workspace = {
semanticTokens = mkLuaInline "vim.NIL";
};
};
};
};
}

24
modules/plugins/lsp/presets/asm-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.asm-lsp;
in {
options.vim.lsp.presets.asm-lsp = {
enable = mkLspPresetEnableOption "asm-lsp" "Assembly" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.asm-lsp = {
enable = true;
cmd = [(getExe pkgs.asm-lsp)];
root_markers = [".git" ".asm-lsp.toml"];
};
};
}

35
modules/plugins/lsp/presets/astro-language-server.nix Normal file
View file

@ -0,0 +1,35 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.lsp.presets.astro-language-server;
in {
options.vim.lsp.presets.astro-language-server = {
enable = mkLspPresetEnableOption "astro-language-server" "Astro" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.astro-language-server = {
enable = true;
cmd = [(getExe pkgs.astro-language-server) "--stdio"];
root_markers = [".git" "package.json" "tsconfig.json" "jsconfig.json"];
init_options = {
typescript = {};
};
before_init = mkLuaInline ''
function(_, config)
if config.init_options and config.init_options.typescript and not config.init_options.typescript.tsdk then
config.init_options.typescript.tsdk = util.get_typescript_server_path(config.root_dir)
end
end
'';
};
};
}

77
modules/plugins/lsp/presets/basedpyright.nix Normal file
View file

@ -0,0 +1,77 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe';
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.dag) entryBefore;
cfg = config.vim.lsp.presets.basedpyright;
in {
options.vim.lsp.presets.basedpyright = {
enable = mkLspPresetEnableOption "basedpyright" "Based Pyright" [];
};
config = mkIf cfg.enable {
vim = {
lsp.servers.basedpyright = {
enable = true;
cmd = [(getExe' pkgs.basedpyright "basedpyright-langserver") "--stdio"];
root_markers = [".git" "pyrightconfig.json"];
settings = {
basedpyright = {
analysis = {
autoSearchPaths = true;
useLibraryCodeForTypes = true;
diagnosticMode = "openFilesOnly";
};
};
};
on_attach = mkLuaInline ''
function(client, bufnr)
vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightOrganizeImports', function()
local params = {
command = 'basedpyright.organizeimports',
arguments = { vim.uri_from_bufnr(bufnr) },
}
-- Using client.request() directly because "basedpyright.organizeimports" is private
-- (not advertised via capabilities), which client:exec_cmd() refuses to call.
-- https://github.com/neovim/neovim/blob/c333d64663d3b6e0dd9aa440e433d346af4a3d81/runtime/lua/vim/lsp/client.lua#L1024-L1030
client.request('workspace/executeCommand', params, nil, bufnr)
end, {
desc = 'Organize Imports',
})
vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightSetPythonPath', basedpyright_set_python_path, {
desc = 'Reconfigure basedpyright with the provided python path',
nargs = 1,
complete = 'file',
})
end
'';
};
luaConfigRC.basedpyright-util = entryBefore ["lsp-servers"] ''
local function basedpyright_set_python_path(server_name, command)
local path = command.args
local clients = vim.lsp.get_clients {
bufnr = vim.api.nvim_get_current_buf(),
name = server_name,
}
for _, client in ipairs(clients) do
if client.settings then
client.settings.python = vim.tbl_deep_extend('force', client.settings.python or {}, { pythonPath = path })
else
client.config.settings = vim.tbl_deep_extend('force', client.config.settings, { python = { pythonPath = path } })
end
client:notify('workspace/didChangeConfiguration', { settings = nil })
end
end
'';
};
};
}

30
modules/plugins/lsp/presets/bash-language-server.nix Normal file
View file

@ -0,0 +1,30 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.lsp.presets.bash-language-server;
in {
options.vim.lsp.presets.bash-language-server = {
enable = mkLspPresetEnableOption "bash-language-server" "Bash" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.bash-language-server = {
enable = true;
cmd = [(getExe pkgs.bash-language-server) "start"];
root_markers = [".git"];
settings = {
basheIde = {
globPattern = mkLuaInline "vim.env.GLOB_PATTERN or '*@(.sh|.inc|.bash|.command)'";
};
};
};
};
}

54
modules/plugins/lsp/presets/ccls.nix Normal file
View file

@ -0,0 +1,54 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.lsp.presets.ccls;
in {
options.vim.lsp.presets.ccls = {
enable = mkLspPresetEnableOption "ccls" "CC" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.ccls = {
enable = true;
cmd = [(getExe pkgs.ccls)];
offset_encoding = "utf-32";
root_markers = [".git" ".ccls" "compile_commands.json"];
workspace_required = true;
on_attach = mkLuaInline ''
function(client, bufnr)
local function switch_source_header(bufnr)
local method_name = "textDocument/switchSourceHeader"
local params = vim.lsp.util.make_text_document_params(bufnr)
client:request(method_name, params, function(err, result)
if err then
error(tostring(err))
end
if not result then
vim.notify('corresponding file cannot be determined')
return
end
vim.cmd.edit(vim.uri_to_fname(result))
end, bufnr)
end
vim.api.nvim_buf_create_user_command(
bufnr,
"LspCclsSwitchSourceHeader",
function(arg)
switch_source_header(client, 0)
end,
{desc = "Switch between source/header"}
)
end
'';
};
};
}

107
modules/plugins/lsp/presets/clangd.nix Normal file
View file

@ -0,0 +1,107 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe';
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.lsp.presets.clangd;
in {
options.vim.lsp.presets.clangd = {
enable = mkLspPresetEnableOption "clangd" "Clangd" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.clangd = {
enable = true;
cmd = [(getExe' pkgs.clang-tools "clangd")];
root_markers = [
".git"
".clangd"
".clang-tidy"
".clang-format"
"compile_commands.json"
"compile_flags.txt"
"configure.ac"
];
capabilities = {
textDocument = {
completion = {
editsNearCursor = true;
};
};
offsetEncoding = ["utf-8" "utf-16"];
};
on_attach = mkLuaInline ''
function(client, bufnr)
local function switch_source_header(bufnr)
local method_name = "textDocument/switchSourceHeader"
local client = vim.lsp.get_clients({ bufnr = bufnr, name = "clangd", })[1]
if not client then
return vim.notify(('method %s is not supported by any servers active on the current buffer'):format(method_name))
end
local params = vim.lsp.util.make_text_document_params(bufnr)
client.request(method_name, params, function(err, result)
if err then
error(tostring(err))
end
if not result then
vim.notify('corresponding file cannot be determined')
return
end
vim.cmd.edit(vim.uri_to_fname(result))
end, bufnr)
end
local function symbol_info()
local bufnr = vim.api.nvim_get_current_buf()
local clangd_client = vim.lsp.get_clients({ bufnr = bufnr, name = "clangd" })[1]
if not clangd_client or not clangd_client:supports_method 'textDocument/symbolInfo' then
return vim.notify('Clangd client not found', vim.log.levels.ERROR)
end
local win = vim.api.nvim_get_current_win()
local params = vim.lsp.util.make_position_params(win, clangd_client.offset_encoding)
clangd_client:request('textDocument/symbolInfo', params, function(err, res)
if err or #res == 0 then
-- Clangd always returns an error, there is not reason to parse it
return
end
local container = string.format('container: %s', res[1].containerName) ---@type string
local name = string.format('name: %s', res[1].name) ---@type string
vim.lsp.util.open_floating_preview({ name, container }, "", {
height = 2,
width = math.max(string.len(name), string.len(container)),
focusable = false,
focus = false,
border = 'single',
title = 'Symbol Info',
})
end, bufnr)
end
vim.api.nvim_buf_create_user_command(
bufnr,
"ClangdSwitchSourceHeader",
function(arg)
switch_source_header(0)
end,
{desc = "Switch between source/header"}
)
vim.api.nvim_buf_create_user_command(
bufnr,
"ClangdShowSymbolInfo",
function(arg)
symbol_info()
end,
{desc = "Show symbol info"}
)
end
'';
};
};
}

24
modules/plugins/lsp/presets/clojure-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.clojure-lsp;
in {
options.vim.lsp.presets.clojure-lsp = {
enable = mkLspPresetEnableOption "clojure-lsp" "Clojure" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.clojure-lsp = {
enable = true;
cmd = [(getExe pkgs.clojure-lsp)];
root_markers = [".git" "project.clj"];
};
};
}

24
modules/plugins/lsp/presets/cue.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.cue;
in {
options.vim.lsp.presets.cue = {
enable = mkLspPresetEnableOption "cue" "Cue" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.cue = {
enable = true;
cmd = [(getExe pkgs.cue) "lsp"];
root_markers = [".git" "cue.mod"];
};
};
}

37
modules/plugins/lsp/presets/dart.nix Normal file
View file

@ -0,0 +1,37 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
cfg = config.vim.lsp.presets.dart;
in {
options.vim.lsp.presets.dart = {
enable = mkLspPresetEnableOption "dart" "Dart" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.dart = {
enable = true;
cmd = [(getExe pkgs.dart) "language-server" "--protocol=lsp"];
root_markers = [".git" "pubspec.yaml"];
init_options = {
onlyAnalyzeProjectsWithOpenFiles = true;
suggestFromUnimportedLibraries = true;
closingLabels = true;
outline = true;
flutterOutline = true;
};
settings = {
dart = {
completeFunctionCalls = true;
showTodos = true;
};
};
};
};
}

75
modules/plugins/lsp/presets/default.nix Normal file
View file

@ -0,0 +1,75 @@
{
imports = [
./arduino-language-server.nix
./asm-lsp.nix
./astro-language-server.nix
./basedpyright.nix
./bash-language-server.nix
./ccls.nix
./clangd.nix
./clojure-lsp.nix
./cue.nix
./dart.nix
./deno.nix
./elixir-ls.nix
./elm-language-server.nix
./emmet-ls.nix
./fsautocomplete.nix
./gleam.nix
./glsl_analyzer.nix
./gopls.nix
./harper.nix
./helm-ls.nix
./intelephense.nix
./jdt-language-server.nix
./jinja-lsp.nix
./jq-lsp.nix
./julia-languageserver.nix
./just-lsp.nix
./kotlin-language-server.nix
./lemminx.nix
./lua-language-server.nix
./markdown-oxide.nix
./marksman.nix
./neocmakelsp.nix
./nil.nix
./nimlsp.nix
./nixd.nix
./nushell.nix
./ocaml-lsp.nix
./ols.nix
./openscad-lsp.nix
./phan.nix
./phpactor.nix
./pyrefly.nix
./pyright.nix
./python-lsp-server.nix
./qmlls.nix
./r-languageserver.nix
./ruby-lsp.nix
./ruff.nix
./rumdl.nix
./solargraph.nix
./sqls.nix
./superhtml.nix
./svelte-language-server.nix
./tailwindcss-language-server.nix
./taplo.nix
./terraform-ls.nix
./texlab.nix
./tinymist.nix
./tofu-ls.nix
./tombi.nix
./twig-language-server.nix
./ty.nix
./typescript-go.nix
./typescript-language-server.nix
./vala-language-server.nix
./vscode-css-language-server.nix
./vscode-json-language-server.nix
./wgsl-analyzer.nix
./yaml-language-server.nix
./zls.nix
./zuban.nix
];
}

111
modules/plugins/lsp/presets/deno.nix Normal file
View file

@ -0,0 +1,111 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.lsp.presets.deno;
in {
options.vim.lsp.presets.deno = {
enable = mkLspPresetEnableOption "deno" "Deno" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.deno = {
enable = true;
cmd = [(getExe pkgs.deno) "lsp"];
cmd_env = {NO_COLOR = true;};
root_markers = ["deno.json" "deno.jsonc" ".git"];
settings = {
deno = {
enable = true;
suggest = {
imports = {
hosts = {
"https://deno.land" = true;
};
};
};
};
};
handlers = let
handler = mkLuaInline ''
function(err, result, ctx, config)
local function nvf_denols_virtual_text_document_handler(uri, res, client)
if not res then
return nil
end
local lines = vim.split(res.result, '\n')
local bufnr = vim.uri_to_bufnr(uri)
local current_buf = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
if #current_buf ~= 0 then
return nil
end
vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
vim.api.nvim_set_option_value('readonly', true, { buf = bufnr })
vim.api.nvim_set_option_value('modified', false, { buf = bufnr })
vim.api.nvim_set_option_value('modifiable', false, { buf = bufnr })
vim.lsp.buf_attach_client(bufnr, client.id)
end
local function nvf_denols_virtual_text_document(uri, client)
local params = {
textDocument = {
uri = uri,
},
}
local result = client.request_sync('deno/virtualTextDocument', params)
nvf_denols_virtual_text_document_handler(uri, result, client)
end
if not result or vim.tbl_isempty(result) then
return nil
end
local client = vim.lsp.get_client_by_id(ctx.client_id)
for _, res in pairs(result) do
local uri = res.uri or res.targetUri
if uri:match '^deno:' then
nvf_denols_virtual_text_document(uri, client)
res['uri'] = uri
res['targetUri'] = uri
end
end
vim.lsp.handlers[ctx.method](err, result, ctx, config)
end
'';
in {
"textDocument/definition" = handler;
"textDocument/typeDefinition" = handler;
"textDocument/references" = handler;
};
on_attach = mkLuaInline ''
function(client, bufnr)
vim.api.nvim_buf_create_user_command(0, 'LspDenolsCache', function()
client:exec_cmd({
command = 'deno.cache',
arguments = { {}, vim.uri_from_bufnr(bufnr) },
}, { bufnr = bufnr }, function(err, _result, ctx)
if err then
local uri = ctx.params.arguments[2]
vim.api.nvim_err_writeln('cache command failed for ' .. vim.uri_to_fname(uri))
end
end)
end, {
desc = 'Cache a module and all of its dependencies.',
})
end
'';
};
};
}

34
modules/plugins/lsp/presets/elixir-ls.nix Normal file
View file

@ -0,0 +1,34 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.lsp.presets.elixir-ls;
in {
options.vim.lsp.presets.elixir-ls = {
enable = mkLspPresetEnableOption "elixir-ls" "Elixir" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.elixir-ls = {
enable = true;
cmd = [(getExe pkgs.elixir-ls)];
root_dir = mkLuaInline ''
function(bufnr, on_dir)
local fname = vim.api.nvim_buf_get_name(bufnr)
local matches = vim.fs.find({ 'mix.exs' }, { upward = true, limit = 2, path = fname })
local child_or_root_path, maybe_umbrella_path = unpack(matches)
local root_dir = vim.fs.dirname(maybe_umbrella_path or child_or_root_path)
on_dir(root_dir)
end
'';
};
};
}

25
modules/plugins/lsp/presets/elm-language-server.nix Normal file
View file

@ -0,0 +1,25 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
cfg = config.vim.lsp.presets.elm-language-server;
in {
options.vim.lsp.presets.elm-language-server = {
enable = mkLspPresetEnableOption "elm-language-server" "Elm" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.elm-language-server = {
enable = true;
cmd = [(getExe pkgs.elmPackages.elm-language-server)];
root_markers = [".git" "elm.json"];
workspace_required = false;
};
};
}

24
modules/plugins/lsp/presets/emmet-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.emmet-ls;
in {
options.vim.lsp.presets.emmet-ls = {
enable = mkLspPresetEnableOption "emmet-ls" "Emmet" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.emmet-ls = {
enable = true;
cmd = [(getExe pkgs.emmet-ls) "--stdio"];
root_markers = [".git"];
};
};
}

54
modules/plugins/lsp/presets/fsautocomplete.nix Normal file
View file

@ -0,0 +1,54 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.lsp.presets.fsautocomplete;
in {
options.vim.lsp.presets.fsautocomplete = {
enable = mkLspPresetEnableOption "fsautocomplete" "F# Autocomplete" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.fsautocomplete = {
enable = true;
cmd = [(getExe pkgs.fsautocomplete) "--adaptive-lsp-server-enabled"];
root_dir = mkLuaInline ''
function(bufnr, on_dir)
on_dir(vim.fs.root(bufnr, function(name, path)
return name == ".git" or name:match("%.sln$") or name:match("%.fsproj$")
end))
end
'';
init_options = {
AutomaticWorkspaceInit = true;
};
settings = {
FSharp = {
keywordsAutocomplete = true;
ExternalAutocomplete = false;
Linter = true;
UnionCaseStubGeneration = true;
UnionCaseStubGenerationBody = ''failwith "Not Implemented"'';
RecordStubGeneration = true;
RecordStubGenerationBody = ''failwith "Not Implemented"'';
InterfaceStubGeneration = true;
InterfaceStubGenerationObjectIdentifier = "this";
InterfaceStubGenerationMethodBody = ''failwith "Not Implemented"'';
UnusedOpensAnalyzer = true;
UnusedDeclarationsAnalyzer = true;
UseSdkScripts = true;
SimplifyNameAnalyzer = true;
ResolveNamespaces = true;
EnableReferenceCodeLens = true;
};
};
};
};
}

24
modules/plugins/lsp/presets/gleam.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.gleam;
in {
options.vim.lsp.presets.gleam = {
enable = mkLspPresetEnableOption "gleam" "Gleam" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.gleam = {
enable = true;
cmd = [(getExe pkgs.gleam) "lsp"];
root_markers = [".git" "gleam.toml"];
};
};
}

24
modules/plugins/lsp/presets/glsl_analyzer.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.glsl_analyzer;
in {
options.vim.lsp.presets.glsl_analyzer = {
enable = mkLspPresetEnableOption "glsl_analyzer" "GLSL Analyzer" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.glsl_analyzer = {
enable = true;
cmd = [(getExe pkgs.glsl_analyzer)];
root_markers = [".git"];
};
};
}

59
modules/plugins/lsp/presets/gopls.nix Normal file
View file

@ -0,0 +1,59 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.lsp.presets.gopls;
in {
options.vim.lsp.presets.gopls = {
enable = mkLspPresetEnableOption "gopls" "Go" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.gopls = {
enable = true;
cmd = [(getExe pkgs.gopls)];
root_dir = mkLuaInline ''
function(bufnr, on_dir)
local fname = vim.api.nvim_buf_get_name(bufnr)
local function get_root(fname)
if _G.nvf_gopls_mod_cache and fname:sub(1, #_G.nvf_gopls_mod_cache) == _G.nvf_gopls_mod_cache then
local clients = vim.lsp.get_clients { name = 'gopls' }
if #clients > 0 then
return clients[#clients].config.root_dir
end
end
return vim.fs.root(fname, 'go.work') or vim.fs.root(fname, 'go.mod') or vim.fs.root(fname, '.git')
end
-- see: https://github.com/neovim/nvim-lspconfig/issues/804
if _G.nvf_gopls_mod_cache then
on_dir(get_root(fname))
return
end
local cmd = { 'go', 'env', 'GOMODCACHE' }
local ok, err = pcall(vim.system, cmd, { text = true }, function(output)
if output.code == 0 then
if output.stdout then
_G.nvf_gopls_mod_cache = vim.trim(output.stdout)
end
on_dir(get_root(fname))
else
vim.schedule(function()
vim.notify(('[gopls] cmd failed with code %d: %s\n%s'):format(output.code, cmd, output.stderr))
end)
end
end)
if not ok then vim.notify(('[gopls] cmd failed: %s\n%s'):format(cmd, err)) end
end
'';
};
};
}

54
modules/plugins/lsp/presets/harper.nix Normal file
View file

@ -0,0 +1,54 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
cfg = config.vim.lsp.presets.harper;
filetypes = [
# <https://writewithharper.com/docs/integrations/language-server#Supported-Languages>
"asciidoc"
"c"
"clojure"
"cmake"
"cpp"
"cs"
"daml"
"dart"
"gitcommit"
"go"
"haskell"
"html"
"ink"
"java"
"javascript"
"javascriptreact"
"kotlin"
"lhaskell"
"lua"
"mail"
"markdown"
"nix"
"php"
"python"
"ruby"
"rust"
];
in {
options.vim.lsp.presets.harper = {
enable = mkLspPresetEnableOption "harper" "Harper" filetypes;
};
config = mkIf cfg.enable {
vim.lsp.servers.harper = {
enable = true;
cmd = [(getExe pkgs.harper) "--stdio"];
root_markers = [".git" ".harper-dictionary.txt"];
inherit filetypes;
};
};
}

29
modules/plugins/lsp/presets/helm-ls.nix Normal file
View file

@ -0,0 +1,29 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
cfg = config.vim.lsp.presets.helm-ls;
in {
options.vim.lsp.presets.helm-ls = {
enable = mkLspPresetEnableOption "helm-ls" "Helm" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.helm-ls = {
enable = true;
cmd = [(getExe pkgs.helm-ls) "serve"];
root_markers = [".git" "Chart.yaml"];
capabilities = {
didChangeWatchedFiles = {
dynamicRegistration = true;
};
};
};
};
}

24
modules/plugins/lsp/presets/intelephense.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.intelephense;
in {
options.vim.lsp.presets.intelephense = {
enable = mkLspPresetEnableOption "intelephense" "Intelephense" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.intelephense = {
enable = true;
cmd = [(getExe pkgs.intelephense) "--stdio"];
root_markers = [".git"];
};
};
}

136
modules/plugins/lsp/presets/jdt-language-server.nix Normal file
View file

@ -0,0 +1,136 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.dag) entryBefore;
cfg = config.vim.lsp.presets.jdt-language-server;
in {
options.vim.lsp.presets.jdt-language-server = {
enable = mkLspPresetEnableOption "jdt-language-server" "Eclipse JDT" [];
};
config = mkIf cfg.enable {
vim = {
lsp.servers.jdt-language-server = {
enable = true;
cmd = mkLuaInline ''
{
'${getExe pkgs.jdt-language-server}',
'-configuration',
get_jdtls_config_dir(),
'-data',
get_jdtls_workspace_dir(),
get_jdtls_jvm_args(),
}
'';
root_markers = [
# Multi-module projects
".git"
"build.gradle"
"build.gradle.kts"
# Single-module projects
"build.xml" # Ant
"pom.xml" # Maven
"settings.gradle" # Gradle
"settings.gradle.kts" # Gradle
];
init_options = {
workspace = mkLuaInline "get_jdtls_workspace_dir()";
jvm_args = {};
os_config = mkLuaInline "nil";
};
handlers = {
"textDocument/codeAction" = mkLuaInline "jdtls_on_textdocument_codeaction";
"textDocument/rename" = mkLuaInline "jdtls_on_textdocument_rename";
"workspace/applyEdit" = mkLuaInline "jdtls_on_workspace_applyedit";
"language/status" = mkLuaInline "vim.schedule_wrap(jdtls_on_language_status)";
};
};
luaConfigRC.jdtls-util = entryBefore ["lsp-servers"] ''
local jdtls_handlers = require 'vim.lsp.handlers'
local jdtls_env = {
HOME = vim.uv.os_homedir(),
XDG_CACHE_HOME = os.getenv 'XDG_CACHE_HOME',
JDTLS_JVM_ARGS = os.getenv 'JDTLS_JVM_ARGS',
}
local function get_cache_dir()
return jdtls_env.XDG_CACHE_HOME and jdtls_env.XDG_CACHE_HOME or jdtls_env.HOME .. '/.cache'
end
local function get_jdtls_cache_dir()
return get_cache_dir() .. '/jdtls'
end
local function get_jdtls_config_dir()
return get_jdtls_cache_dir() .. '/config'
end
local function get_jdtls_workspace_dir()
return get_jdtls_cache_dir() .. '/workspace'
end
local function get_jdtls_jvm_args()
local args = {}
for a in string.gmatch((jdtls_env.JDTLS_JVM_ARGS or '''), '%S+') do
local arg = string.format('--jvm-arg=%s', a)
table.insert(args, arg)
end
return unpack(args)
end
-- TextDocument version is reported as 0, override with nil so that
-- the client doesn't think the document is newer and refuses to update
-- See: https://github.com/eclipse/eclipse.jdt.ls/issues/1695
local function jdtls_fix_zero_version(workspace_edit)
if workspace_edit and workspace_edit.documentChanges then
for _, change in pairs(workspace_edit.documentChanges) do
local text_document = change.textDocument
if text_document and text_document.version and text_document.version == 0 then
text_document.version = nil
end
end
end
return workspace_edit
end
local function jdtls_on_textdocument_codeaction(err, actions, ctx)
for _, action in ipairs(actions) do
-- TODO: (steelsojka) Handle more than one edit?
if action.command == 'java.apply.workspaceEdit' then -- 'action' is Command in java format
action.edit = jdtls_fix_zero_version(action.edit or action.arguments[1])
elseif type(action.command) == 'table' and action.command.command == 'java.apply.workspaceEdit' then -- 'action' is CodeAction in java format
action.edit = jdtls_fix_zero_version(action.edit or action.command.arguments[1])
end
end
jdtls_handlers[ctx.method](err, actions, ctx)
end
local function jdtls_on_textdocument_rename(err, workspace_edit, ctx)
jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
end
local function jdtls_on_workspace_applyedit(err, workspace_edit, ctx)
jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
end
-- Non-standard notification that can be used to display progress
local function jdtls_on_language_status(_, result)
local command = vim.api.nvim_command
command 'echohl ModeMsg'
command(string.format('echo "%s"', result.message))
command 'echohl None'
end
'';
};
};
}

24
modules/plugins/lsp/presets/jinja-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.jinja-lsp;
in {
options.vim.lsp.presets.jinja-lsp = {
enable = mkLspPresetEnableOption "jinja-lsp" "Jinja" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.jinja-lsp = {
enable = true;
cmd = [(getExe pkgs.jinja-lsp)];
root_markers = [".git"];
};
};
}

24
modules/plugins/lsp/presets/jq-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.jq-lsp;
in {
options.vim.lsp.presets.jq-lsp = {
enable = mkLspPresetEnableOption "jq-lsp" "JQ" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.jq-lsp = {
enable = true;
cmd = [(getExe pkgs.jq-lsp)];
root_markers = [".git"];
};
};
}

129
modules/plugins/lsp/presets/julia-languageserver.nix Normal file
View file

@ -0,0 +1,129 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.dag) entryBefore;
cfg = config.vim.lsp.presets.julia-languageserver;
in {
options.vim.lsp.presets.julia-languageserver = {
enable = mkLspPresetEnableOption "julia-languageserver" "Julia" [];
};
config = mkIf cfg.enable {
vim = {
lsp.servers.julia-languageserver = {
enable = true;
root_markers = ["Project.toml" "JuliaProject.toml"];
cmd = mkLuaInline ''
{
'${getExe (pkgs.julia.withPackages ["LanguageServer"])}',
'--startup-file=no',
'--history-file=no',
'-e',
[[
# Load LanguageServer.jl: attempt to load from ~/.julia/environments/nvim-lspconfig
# with the regular load path as a fallback
ls_install_path = joinpath(
get(DEPOT_PATH, 1, joinpath(homedir(), ".julia")),
"environments", "nvim-lspconfig"
)
pushfirst!(LOAD_PATH, ls_install_path)
using LanguageServer
popfirst!(LOAD_PATH)
depot_path = get(ENV, "JULIA_DEPOT_PATH", "")
project_path = let
dirname(something(
## 1. Finds an explicitly set project (JULIA_PROJECT)
Base.load_path_expand((
p = get(ENV, "JULIA_PROJECT", nothing);
p === nothing ? nothing : isempty(p) ? nothing : p
)),
## 2. Look for a Project.toml file in the current working directory,
## or parent directories, with $HOME as an upper boundary
Base.current_project(),
## 3. First entry in the load path
get(Base.load_path(), 1, nothing),
## 4. Fallback to default global environment,
## this is more or less unreachable
Base.load_path_expand("@v#.#"),
))
end
@info "Running language server" VERSION pwd() project_path depot_path
server = LanguageServer.LanguageServerInstance(stdin, stdout, project_path, depot_path)
server.runlinter = true
run(server)
]],
}
'';
on_attach = mkLuaInline ''
function(_, bufnr)
vim.api.nvim_buf_create_user_command(bufnr, 'LspJuliaActivateEnv', activate_julia_env, {
desc = 'Activate a Julia environment',
nargs = '?',
complete = 'file',
})
end
'';
};
luaConfigRC.julia-util = entryBefore ["lsp-servers"] ''
local function activate_julia_env(path)
assert(vim.fn.has 'nvim-0.10' == 1, 'requires Nvim 0.10 or newer')
local bufnr = vim.api.nvim_get_current_buf()
local julials_clients = vim.lsp.get_clients { bufnr = bufnr, name = 'julials' }
assert(
#julials_clients > 0,
'method julia/activateenvironment is not supported by any servers active on the current buffer'
)
local function _activate_env(environment)
if environment then
for _, julials_client in ipairs(julials_clients) do
julials_client:notify('julia/activateenvironment', { envPath = environment })
end
vim.notify('Julia environment activated: \n`' .. environment .. '`', vim.log.levels.INFO)
end
end
if path then
path = vim.fs.normalize(vim.fn.fnamemodify(vim.fn.expand(path), ':p'))
local found_env = false
for _, project_file in ipairs(root_files) do
local file = vim.uv.fs_stat(vim.fs.joinpath(path, project_file))
if file and file.type then
found_env = true
break
end
end
if not found_env then
vim.notify('Path is not a julia environment: \n`' .. path .. '`', vim.log.levels.WARN)
return
end
_activate_env(path)
else
local depot_paths = vim.env.JULIA_DEPOT_PATH
and vim.split(vim.env.JULIA_DEPOT_PATH, vim.fn.has 'win32' == 1 and ';' or ':')
or { vim.fn.expand '~/.julia' }
local environments = {}
vim.list_extend(environments, vim.fs.find(root_files, { type = 'file', upward = true, limit = math.huge }))
for _, depot_path in ipairs(depot_paths) do
local depot_env = vim.fs.joinpath(vim.fs.normalize(depot_path), 'environments')
vim.list_extend(
environments,
vim.fs.find(function(name, env_path)
return vim.tbl_contains(root_files, name) and string.sub(env_path, #depot_env + 1):match '^/[^/]*$'
end, { path = depot_env, type = 'file', limit = math.huge })
)
end
environments = vim.tbl_map(vim.fs.dirname, environments)
vim.ui.select(environments, { prompt = 'Select a Julia environment' }, _activate_env)
end
end
'';
};
};
}

24
modules/plugins/lsp/presets/just-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.just-lsp;
in {
options.vim.lsp.presets.just-lsp = {
enable = mkLspPresetEnableOption "just-lsp" "Just" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.just-lsp = {
enable = true;
cmd = [(getExe pkgs.just-lsp)];
root_markers = [".git" "Justfile" "justfile"];
};
};
}

46
modules/plugins/lsp/presets/kotlin-language-server.nix Normal file
View file

@ -0,0 +1,46 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.lsp.presets.kotlin-language-server;
in {
options.vim.lsp.presets.kotlin-language-server = {
enable = mkLspPresetEnableOption "kotlin-language-server" "Kotlin" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.kotlin-language-server = {
enable = true;
cmd = [(getExe pkgs.kotlin-language-server)];
root_markers = [
"settings.gradle" # Gradle (multi-project)
"settings.gradle.kts" # Gradle (multi-project)
"build.xml" # Ant
"pom.xml" # Maven
"build.gradle" # Gradle
"build.gradle.kts" # gradle
];
init_options = {
storagePath = mkLuaInline ''
vim.fs.root(vim.fn.expand '%:p:h',
{
'settings.gradle', -- Gradle (multi-project)
'settings.gradle.kts', -- Gradle (multi-project)
'build.xml', -- Ant
'pom.xml', -- Maven
'build.gradle', -- Gradle
'build.gradle.kts', -- Gradle
}
)
'';
};
};
};
}

24
modules/plugins/lsp/presets/lemminx.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.lemminx;
in {
options.vim.lsp.presets.lemminx = {
enable = mkLspPresetEnableOption "lemminx" "Lemminx" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.lemminx = {
enable = true;
cmd = [(getExe pkgs.lemminx)];
root_markers = [".git"];
};
};
}

33
modules/plugins/lsp/presets/lua-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.lua-language-server;
in {
options.vim.lsp.presets.lua-language-server = {
enable = mkLspPresetEnableOption "lua-language-server" "Lua" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.lua-language-server = {
enable = true;
cmd = [(getExe pkgs.lua-language-server)];
root_markers = [
".luarc.json"
".luarc.jsonc"
".luacheckrc"
".stylua.toml"
"stylua.toml"
"selene.toml"
"selene.yml"
".git"
];
};
};
}

24
modules/plugins/lsp/presets/markdown-oxide.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.markdown-oxide;
in {
options.vim.lsp.presets.markdown-oxide = {
enable = mkLspPresetEnableOption "markdown-oxide" "Markdown Oxide" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.markdown-oxide = {
enable = true;
cmd = [(getExe pkgs.markdown-oxide)];
root_markers = [".git" ".moxide.toml" ".obsidian"];
};
};
}

24
modules/plugins/lsp/presets/marksman.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.marksman;
in {
options.vim.lsp.presets.marksman = {
enable = mkLspPresetEnableOption "marksman" "Marksman" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.marksman = {
enable = true;
cmd = [(getExe pkgs.marksman) "server"];
root_markers = [".git" ".marksman.toml"];
};
};
}

27
modules/plugins/lsp/presets/neocmakelsp.nix Normal file
View file

@ -0,0 +1,27 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
cfg = config.vim.lsp.presets.neocmakelsp;
in {
options.vim.lsp.presets.neocmakelsp = {
enable = mkLspPresetEnableOption "neocmakelsp" "NeoCmake" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.neocmakelsp = {
enable = true;
cmd = [(getExe pkgs.neocmakelsp) "stdio"];
root_markers = [".git" ".gersemirc"];
capabilities = {
textDocument.completion.completionItem.snippetSupport = true;
};
};
};
}

24
modules/plugins/lsp/presets/nil.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.nil;
in {
options.vim.lsp.presets.nil = {
enable = mkLspPresetEnableOption "nil" "Nil" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.nil = {
enable = true;
cmd = [(getExe pkgs.nil)];
root_markers = [".git"];
};
};
}

32
modules/plugins/lsp/presets/nimlsp.nix Normal file
View file

@ -0,0 +1,32 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf;
inherit (lib.nvim.types) mkLspPresetEnableOption;
inherit (lib.generators) mkLuaInline;
cfg = config.vim.lsp.presets.nimlsp;
in {
options.vim.lsp.presets.nimlsp = {
enable = mkLspPresetEnableOption "nimlsp" "Nim" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.nimlsp = {
enable = true;
cmd = [(getExe pkgs.nimlsp)];
root_dir = mkLuaInline ''
function(bufnr, on_dir)
local fname = vim.api.nvim_buf_get_name(bufnr)
on_dir(
util.root_pattern '*.nimble'(fname) or vim.fs.dirname(vim.fs.find('.git', { path = fname, upward = true })[1])
)
end
'';
};
};
}

24
modules/plugins/lsp/presets/nixd.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.nixd;
in {
options.vim.lsp.presets.nixd = {
enable = mkLspPresetEnableOption "nixd" "Nixd" [];
};
config = mkIf cfg.enable {
vim.lsp.servers.nixd = {
enable = true;
cmd = [(getExe pkgs.nixd)];
root_markers = [".git"];
};
};
}

Some files were not shown because too many files have changed in this diff Show more