mirror of
https://github.com/NotAShelf/nvf.git
synced 2025-11-03 20:22:21 +00:00
Merge 11bb5982c5 into 9aa9088564
This commit is contained in:
Samuel Cobb
GitHub
commit
b3e5a452b2
29 changed files with 1258 additions and 850 deletions
|
|
@ -83,7 +83,8 @@ isMaximal: {
|
|||
dart.enable = false;
|
||||
ocaml.enable = false;
|
||||
elixir.enable = false;
|
||||
haskell.enable = false;
|
||||
haskell.enable = true;
|
||||
hcl.enable = true;
|
||||
ruby.enable = false;
|
||||
fsharp.enable = false;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
{lib}: let
|
||||
inherit (builtins) isString getAttr;
|
||||
inherit (lib.options) mkOption;
|
||||
inherit (lib.types) listOf bool str submodule attrsOf anything either nullOr;
|
||||
inherit (lib.types) listOf bool str submodule attrsOf anything either nullOr oneOf;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
inherit (lib.nvim.types) luaInline;
|
||||
in {
|
||||
|
|
@ -62,7 +62,7 @@ in {
|
|||
};
|
||||
|
||||
cmd = mkOption {
|
||||
type = nullOr (listOf str);
|
||||
type = nullOr (either luaInline (listOf str));
|
||||
default = null;
|
||||
description = "Command used to start the LSP server";
|
||||
};
|
||||
|
|
|
|||
|
|
@ -8,5 +8,6 @@
|
|||
./highlight.nix
|
||||
./lsp.nix
|
||||
./spellcheck.nix
|
||||
./util.nix
|
||||
];
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@
|
|||
|
||||
cfg = config.vim.lsp;
|
||||
|
||||
# TODO: lspConfigurations filter on enabledServers instead of cfg.servers?
|
||||
lspConfigurations =
|
||||
mapAttrsToList (
|
||||
name: value: ''
|
||||
|
|
|
|||
178
modules/neovim/init/util.nix
Normal file
178
modules/neovim/init/util.nix
Normal file
|
|
@ -0,0 +1,178 @@
|
|||
{
|
||||
config,
|
||||
lib,
|
||||
...
|
||||
}: let
|
||||
inherit (builtins) filter;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.nvim.dag) entryBefore;
|
||||
|
||||
cfg = config.vim.lsp;
|
||||
in {
|
||||
config = mkMerge [
|
||||
(mkIf (cfg.servers != {}) {
|
||||
vim.luaConfigRC.lsp-util =
|
||||
entryBefore ["lsp-servers"]
|
||||
/*
|
||||
lua
|
||||
*/
|
||||
''
|
||||
-- Port of nvim-lspconfig util
|
||||
local util = { path = {} }
|
||||
|
||||
util.default_config = {
|
||||
log_level = vim.lsp.protocol.MessageType.Warning,
|
||||
message_level = vim.lsp.protocol.MessageType.Warning,
|
||||
settings = vim.empty_dict(),
|
||||
init_options = vim.empty_dict(),
|
||||
handlers = {},
|
||||
autostart = true,
|
||||
capabilities = vim.lsp.protocol.make_client_capabilities(),
|
||||
}
|
||||
|
||||
-- global on_setup hook
|
||||
util.on_setup = nil
|
||||
|
||||
do
|
||||
local validate = vim.validate
|
||||
local api = vim.api
|
||||
local lsp = vim.lsp
|
||||
local nvim_eleven = vim.fn.has 'nvim-0.11' == 1
|
||||
|
||||
local iswin = vim.uv.os_uname().version:match 'Windows'
|
||||
|
||||
local function escape_wildcards(path)
|
||||
return path:gsub('([%[%]%?%*])', '\\%1')
|
||||
end
|
||||
|
||||
local function is_fs_root(path)
|
||||
if iswin then
|
||||
return path:match '^%a:$'
|
||||
else
|
||||
return path == '/'
|
||||
end
|
||||
end
|
||||
|
||||
local function traverse_parents(path, cb)
|
||||
path = vim.uv.fs_realpath(path)
|
||||
local dir = path
|
||||
-- Just in case our algo is buggy, don't infinite loop.
|
||||
for _ = 1, 100 do
|
||||
dir = vim.fs.dirname(dir)
|
||||
if not dir then
|
||||
return
|
||||
end
|
||||
-- If we can't ascend further, then stop looking.
|
||||
if cb(dir, path) then
|
||||
return dir, path
|
||||
end
|
||||
if is_fs_root(dir) then
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
util.root_pattern = function(...)
|
||||
local patterns = util.tbl_flatten { ... }
|
||||
return function(startpath)
|
||||
startpath = util.strip_archive_subpath(startpath)
|
||||
for _, pattern in ipairs(patterns) do
|
||||
local match = util.search_ancestors(startpath, function(path)
|
||||
for _, p in ipairs(vim.fn.glob(table.concat({ escape_wildcards(path), pattern }, '/'), true, true)) do
|
||||
if vim.uv.fs_stat(p) then
|
||||
return path
|
||||
end
|
||||
end
|
||||
end)
|
||||
|
||||
if match ~= nil then
|
||||
return match
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
util.root_markers_with_field = function(root_files, new_names, field, fname)
|
||||
local path = vim.fn.fnamemodify(fname, ':h')
|
||||
local found = vim.fs.find(new_names, { path = path, upward = true })
|
||||
|
||||
for _, f in ipairs(found or {}) do
|
||||
-- Match the given `field`.
|
||||
for line in io.lines(f) do
|
||||
if line:find(field) then
|
||||
root_files[#root_files + 1] = vim.fs.basename(f)
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return root_files
|
||||
end
|
||||
|
||||
util.insert_package_json = function(root_files, field, fname)
|
||||
return util.root_markers_with_field(root_files, { 'package.json', 'package.json5' }, field, fname)
|
||||
end
|
||||
|
||||
util.strip_archive_subpath = function(path)
|
||||
-- Matches regex from zip.vim / tar.vim
|
||||
path = vim.fn.substitute(path, 'zipfile://\\(.\\{-}\\)::[^\\\\].*$', '\\1', ''')
|
||||
path = vim.fn.substitute(path, 'tarfile:\\(.\\{-}\\)::.*$', '\\1', ''')
|
||||
return path
|
||||
end
|
||||
|
||||
util.get_typescript_server_path = function(root_dir)
|
||||
local project_roots = vim.fs.find('node_modules', { path = root_dir, upward = true, limit = math.huge })
|
||||
for _, project_root in ipairs(project_roots) do
|
||||
local typescript_path = project_root .. '/typescript'
|
||||
local stat = vim.loop.fs_stat(typescript_path)
|
||||
if stat and stat.type == 'directory' then
|
||||
return typescript_path .. '/lib'
|
||||
end
|
||||
end
|
||||
return '''
|
||||
end
|
||||
|
||||
util.search_ancestors = function(startpath, func)
|
||||
if nvim_eleven then
|
||||
validate('func', func, 'function')
|
||||
end
|
||||
if func(startpath) then
|
||||
return startpath
|
||||
end
|
||||
local guard = 100
|
||||
for path in vim.fs.parents(startpath) do
|
||||
-- Prevent infinite recursion if our algorithm breaks
|
||||
guard = guard - 1
|
||||
if guard == 0 then
|
||||
return
|
||||
end
|
||||
|
||||
if func(path) then
|
||||
return path
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
util.path.is_descendant = function(root, path)
|
||||
if not path then
|
||||
return false
|
||||
end
|
||||
|
||||
local function cb(dir, _)
|
||||
return dir == root
|
||||
end
|
||||
|
||||
local dir, _ = traverse_parents(path, cb)
|
||||
|
||||
return dir == root
|
||||
end
|
||||
|
||||
util.tbl_flatten = function(t)
|
||||
--- @diagnostic disable-next-line:deprecated
|
||||
return nvim_eleven and vim.iter(t):flatten(math.huge):totable() or vim.tbl_flatten(t)
|
||||
end
|
||||
end
|
||||
'';
|
||||
})
|
||||
];
|
||||
}
|
||||
|
|
@ -4,12 +4,24 @@
|
|||
lib,
|
||||
...
|
||||
}: let
|
||||
inherit (builtins) attrNames;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.types) package;
|
||||
inherit (lib.types) package enum listOf;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.assembly;
|
||||
defaultServers = ["asm-lsp"];
|
||||
servers = {
|
||||
asm-lsp = {
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.asm-lsp)];
|
||||
filetypes = ["asm" "vmasm"];
|
||||
root_markers = [".asm-lsp.toml" ".git"];
|
||||
};
|
||||
};
|
||||
in {
|
||||
options.vim.languages.assembly = {
|
||||
enable = mkEnableOption "Assembly support";
|
||||
|
|
@ -20,12 +32,11 @@ in {
|
|||
};
|
||||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Assembly LSP support (asm-lsp)" // {default = config.vim.lsp.enable;};
|
||||
|
||||
package = mkOption {
|
||||
type = package;
|
||||
default = pkgs.asm-lsp;
|
||||
description = "asm-lsp package";
|
||||
enable = mkEnableOption "Assembly LSP support" // {default = config.vim.lsp.enable;};
|
||||
servers = mkOption {
|
||||
description = "Assembly LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
|
@ -36,14 +47,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.asm-lsp = ''
|
||||
lspconfig.asm_lsp.setup {
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = {"${cfg.lsp.package}/bin/asm-lsp"},
|
||||
}
|
||||
'';
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,24 +11,33 @@
|
|||
inherit (lib.meta) getExe;
|
||||
inherit (lib.types) enum either listOf package str;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
inherit (lib.nvim.types) mkGrammarOption diagnostics;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
|
||||
cfg = config.vim.languages.astro;
|
||||
|
||||
defaultServer = "astro";
|
||||
defaultServers = ["astro"];
|
||||
servers = {
|
||||
astro = {
|
||||
package = pkgs.astro-language-server;
|
||||
lspConfig = ''
|
||||
lspconfig.astro.setup {
|
||||
capabilities = capabilities,
|
||||
on_attach = attach_keymaps,
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/astro-ls", "--stdio"}''
|
||||
}
|
||||
}
|
||||
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
|
||||
'';
|
||||
};
|
||||
};
|
||||
|
|
@ -81,18 +90,10 @@ in {
|
|||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Astro LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
server = mkOption {
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
servers = mkOption {
|
||||
description = "Astro LSP server to use";
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
example = ''[lib.getExe pkgs.astro-language-server "--minify" "--stdio"]'';
|
||||
description = "Astro LSP server package, or the command to run as a list of strings";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -130,8 +131,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.astro-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
(mkIf cfg.format.enable {
|
||||
|
|
|
|||
|
|
@ -10,26 +10,25 @@
|
|||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) enum either package listOf str bool;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
inherit (lib.nvim.types) diagnostics mkGrammarOption;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.bash;
|
||||
|
||||
defaultServer = "bash-ls";
|
||||
defaultServers = ["bash-ls"];
|
||||
servers = {
|
||||
bash-ls = {
|
||||
package = pkgs.bash-language-server;
|
||||
lspConfig = ''
|
||||
lspconfig.bashls.setup{
|
||||
capabilities = capabilities;
|
||||
on_attach = default_on_attach;
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/bash-language-server", "start"}''
|
||||
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)'";
|
||||
};
|
||||
};
|
||||
}
|
||||
'';
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -56,19 +55,11 @@ in {
|
|||
};
|
||||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Enable Bash LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
server = mkOption {
|
||||
enable = mkEnableOption "Bash LSP support" // {default = config.vim.lsp.enable;};
|
||||
servers = mkOption {
|
||||
description = "Bash LSP server to use";
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
description = "bash-language-server package, or the command to run as a list of strings";
|
||||
example = literalExpression ''[lib.getExe pkgs.bash-language-server "start"]'';
|
||||
type = either package (listOf str);
|
||||
default = pkgs.bash-language-server;
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -108,8 +99,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.bash-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
(mkIf cfg.format.enable {
|
||||
|
|
|
|||
|
|
@ -4,15 +4,27 @@
|
|||
lib,
|
||||
...
|
||||
}: let
|
||||
inherit (builtins) attrNames;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) either listOf package str;
|
||||
inherit (lib.types) enum either listOf package str;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
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"];
|
||||
};
|
||||
};
|
||||
in {
|
||||
options.vim.languages.clojure = {
|
||||
enable = mkEnableOption "Clojure language support";
|
||||
|
|
@ -24,28 +36,22 @@ in {
|
|||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Clojure LSP support" // {default = config.vim.lsp.enable;};
|
||||
package = mkOption {
|
||||
type = either package (listOf str);
|
||||
default = pkgs.clojure-lsp;
|
||||
description = "Clojure LSP";
|
||||
servers = mkOption {
|
||||
description = "Clojure LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
config = mkIf cfg.enable (mkMerge [
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.clojure-lsp = ''
|
||||
lspconfig.clojure_lsp.setup {
|
||||
capabilities = capabilities;
|
||||
on_attach = default_on_attach;
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${getExe cfg.lsp.package}"}''
|
||||
};
|
||||
}
|
||||
'';
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
(mkIf cfg.treesitter.enable {
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
}: let
|
||||
inherit (builtins) attrNames;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.trivial) boolToString;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
|
|
@ -14,26 +15,31 @@
|
|||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.dag) entryAfter;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.dart;
|
||||
ftcfg = cfg.flutter-tools;
|
||||
|
||||
defaultServer = "dart";
|
||||
defaultServers = ["dart"];
|
||||
servers = {
|
||||
dart = {
|
||||
package = pkgs.dart;
|
||||
lspConfig = ''
|
||||
lspconfig.dartls.setup{
|
||||
capabilities = capabilities;
|
||||
on_attach=default_on_attach;
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/dart", "language-server", "--protocol=lsp"}''
|
||||
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;
|
||||
};
|
||||
};
|
||||
${optionalString (cfg.lsp.opts != null) "init_options = ${cfg.lsp.dartOpts}"}
|
||||
}
|
||||
'';
|
||||
};
|
||||
};
|
||||
in {
|
||||
|
|
@ -46,23 +52,11 @@ in {
|
|||
};
|
||||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Dart LSP support";
|
||||
server = mkOption {
|
||||
description = "The Dart LSP server to use";
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
};
|
||||
package = mkOption {
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
|
||||
description = "Dart LSP server package, or the command to run as a list of strings";
|
||||
};
|
||||
|
||||
opts = mkOption {
|
||||
type = nullOr str;
|
||||
default = null;
|
||||
description = "Options to pass to Dart LSP server";
|
||||
enable = mkEnableOption "Dart LSP support" // {default = config.vim.lsp.enable;};
|
||||
servers = mkOption {
|
||||
description = "Dart LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -131,19 +125,23 @@ in {
|
|||
};
|
||||
};
|
||||
|
||||
config.vim = mkIf cfg.enable (mkMerge [
|
||||
config = mkIf cfg.enable (mkMerge [
|
||||
(mkIf cfg.treesitter.enable {
|
||||
treesitter.enable = true;
|
||||
treesitter.grammars = [cfg.treesitter.package];
|
||||
vim.treesitter.enable = true;
|
||||
vim.treesitter.grammars = [cfg.treesitter.package];
|
||||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
lsp.lspconfig.enable = true;
|
||||
lsp.lspconfig.sources.dart-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
(mkIf ftcfg.enable {
|
||||
startPlugins = [
|
||||
vim.startPlugins = [
|
||||
(
|
||||
if ftcfg.enableNoResolvePatch
|
||||
then "flutter-tools-patched"
|
||||
|
|
@ -152,7 +150,7 @@ in {
|
|||
"plenary-nvim"
|
||||
];
|
||||
|
||||
pluginRC.flutter-tools = entryAfter ["lsp-setup"] ''
|
||||
vim.pluginRC.flutter-tools = entryAfter ["lsp-servers"] ''
|
||||
require('flutter-tools').setup {
|
||||
${optionalString (ftcfg.flutterPackage != null) "flutter_path = \"${ftcfg.flutterPackage}/bin/flutter\","}
|
||||
lsp = {
|
||||
|
|
|
|||
|
|
@ -8,28 +8,36 @@
|
|||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.types) enum either listOf package str;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.nvim.dag) entryAnywhere;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.elixir;
|
||||
|
||||
defaultServer = "elixirls";
|
||||
defaultServers = ["elixirls"];
|
||||
servers = {
|
||||
elixirls = {
|
||||
package = pkgs.elixir-ls;
|
||||
lspConfig = ''
|
||||
-- elixirls setup
|
||||
lspconfig.elixirls.setup {
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/elixir-ls"}''
|
||||
}
|
||||
}
|
||||
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
|
||||
'';
|
||||
};
|
||||
};
|
||||
|
|
@ -54,18 +62,10 @@ in {
|
|||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Elixir LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
server = mkOption {
|
||||
servers = mkOption {
|
||||
description = "Elixir LSP server to use";
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
description = "Elixir LSP server package, or the command to run as a list of strings";
|
||||
example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -97,8 +97,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.elixir-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
(mkIf cfg.format.enable {
|
||||
|
|
|
|||
|
|
@ -8,27 +8,21 @@
|
|||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.types) enum either listOf package str;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.gleam;
|
||||
|
||||
defaultServer = "gleam";
|
||||
defaultServers = ["gleam"];
|
||||
servers = {
|
||||
gleam = {
|
||||
package = pkgs.gleam;
|
||||
lspConfig = ''
|
||||
lspconfig.gleam.setup{
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/gleam", "lsp"}''
|
||||
}
|
||||
}
|
||||
'';
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.gleam) "lsp"];
|
||||
filetypes = ["gleam"];
|
||||
root_markers = ["gleam.toml" ".git"];
|
||||
};
|
||||
};
|
||||
in {
|
||||
|
|
@ -42,17 +36,10 @@ in {
|
|||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Gleam LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
server = mkOption {
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
servers = mkOption {
|
||||
description = "Gleam LSP server to use";
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
description = "Gleam LSP server package, or the command to run as a list of strings";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
|
@ -64,8 +51,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.gleam-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,17 +4,67 @@
|
|||
pkgs,
|
||||
...
|
||||
}: let
|
||||
inherit (builtins) isList;
|
||||
inherit (lib.types) either package listOf str;
|
||||
inherit (builtins) isList attrNames;
|
||||
inherit (lib.types) either package enum listOf str;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.strings) optionalString;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.dag) entryAfter;
|
||||
inherit (lib.nvim.dag) entryAfter entryBefore;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.meta) getExe';
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
inherit (pkgs) haskellPackages;
|
||||
inherit (lib.nvim.lua) toLuaObject;
|
||||
|
||||
cfg = config.vim.languages.haskell;
|
||||
|
||||
defaultServers = ["hls"];
|
||||
servers = {
|
||||
hls = {
|
||||
enable = false;
|
||||
cmd = [(getExe' pkgs.haskellPackages.haskell-language-server "haskell-language-server-wrapper") "--lsp"];
|
||||
filetypes = ["haskell" "lhaskell"];
|
||||
on_attach =
|
||||
mkLuaInline
|
||||
/*
|
||||
lua
|
||||
*/
|
||||
''
|
||||
function(client, bufnr)
|
||||
local ht = require("haskell-tools")
|
||||
default_on_attach(client, bufnr, ht)
|
||||
local opts = { noremap = true, silent = true, buffer = bufnr }
|
||||
vim.keymap.set('n', '<localleader>cl', vim.lsp.codelens.run, opts)
|
||||
vim.keymap.set('n', '<localleader>hs', ht.hoogle.hoogle_signature, opts)
|
||||
vim.keymap.set('n', '<localleader>ea', ht.lsp.buf_eval_all, opts)
|
||||
vim.keymap.set('n', '<localleader>rr', ht.repl.toggle, opts)
|
||||
vim.keymap.set('n', '<localleader>rf', function()
|
||||
ht.repl.toggle(vim.api.nvim_buf_get_name(0))
|
||||
end, opts)
|
||||
vim.keymap.set('n', '<localleader>rq', ht.repl.quit, opts)
|
||||
end
|
||||
'';
|
||||
root_dir =
|
||||
mkLuaInline
|
||||
/*
|
||||
lua
|
||||
*/
|
||||
''
|
||||
function(bufnr, on_dir)
|
||||
local fname = vim.api.nvim_buf_get_name(bufnr)
|
||||
on_dir(util.root_pattern('hie.yaml', 'stack.yaml', 'cabal.project', '*.cabal', 'package.yaml')(fname))
|
||||
end
|
||||
'';
|
||||
settings = {
|
||||
haskell = {
|
||||
formattingProvider = "ormolu";
|
||||
cabalFormattingProvider = "cabalfmt";
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
in {
|
||||
options.vim.languages.haskell = {
|
||||
enable = mkEnableOption "Haskell support";
|
||||
|
|
@ -25,12 +75,11 @@ in {
|
|||
};
|
||||
|
||||
lsp = {
|
||||
enable = mkEnableOption "LSP support for Haskell" // {default = config.vim.lsp.enable;};
|
||||
package = mkOption {
|
||||
description = "Haskell LSP package or command to run the Haskell LSP";
|
||||
example = ''[ (lib.getExe pkgs.haskellPackages.haskell-language-server) "--debug" ]'';
|
||||
default = haskellPackages.haskell-language-server;
|
||||
type = either package (listOf str);
|
||||
enable = mkEnableOption "Haskell LSP support" // {default = config.vim.lsp.enable;};
|
||||
servers = mkOption {
|
||||
description = "Haskell LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -57,7 +106,7 @@ in {
|
|||
startPlugins = ["haskell-tools-nvim"];
|
||||
luaConfigRC.haskell-tools-nvim =
|
||||
entryAfter
|
||||
["lsp-setup"]
|
||||
["lsp-servers"]
|
||||
''
|
||||
vim.g.haskell_tools = {
|
||||
${optionalString cfg.lsp.enable ''
|
||||
|
|
@ -67,25 +116,7 @@ in {
|
|||
enable = true,
|
||||
},
|
||||
},
|
||||
hls = {
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/haskell-language-server-wrapper", "--lsp"}''
|
||||
},
|
||||
on_attach = function(client, bufnr, ht)
|
||||
default_on_attach(client, bufnr, ht)
|
||||
local opts = { noremap = true, silent = true, buffer = bufnr }
|
||||
vim.keymap.set('n', '<localleader>cl', vim.lsp.codelens.run, opts)
|
||||
vim.keymap.set('n', '<localleader>hs', ht.hoogle.hoogle_signature, opts)
|
||||
vim.keymap.set('n', '<localleader>ea', ht.lsp.buf_eval_all, opts)
|
||||
vim.keymap.set('n', '<localleader>rr', ht.repl.toggle, opts)
|
||||
vim.keymap.set('n', '<localleader>rf', function()
|
||||
ht.repl.toggle(vim.api.nvim_buf_get_name(0))
|
||||
end, opts)
|
||||
vim.keymap.set('n', '<localleader>rq', ht.repl.quit, opts)
|
||||
end,
|
||||
},
|
||||
hls = ${toLuaObject servers.hls}
|
||||
''}
|
||||
${optionalString cfg.dap.enable ''
|
||||
dap = {
|
||||
|
|
|
|||
|
|
@ -8,22 +8,19 @@
|
|||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.types) package bool enum;
|
||||
inherit (lib.types) package bool enum listOf;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.hcl;
|
||||
|
||||
defaultServer = "terraform-ls";
|
||||
defaultServers = ["terraform-ls"];
|
||||
servers = {
|
||||
terraform-ls = {
|
||||
package = pkgs.terraform-ls;
|
||||
lspConfig = ''
|
||||
lspconfig.terraformls.setup {
|
||||
capabilities = capabilities,
|
||||
on_attach=default_on_attach,
|
||||
cmd = {"${lib.getExe cfg.lsp.package}", "serve"},
|
||||
}
|
||||
'';
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.terraform-ls) "serve"];
|
||||
filetypes = ["terraform" "terraform-vars"];
|
||||
root_markers = [".terraform" ".git"];
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -43,12 +40,11 @@ in {
|
|||
};
|
||||
|
||||
lsp = {
|
||||
enable = mkEnableOption "HCL LSP support (terraform-ls)" // {default = config.vim.lsp.enable;};
|
||||
# TODO: (maybe, is it better?) it would be cooler to use vscode-extensions.hashicorp.hcl probably, shouldn't be too hard
|
||||
package = mkOption {
|
||||
type = package;
|
||||
default = servers.${defaultServer}.package;
|
||||
description = "HCL language server package (terraform-ls)";
|
||||
enable = mkEnableOption "HCL LSP support" // {default = config.vim.lsp.enable;};
|
||||
servers = mkOption {
|
||||
description = "HCL LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -96,10 +92,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources = lib.optionalAttrs (! config.vim.languages.terraform.lsp.enable) {
|
||||
terraform-ls = servers.${cfg.lsp.server}.lspConfig;
|
||||
};
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
(mkIf cfg.format.enable {
|
||||
|
|
|
|||
|
|
@ -4,44 +4,37 @@
|
|||
lib,
|
||||
...
|
||||
}: let
|
||||
inherit (builtins) attrNames;
|
||||
inherit (builtins) attrNames head;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) enum either listOf package str;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.types) enum listOf;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.helm;
|
||||
yamlCfg = config.vim.languages.yaml;
|
||||
|
||||
helmCmd =
|
||||
if isList cfg.lsp.package
|
||||
then cfg.lsp.package
|
||||
else ["${cfg.lsp.package}/bin/helm_ls" "serve"];
|
||||
yamlCmd =
|
||||
if isList yamlCfg.lsp.package
|
||||
then builtins.elemAt yamlCfg.lsp.package 0
|
||||
else "${yamlCfg.lsp.package}/bin/yaml-language-server";
|
||||
|
||||
defaultServer = "helm-ls";
|
||||
defaultServers = ["helm-ls"];
|
||||
servers = {
|
||||
helm-ls = {
|
||||
package = pkgs.helm-ls;
|
||||
lspConfig = ''
|
||||
lspconfig.helm_ls.setup {
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = ${expToLua helmCmd},
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.helm-ls) "serve"];
|
||||
filetypes = ["helm" "yaml.helm-values"];
|
||||
root_markers = ["Chart.yaml"];
|
||||
capabilities = {
|
||||
didChangeWatchedFiles = {
|
||||
dynamicRegistration = true;
|
||||
};
|
||||
};
|
||||
settings = {
|
||||
['helm-ls'] = {
|
||||
helm-ls = {
|
||||
yamlls = {
|
||||
path = "${yamlCmd}"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
'';
|
||||
# TODO: Determine if this is a good enough solution
|
||||
path = (head yamlCfg.lsp.servers).cmd;
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
in {
|
||||
|
|
@ -55,17 +48,10 @@ in {
|
|||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Helm LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
server = mkOption {
|
||||
servers = mkOption {
|
||||
description = "Helm LSP server to use";
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
description = "Helm LSP server package";
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
|
@ -77,8 +63,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.helm-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
{
|
||||
|
|
|
|||
|
|
@ -7,12 +7,59 @@
|
|||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) either listOf package str;
|
||||
inherit (builtins) attrNames;
|
||||
inherit (lib.types) listOf enum;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
inherit (lib.nvim.dag) entryBefore;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
|
||||
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)";
|
||||
};
|
||||
};
|
||||
};
|
||||
in {
|
||||
options.vim.languages.java = {
|
||||
enable = mkEnableOption "Java language support";
|
||||
|
|
@ -23,30 +70,107 @@ in {
|
|||
};
|
||||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Java LSP support (java-language-server)" // {default = config.vim.lsp.enable;};
|
||||
package = mkOption {
|
||||
description = "java language server package, or the command to run as a list of strings";
|
||||
example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
|
||||
type = either package (listOf str);
|
||||
default = pkgs.jdt-language-server;
|
||||
enable = mkEnableOption "Java LSP support" // {default = config.vim.lsp.enable;};
|
||||
servers = mkOption {
|
||||
description = "Java LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
config = mkIf cfg.enable (mkMerge [
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.jdtls = ''
|
||||
lspconfig.jdtls.setup {
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${getExe cfg.lsp.package}", "-data", vim.fn.stdpath("cache").."/jdtls/workspace"}''
|
||||
},
|
||||
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;
|
||||
})
|
||||
|
||||
(mkIf cfg.treesitter.enable {
|
||||
|
|
|
|||
|
|
@ -4,35 +4,41 @@
|
|||
config,
|
||||
...
|
||||
}: let
|
||||
inherit (builtins) attrNames isList;
|
||||
inherit (builtins) attrNames;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.types) either listOf package str enum bool nullOr;
|
||||
inherit (lib.types) listOf enum;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.strings) optionalString;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
inherit (lib.nvim.dag) entryBefore;
|
||||
|
||||
defaultServer = "julials";
|
||||
defaultServers = ["jdtls"];
|
||||
servers = {
|
||||
julials = {
|
||||
package = pkgs.julia.withPackages ["LanguageServer"];
|
||||
internalFormatter = true;
|
||||
lspConfig = ''
|
||||
lspconfig.julials.setup {
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''
|
||||
jdtls = {
|
||||
enable = true;
|
||||
cmd =
|
||||
mkLuaInline
|
||||
/*
|
||||
lua
|
||||
*/
|
||||
''
|
||||
{
|
||||
"${optionalString (cfg.lsp.package != null) "${cfg.lsp.package}/bin/"}julia",
|
||||
"--startup-file=no",
|
||||
"--history-file=no",
|
||||
"--eval",
|
||||
'${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(
|
||||
|
|
@ -55,11 +61,24 @@
|
|||
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
|
||||
'';
|
||||
};
|
||||
};
|
||||
|
|
@ -76,11 +95,10 @@ in {
|
|||
};
|
||||
|
||||
lsp = {
|
||||
enable = mkOption {
|
||||
type = bool;
|
||||
default = config.vim.lsp.enable;
|
||||
enable = mkEnableOption "Java LSP support" // {default = config.vim.lsp.enable;};
|
||||
servers = mkOption {
|
||||
description = ''
|
||||
Whether to enable Julia LSP support.
|
||||
Julia LSP Server to Use
|
||||
|
||||
::: {.note}
|
||||
The entirety of Julia is bundled with nvf, if you enable this
|
||||
|
|
@ -92,21 +110,8 @@ in {
|
|||
Julia in your devshells.
|
||||
:::
|
||||
'';
|
||||
};
|
||||
|
||||
server = mkOption {
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
description = "Julia LSP server to use";
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
description = ''
|
||||
Julia LSP server package, `null` to use the Julia binary in {env}`PATH`, or
|
||||
the command to run as a list of strings.
|
||||
'';
|
||||
type = nullOr (either package (listOf str));
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
|
@ -119,8 +124,70 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.julia-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
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;
|
||||
})
|
||||
]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,16 +4,47 @@
|
|||
lib,
|
||||
...
|
||||
}: let
|
||||
inherit (lib.options) mkEnableOption mkOption literalExpression;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.types) either package listOf str;
|
||||
inherit (lib.meta) getExe' getExe;
|
||||
inherit (builtins) attrNames;
|
||||
inherit (lib.types) enum listOf;
|
||||
inherit (lib.nvim.types) mkGrammarOption diagnostics;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
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
|
||||
}
|
||||
)";
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
defaultDiagnosticsProvider = ["ktlint"];
|
||||
diagnosticsProviders = {
|
||||
ktlint = {
|
||||
|
|
@ -31,22 +62,10 @@ in {
|
|||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Kotlin LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
package = mkOption {
|
||||
description = "kotlin_language_server package with Kotlin runtime";
|
||||
type = either package (listOf str);
|
||||
example = literalExpression ''
|
||||
pkgs.symlinkJoin {
|
||||
name = "kotlin-language-server-wrapped";
|
||||
paths = [pkgs.kotlin-language-server];
|
||||
nativeBuildInputs = [pkgs.makeBinaryWrapper];
|
||||
postBuild = '''
|
||||
wrapProgram $out/bin/kotlin-language-server \
|
||||
--prefix PATH : ''${pkgs.kotlin}/bin
|
||||
''';
|
||||
};
|
||||
'';
|
||||
default = pkgs.kotlin-language-server;
|
||||
servers = mkOption {
|
||||
description = "Kotlin LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -78,23 +97,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.kotlin_language_server = ''
|
||||
lspconfig.kotlin_language_server.setup {
|
||||
capabilities = capabilities,
|
||||
root_dir = lspconfig.util.root_pattern("main.kt", ".git"),
|
||||
on_attach=default_on_attach,
|
||||
init_options = {
|
||||
-- speeds up the startup time for the LSP
|
||||
storagePath = vim.fn.stdpath('state') .. '/kotlin',
|
||||
},
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/kotlin-language-server"}''
|
||||
},
|
||||
}
|
||||
'';
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,13 +8,32 @@
|
|||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) bool either enum listOf package str;
|
||||
inherit (lib.types) bool enum listOf package;
|
||||
inherit (lib.nvim.types) diagnostics mkGrammarOption;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.nvim.dag) entryBefore;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
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"
|
||||
];
|
||||
};
|
||||
};
|
||||
|
||||
defaultFormat = "stylua";
|
||||
formats = {
|
||||
stylua = {
|
||||
|
|
@ -43,12 +62,11 @@ in {
|
|||
};
|
||||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Lua LSP support via LuaLS" // {default = config.vim.lsp.enable;};
|
||||
|
||||
package = mkOption {
|
||||
description = "LuaLS package, or the command to run as a list of strings";
|
||||
type = either package (listOf str);
|
||||
default = pkgs.lua-language-server;
|
||||
enable = mkEnableOption "Lua LSP support" // {default = config.vim.lsp.enable;};
|
||||
servers = mkOption {
|
||||
description = "Lua LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
|
||||
lazydev.enable = mkEnableOption "lazydev.nvim integration, useful for neovim plugin developers";
|
||||
|
|
@ -91,23 +109,17 @@ in {
|
|||
|
||||
(mkIf cfg.enable (mkMerge [
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.lua-lsp = ''
|
||||
lspconfig.lua_ls.setup {
|
||||
capabilities = capabilities;
|
||||
on_attach = default_on_attach;
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${getExe cfg.lsp.package}"}''
|
||||
};
|
||||
}
|
||||
'';
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
(mkIf cfg.lsp.lazydev.enable {
|
||||
vim.startPlugins = ["lazydev-nvim"];
|
||||
vim.pluginRC.lazydev = entryBefore ["lua-lsp"] ''
|
||||
vim.pluginRC.lazydev = entryBefore ["lsp-servers"] ''
|
||||
require("lazydev").setup({
|
||||
enabled = function(root_dir)
|
||||
return not vim.uv.fs_stat(root_dir .. "/.luarc.json")
|
||||
|
|
|
|||
|
|
@ -8,28 +8,20 @@
|
|||
inherit (lib.meta) getExe;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) bool enum either package listOf str nullOr;
|
||||
inherit (lib.nvim.lua) expToLua toLuaObject;
|
||||
inherit (lib.types) bool enum package listOf str nullOr;
|
||||
inherit (lib.nvim.lua) toLuaObject;
|
||||
inherit (lib.nvim.types) diagnostics mkGrammarOption mkPluginSetupOption;
|
||||
inherit (lib.nvim.dag) entryAnywhere;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.markdown;
|
||||
defaultServer = "marksman";
|
||||
defaultServers = ["marksman"];
|
||||
servers = {
|
||||
marksman = {
|
||||
package = pkgs.marksman;
|
||||
lspConfig = ''
|
||||
lspconfig.marksman.setup{
|
||||
capabilities = capabilities;
|
||||
on_attach = default_on_attach;
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/marksman", "server"}''
|
||||
},
|
||||
}
|
||||
'';
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.marksman) "server"];
|
||||
filetypes = ["markdown" "markdown.mdx"];
|
||||
root_markers = [".marksman.toml" ".git"];
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -67,19 +59,12 @@ in {
|
|||
};
|
||||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Enable Markdown LSP support" // {default = config.vim.lsp.enable;};
|
||||
enable = mkEnableOption "Markdown LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
server = mkOption {
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
servers = mkOption {
|
||||
description = "Markdown LSP server to use";
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
|
||||
description = "Markdown LSP server package, or the command to run as a list of strings";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -161,8 +146,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.markdown-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
(mkIf cfg.format.enable {
|
||||
|
|
|
|||
|
|
@ -6,30 +6,33 @@
|
|||
}: let
|
||||
inherit (builtins) attrNames;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.meta) getExe';
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) enum either listOf package str;
|
||||
inherit (lib.types) enum listOf package;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.nim;
|
||||
|
||||
defaultServer = "nimlsp";
|
||||
defaultServers = ["nimlsp"];
|
||||
servers = {
|
||||
nimlsp = {
|
||||
package = pkgs.nimlsp;
|
||||
lspConfig = ''
|
||||
lspconfig.nimls.setup{
|
||||
capabilities = capabilities;
|
||||
on_attach = default_on_attach;
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''
|
||||
{"${cfg.lsp.package}/bin/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
|
||||
'';
|
||||
};
|
||||
};
|
||||
|
|
@ -54,17 +57,11 @@ in {
|
|||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Nim LSP support" // {default = config.vim.lsp.enable;};
|
||||
server = mkOption {
|
||||
description = "Nim LSP server to use";
|
||||
type = str;
|
||||
default = defaultServer;
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
description = "Nim LSP server package, or the command to run as a list of strings";
|
||||
example = ''[lib.getExe pkgs.nimlsp]'';
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
servers = mkOption {
|
||||
description = "Nim LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -100,8 +97,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.nim-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
(mkIf cfg.format.enable {
|
||||
|
|
|
|||
|
|
@ -9,90 +9,43 @@
|
|||
inherit (lib.meta) getExe;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.strings) optionalString;
|
||||
inherit (lib.types) anything attrsOf enum either listOf nullOr package str;
|
||||
inherit (lib.types) enum package listOf;
|
||||
inherit (lib.nvim.types) mkGrammarOption diagnostics;
|
||||
inherit (lib.nvim.lua) expToLua toLuaObject;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.nix;
|
||||
|
||||
useFormat = "on_attach = default_on_attach";
|
||||
noFormat = "on_attach = attach_keymaps";
|
||||
formattingCmd = mkIf (cfg.format.enable && cfg.lsp.enable) {
|
||||
formatting = mkMerge [
|
||||
(mkIf (cfg.format.type == "alejandra") {
|
||||
command = ["${cfg.format.package}/bin/alejandra" "--quiet"];
|
||||
})
|
||||
(mkIf (cfg.format.type == "nixfmt") {
|
||||
command = ["${cfg.format.package}/bin/nixfmt"];
|
||||
})
|
||||
];
|
||||
};
|
||||
|
||||
defaultServer = "nil";
|
||||
packageToCmd = package: defaultCmd:
|
||||
if isList package
|
||||
then expToLua package
|
||||
else ''{"${package}/bin/${defaultCmd}"}'';
|
||||
defaultServers = ["nil"];
|
||||
servers = {
|
||||
nil = {
|
||||
package = pkgs.nil;
|
||||
internalFormatter = true;
|
||||
lspConfig = ''
|
||||
lspconfig.nil_ls.setup{
|
||||
capabilities = capabilities,
|
||||
${
|
||||
if cfg.format.enable
|
||||
then useFormat
|
||||
else noFormat
|
||||
},
|
||||
cmd = ${packageToCmd cfg.lsp.package "nil"},
|
||||
${optionalString cfg.format.enable ''
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.nil)];
|
||||
settings = {
|
||||
["nil"] = {
|
||||
${optionalString (cfg.format.type == "alejandra")
|
||||
''
|
||||
formatting = {
|
||||
command = {"${cfg.format.package}/bin/alejandra", "--quiet"},
|
||||
},
|
||||
''}
|
||||
${optionalString (cfg.format.type == "nixfmt")
|
||||
''
|
||||
formatting = {
|
||||
command = {"${cfg.format.package}/bin/nixfmt"},
|
||||
},
|
||||
''}
|
||||
},
|
||||
},
|
||||
''}
|
||||
}
|
||||
'';
|
||||
nil = formattingCmd;
|
||||
};
|
||||
filetypes = ["nix"];
|
||||
root_markers = [".git" "flake.nix"];
|
||||
};
|
||||
|
||||
nixd = {
|
||||
package = pkgs.nixd;
|
||||
internalFormatter = true;
|
||||
lspConfig = ''
|
||||
lspconfig.nixd.setup{
|
||||
capabilities = capabilities,
|
||||
${
|
||||
if cfg.format.enable
|
||||
then useFormat
|
||||
else noFormat
|
||||
},
|
||||
cmd = ${packageToCmd cfg.lsp.package "nixd"},
|
||||
${optionalString cfg.format.enable ''
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.nixd)];
|
||||
settings = {
|
||||
nixd = {
|
||||
${optionalString (cfg.format.type == "alejandra")
|
||||
''
|
||||
formatting = {
|
||||
command = {"${cfg.format.package}/bin/alejandra", "--quiet"},
|
||||
},
|
||||
''}
|
||||
${optionalString (cfg.format.type == "nixfmt")
|
||||
''
|
||||
formatting = {
|
||||
command = {"${cfg.format.package}/bin/nixfmt"},
|
||||
},
|
||||
''}
|
||||
options = ${toLuaObject cfg.lsp.options},
|
||||
},
|
||||
},
|
||||
''}
|
||||
}
|
||||
'';
|
||||
nixd = formattingCmd;
|
||||
};
|
||||
filetypes = ["nix"];
|
||||
root_markers = [".git" "flake.nix"];
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -144,23 +97,10 @@ in {
|
|||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Nix LSP support" // {default = config.vim.lsp.enable;};
|
||||
server = mkOption {
|
||||
servers = mkOption {
|
||||
description = "Nix LSP server to use";
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
description = "Nix LSP server package, or the command to run as a list of strings";
|
||||
example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
};
|
||||
|
||||
options = mkOption {
|
||||
type = nullOr (attrsOf anything);
|
||||
default = null;
|
||||
description = "Options to pass to nixd LSP server";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -201,13 +141,6 @@ in {
|
|||
${concatStringsSep ", " (attrNames formats)}
|
||||
'';
|
||||
}
|
||||
{
|
||||
assertion = cfg.lsp.server != "rnix";
|
||||
message = ''
|
||||
rnix-lsp has been archived upstream. Please use one of the following available language servers:
|
||||
${concatStringsSep ", " (attrNames servers)}
|
||||
'';
|
||||
}
|
||||
];
|
||||
}
|
||||
|
||||
|
|
@ -217,11 +150,15 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.nix-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
(mkIf (cfg.format.enable && (!cfg.lsp.enable || !servers.${cfg.lsp.server}.internalFormatter)) {
|
||||
(mkIf (cfg.format.enable && !cfg.lsp.enable) {
|
||||
vim.formatter.conform-nvim = {
|
||||
enable = true;
|
||||
setupOpts.formatters_by_ft.nix = [cfg.format.type];
|
||||
|
|
|
|||
|
|
@ -5,26 +5,29 @@
|
|||
...
|
||||
}: let
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.types) str either package listOf;
|
||||
inherit (lib.types) enum listOf;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (builtins) isList;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
inherit (builtins) attrNames;
|
||||
|
||||
defaultServer = "nushell";
|
||||
defaultServers = ["nushell"];
|
||||
servers = {
|
||||
nushell = {
|
||||
package = pkgs.nushell;
|
||||
lspConfig = ''
|
||||
lspconfig.nushell.setup{
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/nu", "--no-config-file", "--lsp"}''
|
||||
}
|
||||
}
|
||||
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
|
||||
'';
|
||||
};
|
||||
};
|
||||
|
|
@ -41,17 +44,11 @@ in {
|
|||
|
||||
lsp = {
|
||||
enable = mkEnableOption "Nu LSP support" // {default = config.vim.lsp.enable;};
|
||||
server = mkOption {
|
||||
type = str;
|
||||
default = defaultServer;
|
||||
description = "Nu LSP server to use";
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
example = ''[(lib.getExe pkgs.nushell) "--lsp"]'';
|
||||
description = "Nu LSP server package, or the command to run as a list of strings";
|
||||
servers = mkOption {
|
||||
description = "Nu LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
|
@ -63,8 +60,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.nu-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,27 +8,49 @@
|
|||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) either enum listOf package str;
|
||||
inherit (lib.types) enum listOf package;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.ocaml;
|
||||
|
||||
defaultServer = "ocaml-lsp";
|
||||
defaultServers = ["ocaml-lsp"];
|
||||
servers = {
|
||||
ocaml-lsp = {
|
||||
package = pkgs.ocamlPackages.ocaml-lsp;
|
||||
lspConfig = ''
|
||||
lspconfig.ocamllsp.setup {
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${getExe cfg.lsp.package}"}''
|
||||
};
|
||||
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
|
||||
'';
|
||||
};
|
||||
};
|
||||
|
|
@ -49,16 +71,12 @@ in {
|
|||
};
|
||||
|
||||
lsp = {
|
||||
enable = mkEnableOption "OCaml LSP support (ocaml-lsp)" // {default = config.vim.lsp.enable;};
|
||||
server = mkOption {
|
||||
description = "OCaml LSP server to user";
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
};
|
||||
package = mkOption {
|
||||
description = "OCaml language server package, or the command to run as a list of strings";
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
enable = mkEnableOption "OCaml LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
servers = mkOption {
|
||||
description = "OCaml LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -79,8 +97,12 @@ in {
|
|||
|
||||
config = mkIf cfg.enable (mkMerge [
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.ocaml-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
|
||||
(mkIf cfg.treesitter.enable {
|
||||
|
|
|
|||
|
|
@ -7,26 +7,28 @@
|
|||
inherit (builtins) attrNames;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) either listOf package str enum;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.types) listOf enum;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
defaultServer = "ols";
|
||||
defaultServers = ["ols"];
|
||||
servers = {
|
||||
ols = {
|
||||
package = pkgs.ols;
|
||||
lspConfig = ''
|
||||
lspconfig.ols.setup {
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else "{'${cfg.lsp.package}/bin/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'';
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -43,16 +45,10 @@ in {
|
|||
lsp = {
|
||||
enable = mkEnableOption "Odin LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
server = mkOption {
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
servers = mkOption {
|
||||
description = "Odin LSP server to use";
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
description = "Ols package, or the command to run as a list of strings";
|
||||
type = either package (listOf str);
|
||||
default = pkgs.ols;
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
|
@ -64,8 +60,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.odin-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,81 +8,60 @@
|
|||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) enum either listOf package str;
|
||||
inherit (lib.types) enum listOf;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
|
||||
cfg = config.vim.languages.php;
|
||||
|
||||
defaultServer = "phpactor";
|
||||
defaultServers = ["phpactor"];
|
||||
servers = {
|
||||
phpactor = {
|
||||
package = pkgs.phpactor;
|
||||
lspConfig = ''
|
||||
lspconfig.phpactor.setup{
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''
|
||||
{
|
||||
"${getExe cfg.lsp.package}",
|
||||
"language-server"
|
||||
},
|
||||
''
|
||||
}
|
||||
}
|
||||
'';
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.phpactor) "language-server"];
|
||||
filetypes = ["php"];
|
||||
root_markers = [".git" "composer.json" ".phpactor.json" ".phpactor.yml"];
|
||||
workspace_required = true;
|
||||
};
|
||||
|
||||
phan = {
|
||||
package = pkgs.php81Packages.phan;
|
||||
lspConfig = ''
|
||||
lspconfig.phan.setup{
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''
|
||||
{
|
||||
"${getExe cfg.lsp.package}",
|
||||
"-m",
|
||||
"json",
|
||||
"--no-color",
|
||||
"--no-progress-bar",
|
||||
"-x",
|
||||
"-u",
|
||||
"-S",
|
||||
"--language-server-on-stdin",
|
||||
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 = {
|
||||
package = pkgs.intelephense;
|
||||
lspConfig = ''
|
||||
lspconfig.intelephense.setup{
|
||||
capabilities = capabilities,
|
||||
on_attach = default_on_attach,
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''
|
||||
{
|
||||
"${getExe cfg.lsp.package}",
|
||||
"--stdio"
|
||||
},
|
||||
''
|
||||
}
|
||||
}
|
||||
'';
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.intelephense) "--stdio"];
|
||||
filetypes = ["php"];
|
||||
root_markers = ["composer.json" ".git"];
|
||||
};
|
||||
};
|
||||
in {
|
||||
|
|
@ -97,17 +76,10 @@ in {
|
|||
lsp = {
|
||||
enable = mkEnableOption "PHP LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
server = mkOption {
|
||||
servers = mkOption {
|
||||
description = "PHP LSP server to use";
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
description = "PHP LSP server package, or the command to run as a list of strings";
|
||||
example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
|
@ -117,11 +89,14 @@ in {
|
|||
vim.treesitter.enable = true;
|
||||
vim.treesitter.grammars = [cfg.treesitter.package];
|
||||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig = {
|
||||
enable = true;
|
||||
sources.php-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
};
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,57 +8,114 @@
|
|||
inherit (lib.options) mkEnableOption mkOption literalExpression;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) enum either listOf package str bool;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.types) enum listOf package str bool;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
inherit (lib.nvim.dag) entryBefore;
|
||||
|
||||
cfg = config.vim.languages.python;
|
||||
|
||||
defaultServer = "basedpyright";
|
||||
defaultServers = ["basedpyright"];
|
||||
servers = {
|
||||
pyright = {
|
||||
package = pkgs.pyright;
|
||||
lspConfig = ''
|
||||
lspconfig.pyright.setup{
|
||||
capabilities = capabilities;
|
||||
on_attach = default_on_attach;
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/pyright-langserver", "--stdio"}''
|
||||
}
|
||||
}
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.pyright) "--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()
|
||||
client:exec_cmd({
|
||||
command = 'pyright.organizeimports',
|
||||
arguments = { vim.uri_from_bufnr(bufnr) },
|
||||
})
|
||||
end, {
|
||||
desc = 'Organize Imports',
|
||||
})
|
||||
vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightSetPythonPath', function(opts)
|
||||
set_python_path('pyright', opts.args)
|
||||
end, {
|
||||
desc = 'Reconfigure pyright with the provided python path',
|
||||
nargs = 1,
|
||||
complete = 'file',
|
||||
})
|
||||
end
|
||||
'';
|
||||
};
|
||||
|
||||
basedpyright = {
|
||||
package = pkgs.basedpyright;
|
||||
lspConfig = ''
|
||||
lspconfig.basedpyright.setup{
|
||||
capabilities = capabilities;
|
||||
on_attach = default_on_attach;
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/basedpyright-langserver", "--stdio"}''
|
||||
}
|
||||
}
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.basedpyright) "--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()
|
||||
client:exec_cmd({
|
||||
command = 'basedpyright.organizeimports',
|
||||
arguments = { vim.uri_from_bufnr(bufnr) },
|
||||
})
|
||||
end, {
|
||||
desc = 'Organize Imports',
|
||||
})
|
||||
|
||||
vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightSetPythonPath', function(opts)
|
||||
set_python_path('basedpyright', opts.args)
|
||||
end, {
|
||||
desc = 'Reconfigure basedpyright with the provided python path',
|
||||
nargs = 1,
|
||||
complete = 'file',
|
||||
})
|
||||
end
|
||||
'';
|
||||
};
|
||||
|
||||
python-lsp-server = {
|
||||
package = pkgs.python3Packages.python-lsp-server;
|
||||
lspConfig = ''
|
||||
lspconfig.pylsp.setup{
|
||||
capabilities = capabilities;
|
||||
on_attach = default_on_attach;
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/pylsp"}''
|
||||
}
|
||||
}
|
||||
'';
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.python3Packages.python-lsp-server)];
|
||||
filetypes = ["python"];
|
||||
root_markers = [
|
||||
"pyproject.toml"
|
||||
"setup.py"
|
||||
"setup.cfg"
|
||||
"requirements.txt"
|
||||
"Pipfile"
|
||||
".git"
|
||||
];
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -171,17 +228,10 @@ in {
|
|||
lsp = {
|
||||
enable = mkEnableOption "Python LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
server = mkOption {
|
||||
servers = mkOption {
|
||||
description = "Python LSP server to use";
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
description = "python LSP server package, or the command to run as a list of strings";
|
||||
example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -234,8 +284,34 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.python-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.luaConfigRC.python-util =
|
||||
entryBefore ["lsp-servers"]
|
||||
/*
|
||||
lua
|
||||
*/
|
||||
''
|
||||
local function set_python_path(server_name, path)
|
||||
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;
|
||||
})
|
||||
|
||||
(mkIf cfg.format.enable {
|
||||
|
|
|
|||
|
|
@ -7,10 +7,11 @@
|
|||
inherit (builtins) attrNames;
|
||||
inherit (lib.options) mkEnableOption mkOption literalExpression;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) enum either listOf package str;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.types) enum listOf package;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
inherit (lib.generators) mkLuaInline;
|
||||
|
||||
cfg = config.vim.languages.r;
|
||||
|
||||
|
|
@ -50,22 +51,16 @@
|
|||
};
|
||||
};
|
||||
|
||||
defaultServer = "r_language_server";
|
||||
defaultServers = ["r_language_server"];
|
||||
servers = {
|
||||
r_language_server = {
|
||||
package = pkgs.writeShellScriptBin "r_lsp" ''
|
||||
${r-with-languageserver}/bin/R --slave -e "languageserver::run()"
|
||||
'';
|
||||
lspConfig = ''
|
||||
lspconfig.r_language_server.setup{
|
||||
capabilities = capabilities;
|
||||
on_attach = default_on_attach;
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${lib.getExe cfg.lsp.package}"}''
|
||||
}
|
||||
}
|
||||
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
|
||||
'';
|
||||
};
|
||||
};
|
||||
|
|
@ -81,17 +76,10 @@ in {
|
|||
lsp = {
|
||||
enable = mkEnableOption "R LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
server = mkOption {
|
||||
servers = mkOption {
|
||||
description = "R LSP server to use";
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
description = "R LSP server package, or the command to run as a list of strings";
|
||||
example = literalExpression "[ (lib.getExe pkgs.jdt-language-server) \"-data\" \"~/.cache/jdtls/workspace\" ]";
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -127,8 +115,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.r-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,10 +7,10 @@
|
|||
inherit (builtins) attrNames;
|
||||
inherit (lib.options) mkEnableOption mkOption;
|
||||
inherit (lib.modules) mkIf mkMerge;
|
||||
inherit (lib.lists) isList;
|
||||
inherit (lib.types) enum either listOf package str;
|
||||
inherit (lib.meta) getExe;
|
||||
inherit (lib.types) enum listOf;
|
||||
inherit (lib.nvim.types) mkGrammarOption;
|
||||
inherit (lib.nvim.lua) expToLua;
|
||||
inherit (lib.nvim.attrsets) mapListToAttrs;
|
||||
|
||||
cfg = config.vim.languages.yaml;
|
||||
|
||||
|
|
@ -25,23 +25,22 @@
|
|||
end''
|
||||
else "on_attach = default_on_attach";
|
||||
|
||||
defaultServer = "yaml-language-server";
|
||||
defaultServers = ["yaml-language-server"];
|
||||
servers = {
|
||||
yaml-language-server = {
|
||||
package = pkgs.yaml-language-server;
|
||||
lspConfig = ''
|
||||
|
||||
|
||||
lspconfig.yamlls.setup {
|
||||
capabilities = capabilities,
|
||||
${onAttach},
|
||||
cmd = ${
|
||||
if isList cfg.lsp.package
|
||||
then expToLua cfg.lsp.package
|
||||
else ''{"${cfg.lsp.package}/bin/yaml-language-server", "--stdio"}''
|
||||
},
|
||||
}
|
||||
'';
|
||||
enable = true;
|
||||
cmd = [(getExe pkgs.yaml-language-server) "--stdio"];
|
||||
filetypes = ["yaml" "yaml.docker-compose" "yaml.gitlab" "yaml.helm-values"];
|
||||
root_markers = [".git"];
|
||||
on_attach = onAttach;
|
||||
# -- https://github.com/redhat-developer/vscode-redhat-telemetry#how-to-disable-telemetry-reporting
|
||||
settings = {
|
||||
redhat = {
|
||||
telemetry = {
|
||||
enabled = false;
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
};
|
||||
in {
|
||||
|
|
@ -55,18 +54,11 @@ in {
|
|||
};
|
||||
|
||||
lsp = {
|
||||
enable = mkEnableOption "YAML LSP support" // {default = config.vim.lsp.enable;};
|
||||
|
||||
server = mkOption {
|
||||
type = enum (attrNames servers);
|
||||
default = defaultServer;
|
||||
description = "YAML LSP server to use";
|
||||
};
|
||||
|
||||
package = mkOption {
|
||||
type = either package (listOf str);
|
||||
default = servers.${cfg.lsp.server}.package;
|
||||
description = "YAML LSP server package";
|
||||
enable = mkEnableOption "Yaml LSP support" // {default = config.vim.lsp.enable;};
|
||||
servers = mkOption {
|
||||
description = "Yaml LSP server to use";
|
||||
type = listOf (enum (attrNames servers));
|
||||
default = defaultServers;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
|
@ -78,8 +70,12 @@ in {
|
|||
})
|
||||
|
||||
(mkIf cfg.lsp.enable {
|
||||
vim.lsp.lspconfig.enable = true;
|
||||
vim.lsp.lspconfig.sources.yaml-lsp = servers.${cfg.lsp.server}.lspConfig;
|
||||
vim.lsp.servers =
|
||||
mapListToAttrs (n: {
|
||||
name = n;
|
||||
value = servers.${n};
|
||||
})
|
||||
cfg.lsp.servers;
|
||||
})
|
||||
]);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue