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

Merge branch 'main' into telescope-ext

Browse source
This commit is contained in:
raf 2025-04-28 05:45:55 +00:00 • committed by GitHub
commit 49b748072b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
90 changed files with 1935 additions and 1108 deletions
Download patch file Download diff file Expand all files Collapse all files

11
modules/plugins/assistant/chatgpt/config.nix
View file

@ -30,7 +30,16 @@
in {
config = mkIf cfg.enable {
vim = {
startPlugins = ["chatgpt-nvim"];
startPlugins = [
"chatgpt-nvim"
# Dependencies
"nui-nvim"
"plenary-nvim"
];
# ChatGPT.nvim explicitly depends on Telescope.
telescope.enable = true;
pluginRC.chagpt = entryAnywhere ''
require("chatgpt").setup(${toLuaObject cfg.setupOpts})

37
modules/plugins/assistant/codecompanion/codecompanion-nvim.nix
View file

@ -9,7 +9,14 @@ in {
setupOpts = mkPluginSetupOption "codecompanion-nvim" {
opts = {
send_code = mkEnableOption "code from being sent to the LLM.";
send_code =
mkEnableOption ""
// {
default = true;
description = ''
Whether to enable code being sent to the LLM.
'';
};
log_level = mkOption {
type = enum ["DEBUG" "INFO" "ERROR" "TRACE"];
@ -30,7 +37,10 @@ in {
mkEnableOption ""
// {
default = true;
description = "a diff view to see the changes made by the LLM.";
description = ''
Whether to enable a diff view
to see the changes made by the LLM.
'';
};
close_chat_at = mkOption {
@ -64,7 +74,12 @@ in {
};
chat = {
auto_scroll = mkEnableOption "automatic page scrolling.";
auto_scroll =
mkEnableOption ""
// {
default = true;
description = "Whether to enable automatic page scrolling.";
};
show_settings = mkEnableOption ''
LLM settings to appear at the top of the chat buffer.
@ -85,14 +100,18 @@ in {
mkEnableOption ""
// {
default = true;
description = "references in the chat buffer.";
description = ''
Whether to enable references in the chat buffer.
'';
};
show_token_count =
mkEnableOption ""
// {
default = true;
description = "the token count for each response.";
description = ''
Whether to enable the token count for each response.
'';
};
intro_message = mkOption {
@ -155,7 +174,10 @@ in {
mkEnableOption ""
// {
default = true;
description = "showing default actions in the action palette.";
description = ''
Whether to enable showing default
actions in the action palette.
'';
};
show_default_prompt_library =
@ -163,7 +185,8 @@ in {
// {
default = true;
description = ''
showing default prompt library in the action palette.
Whether to enable showing default
prompt library in the action palette.
'';
};
};

5
modules/plugins/assistant/codecompanion/config.nix
View file

@ -22,6 +22,11 @@ in {
};
treesitter.enable = true;
autocomplete.nvim-cmp = {
sources = {codecompanion-nvim = "[codecompanion]";};
sourcePlugins = ["codecompanion-nvim"];
};
};
};
}

13
modules/plugins/completion/blink-cmp/blink-cmp.nix
View file

@ -43,19 +43,6 @@ in {
default = {};
description = "Settings for completion providers.";
};
transform_items = mkOption {
type = nullOr luaInline;
default = mkLuaInline "function(_, items) return items end";
defaultText = ''
Our default does nothing. If you want blink.cmp's default, which
lowers the score for snippets, set this option to null.
'';
description = ''
Function to use when transforming the items before they're returned
for all providers.
'';
};
};
cmdline = {

50
modules/plugins/diagnostics/nvim-lint/config.nix
View file

@ -3,18 +3,50 @@
lib,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.lua) toLuaObject;
cfg = config.vim.diagnostics.nvim-lint;
in {
config = mkIf cfg.enable {
vim = {
startPlugins = ["nvim-lint"];
pluginRC.nvim-lint = entryAnywhere ''
require("lint").linters_by_ft = ${toLuaObject cfg.linters_by_ft}
'';
};
};
config = mkMerge [
(mkIf cfg.enable {
vim = {
startPlugins = ["nvim-lint"];
pluginRC.nvim-lint = entryAnywhere ''
require("lint").linters_by_ft = ${toLuaObject cfg.linters_by_ft}
local linters = require("lint").linters
local nvf_linters = ${toLuaObject cfg.linters}
for linter, config in pairs(nvf_linters) do
if linters[linter] == nil then
linters[linter] = config
else
for key, val in pairs(config) do
linters[linter][key] = val
end
end
end
nvf_lint = ${toLuaObject cfg.lint_function}
'';
};
})
(mkIf (cfg.enable && cfg.lint_after_save) {
vim = {
augroups = [{name = "nvf_nvim_lint";}];
autocmds = [
{
event = ["BufWritePost"];
callback = mkLuaInline ''
function(args)
nvf_lint(args.buf)
end
'';
}
];
};
})
];
}

166
modules/plugins/diagnostics/nvim-lint/nvim-lint.nix
View file

@ -1,6 +1,94 @@
{lib, ...}: let
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.types) attrsOf listOf str;
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.types) nullOr attrsOf listOf str either submodule bool enum;
inherit (lib.nvim.types) luaInline;
inherit (lib.generators) mkLuaInline;
linterType = submodule {
options = {
name = mkOption {
type = nullOr str;
default = null;
description = "Name of the linter";
};
cmd = mkOption {
type = nullOr str;
default = null;
description = "Command of the linter";
};
args = mkOption {
type = nullOr (listOf (either str luaInline));
default = null;
description = "Arguments to pass";
};
stdin = mkOption {
type = nullOr bool;
default = null;
description = "Send content via stdin.";
};
append_fname = mkOption {
type = nullOr bool;
default = null;
description = ''
Automatically add the current file name to the commands arguments. Only
has an effect if stdin is false
'';
};
stream = mkOption {
type = nullOr (enum ["stdout" "stderr" "both"]);
default = null;
description = "Result stream";
};
ignore_exitcode = mkOption {
type = nullOr bool;
default = null;
description = ''
Declares if exit code != 1 should be ignored or result in a warning.
'';
};
env = mkOption {
type = nullOr (attrsOf str);
default = null;
description = "Environment variables to use";
};
cwd = mkOption {
type = nullOr str;
default = null;
description = "Working directory of the linter";
};
parser = mkOption {
type = nullOr luaInline;
default = null;
description = "Parser function";
};
required_files = mkOption {
type = nullOr (listOf str);
default = null;
example = ["eslint.config.js"];
description = ''
Required files to lint. These files must exist relative to the cwd
of the linter or else this linter will be skipped
::: {.note}
This option is an nvf extension that only takes effect if you
use the `nvf_lint()` lua function.
See {option}`vim.diagnostics.nvim-lint.lint_function`.
:::
'';
};
};
};
in {
options.vim.diagnostics.nvim-lint = {
enable = mkEnableOption "asynchronous linter plugin for Neovim [nvim-lint]";
@ -21,5 +109,79 @@ in {
accept.
'';
};
linters = mkOption {
type = attrsOf linterType;
default = {};
example = ''
{
phpcs = {
args = ["-q" "--report-json" "-"];
# this will replace the builtin's env table if it exists
env = {
ENV_VAR = "something";
};
};
}
'';
description = ''
Linter configurations. Builtin linters will be updated and not
replaced, but note that this is not a deep extend operation, i.e. if
you define an `env` option, it will replace the entire `env` table
provided by the builtin (if it exists).
'';
};
lint_after_save = mkEnableOption "autocmd to lint after each save" // {default = true;};
lint_function = mkOption {
type = luaInline;
default = mkLuaInline ''
function(buf)
local ft = vim.api.nvim_get_option_value("filetype", { buf = buf })
local linters = require("lint").linters
local linters_from_ft = require("lint").linters_by_ft[ft]
-- if no linter is configured for this filetype, stops linting
if linters_from_ft == nil then return end
for _, name in ipairs(linters_from_ft) do
local linter = linters[name]
assert(linter, 'Linter with name `' .. name .. '` not available')
if type(linter) == "function" then
linter = linter()
end
-- for require("lint").lint() to work, linter.name must be set
linter.name = linter.name or name
local cwd = linter.required_files
-- if no configuration files are configured, lint
if cwd == nil then
require("lint").lint(linter)
else
-- if configuration files are configured and present in the project, lint
for _, fn in ipairs(cwd) do
local path = vim.fs.joinpath(linter.cwd or vim.fn.getcwd(), fn);
if vim.uv.fs_stat(path) then
require("lint").lint(linter)
break
end
end
end
end
end
'';
example = literalExpression ''
mkLuaInline '''
function(buf)
require("lint").try_lint()
end
'''
'';
description = "Define the global function nvf_lint which is used by nvf to lint.";
};
};
}

6
modules/plugins/formatter/conform-nvim/conform-nvim.nix
View file

@ -4,7 +4,7 @@
...
}: let
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.types) attrs enum;
inherit (lib.types) attrs enum nullOr;
inherit (lib.nvim.types) mkPluginSetupOption;
inherit (lib.nvim.lua) mkLuaInline;
in {
@ -31,7 +31,7 @@ in {
};
format_on_save = mkOption {
type = attrs;
type = nullOr attrs;
default = {
lsp_format = "fallback";
timeout_ms = 500;
@ -43,7 +43,7 @@ in {
};
format_after_save = mkOption {
type = attrs;
type = nullOr attrs;
default = {lsp_format = "fallback";};
description = ''
Table that will be passed to `conform.format()`. If this

2
modules/plugins/git/default.nix
View file

@ -5,6 +5,7 @@ in {
./gitsigns
./vim-fugitive
./git-conflict
./gitlinker-nvim
];
options.vim.git = {
@ -15,6 +16,7 @@ in {
* gitsigns
* vim-fugitive
* git-conflict
* gitlinker-nvim
'';
};
}

22
modules/plugins/git/gitlinker-nvim/config.nix Normal file
View file

@ -0,0 +1,22 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
cfg = config.vim.git.gitlinker-nvim;
in {
config = mkIf cfg.enable {
vim = {
lazy.plugins = {
"gitlinker-nvim" = {
package = "gitlinker-nvim";
setupModule = "gitlinker";
inherit (cfg) setupOpts;
cmd = ["GitLink"];
};
};
};
};
}

6
modules/plugins/git/gitlinker-nvim/default.nix Normal file
View file

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

13
modules/plugins/git/gitlinker-nvim/gitlinker-nvim.nix Normal file
View file

@ -0,0 +1,13 @@
{
config,
lib,
...
}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {
options.vim.git.gitlinker-nvim = {
enable = mkEnableOption "gitlinker-nvim" // {default = config.vim.git.enable;};
setupOpts = mkPluginSetupOption "gitlinker-nvim" {};
};
}

15
modules/plugins/git/gitsigns/config.nix
View file

@ -5,6 +5,7 @@
}: let
inherit (builtins) toJSON;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.binds) addDescriptionsToMappings mkSetExprBinding mkSetLuaBinding pushDownDefault;
inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.lua) toLuaObject;
@ -32,6 +33,7 @@ in {
return '<Ignore>'
end
'')
(mkSetExprBinding gsMappings.previousHunk ''
function()
if vim.wo.diff then return ${toJSON gsMappings.previousHunk.value} end
@ -77,13 +79,12 @@ in {
}
(mkIf cfg.codeActions.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.gitsigns-ca = ''
table.insert(
ls_sources,
null_ls.builtins.code_actions.gitsigns
)
'';
vim.lsp.null-ls = {
enable = true;
setupOpts.sources.gitsigns-ca = mkLuaInline ''
require("null-ls").builtins.code_actions.gitsigns
'';
};
})
]);
}

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

@ -10,8 +10,8 @@
inherit (lib.lists) isList;
inherit (lib.meta) getExe;
inherit (lib.types) enum either listOf package str;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.languages) diagnosticsToLua;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
cfg = config.vim.languages.astro;
@ -22,7 +22,7 @@
package = pkgs.astro-language-server;
lspConfig = ''
lspconfig.astro.setup {
capabilities = capabilities;
capabilities = capabilities,
on_attach = attach_keymaps,
cmd = ${
if isList cfg.lsp.package
@ -39,52 +39,35 @@
formats = {
prettier = {
package = pkgs.nodePackages.prettier;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.prettier.with({
command = "${cfg.format.package}/bin/prettier",
})
)
'';
};
prettierd = {
package = pkgs.prettierd;
};
biome = {
package = pkgs.biome;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.biome.with({
command = "${cfg.format.package}/bin/biome",
})
)
'';
};
};
# TODO: specify packages
defaultDiagnosticsProvider = ["eslint_d"];
diagnosticsProviders = {
eslint_d = {
package = pkgs.eslint_d;
nullConfig = pkg: ''
table.insert(
ls_sources,
null_ls.builtins.diagnostics.eslint_d.with({
command = "${getExe pkg}",
condition = function(utils)
return utils.root_has_file({
"eslint.config.js",
"eslint.config.mjs",
".eslintrc",
".eslintrc.json",
".eslintrc.js",
".eslintrc.yml",
})
end,
})
)
'';
eslint_d = let
pkg = pkgs.eslint_d;
in {
package = pkg;
config = {
cmd = getExe pkg;
required_files = [
"eslint.config.js"
"eslint.config.mjs"
".eslintrc"
".eslintrc.json"
".eslintrc.js"
".eslintrc.yml"
];
};
};
};
in {
@ -101,16 +84,16 @@ in {
enable = mkEnableOption "Astro LSP support" // {default = config.vim.languages.enableLSP;};
server = mkOption {
description = "Astro LSP server to use";
type = enum (attrNames servers);
default = defaultServer;
description = "Astro LSP server to use";
};
package = mkOption {
description = "Astro LSP server package, or the command to run as a list of strings";
example = ''[lib.getExe pkgs.astro-language-server "--minify" "--stdio"]'';
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";
};
};
@ -153,16 +136,22 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.astro-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.astro = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources = diagnosticsToLua {
lang = "astro";
config = cfg.extraDiagnostics.types;
inherit diagnosticsProviders;
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.astro = cfg.extraDiagnostics.types;
linters =
mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
cfg.extraDiagnostics.types);
};
})
]);

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

@ -6,10 +6,10 @@
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.lists) isList;
inherit (lib.types) enum either package listOf str bool;
inherit (lib.nvim.languages) diagnosticsToLua;
inherit (lib.nvim.types) diagnostics mkGrammarOption;
inherit (lib.nvim.lua) expToLua;
@ -37,14 +37,6 @@
formats = {
shfmt = {
package = pkgs.shfmt;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.shfmt.with({
command = "${pkgs.shfmt}/bin/shfmt",
})
)
'';
};
};
@ -52,15 +44,6 @@
diagnosticsProviders = {
shellcheck = {
package = pkgs.shellcheck;
nullConfig = pkg: ''
table.insert(
ls_sources,
null_ls.builtins.diagnostics.shellcheck.with({
command = "${pkg}/bin/shellcheck",
diagnostics_format = "#{m} [#{c}]"
})
)
'';
};
};
in {
@ -130,16 +113,23 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.bash-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.sh = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources = diagnosticsToLua {
lang = "bash";
config = cfg.extraDiagnostics.types;
inherit diagnosticsProviders;
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.sh = cfg.extraDiagnostics.types;
linters = mkMerge (map (name: {
${name}.cmd = getExe diagnosticsProviders.${name}.package;
})
cfg.extraDiagnostics.types);
};
})
]);

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

@ -6,6 +6,7 @@
}: 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;
@ -42,14 +43,6 @@
formats = {
prettier = {
package = pkgs.nodePackages.prettier;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.prettier.with({
command = "${cfg.format.package}/bin/prettier",
})
)
'';
};
prettierd = {
@ -132,8 +125,13 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.css-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.css = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
]);
}

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

@ -13,7 +13,7 @@
inherit (lib.strings) optionalString;
inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.dag) entryAfter;
cfg = config.vim.languages.dart;
ftcfg = cfg.flutter-tools;
@ -81,16 +81,25 @@ in {
description = "Enable flutter-tools for flutter support";
};
flutterPackage = mkOption {
type = nullOr package;
default = pkgs.flutter;
description = "Flutter package, or null to detect the flutter path at runtime instead.";
};
enableNoResolvePatch = mkOption {
type = bool;
default = true;
default = false;
description = ''
Whether to patch flutter-tools so that it doesn't resolve
symlinks when detecting flutter path.
This is required if you want to use a flutter package built with nix.
If you are using a flutter SDK installed from a different source
and encounter the error "`dart` missing from PATH", disable this option.
::: {.note}
This is required if `flutterPackage` is set to null and the flutter
package in your `PATH` was built with Nix. If you are using a flutter
SDK installed from a different source and encounter the error "`dart`
missing from `PATH`", leave this option disabled.
:::
'';
};
@ -122,25 +131,32 @@ in {
};
};
config = mkIf cfg.enable (mkMerge [
config.vim = mkIf cfg.enable (mkMerge [
(mkIf cfg.treesitter.enable {
vim.treesitter.enable = true;
vim.treesitter.grammars = [cfg.treesitter.package];
treesitter.enable = true;
treesitter.grammars = [cfg.treesitter.package];
})
(mkIf cfg.lsp.enable {
vim.lsp.lspconfig.enable = true;
vim.lsp.lspconfig.sources.dart-lsp = servers.${cfg.lsp.server}.lspConfig;
lsp.lspconfig.enable = true;
lsp.lspconfig.sources.dart-lsp = servers.${cfg.lsp.server}.lspConfig;
})
(mkIf ftcfg.enable {
vim.startPlugins =
if ftcfg.enableNoResolvePatch
then ["flutter-tools-patched"]
else ["flutter-tools-nvim"];
lsp.enable = true;
vim.pluginRC.flutter-tools = entryAnywhere ''
startPlugins = [
(
if ftcfg.enableNoResolvePatch
then "flutter-tools-patched"
else "flutter-tools-nvim"
)
"plenary-nvim"
];
pluginRC.flutter-tools = entryAfter ["lsp-setup"] ''
require('flutter-tools').setup {
${optionalString (ftcfg.flutterPackage != null) "flutter_path = \"${ftcfg.flutterPackage}/bin/flutter\","}
lsp = {
color = { -- show the derived colours for dart variables
enabled = ${boolToString ftcfg.color.enable}, -- whether or not to highlight color variables at all, only supported on flutter >= 2.10
@ -152,7 +168,6 @@ in {
capabilities = capabilities,
on_attach = default_on_attach;
flags = lsp_flags,
},
${optionalString cfg.dap.enable ''
debugger = {

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

@ -10,6 +10,7 @@ in {
./clang.nix
./css.nix
./elixir.nix
./fsharp.nix
./gleam.nix
./go.nix
./hcl.nix

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

@ -38,14 +38,9 @@
formats = {
mix = {
package = pkgs.elixir;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.mix.with({
command = "${cfg.format.package}/bin/mix",
})
)
'';
config = {
command = "${cfg.format.package}/bin/mix";
};
};
};
in {
@ -107,8 +102,12 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.elixir-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.elixir = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} =
formats.${cfg.format.type}.config;
};
})
(mkIf cfg.elixir-tools.enable {

107
modules/plugins/languages/fsharp.nix Normal file
View file

@ -0,0 +1,107 @@
{
lib,
pkgs,
config,
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) either listOf package str enum;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.lists) isList;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.lua) expToLua;
defaultServer = "fsautocomplete";
servers = {
fsautocomplete = {
package = pkgs.fsautocomplete;
internalFormatter = false;
lspConfig = ''
lspconfig.fsautocomplete.setup {
capabilities = capabilities;
on_attach = default_on_attach;
cmd = ${
if isList cfg.lsp.package
then expToLua cfg.lsp.package
else "{'${cfg.lsp.package}/bin/fsautocomplete'}"
},
}
'';
};
};
defaultFormat = "fantomas";
formats = {
fantomas = {
package = pkgs.fantomas;
};
};
cfg = config.vim.languages.fsharp;
in {
options = {
vim.languages.fsharp = {
enable = mkEnableOption "F# language support";
treesitter = {
enable = mkEnableOption "F# treesitter" // {default = config.vim.languages.enableTreesitter;};
package = mkGrammarOption pkgs "fsharp";
};
lsp = {
enable = mkEnableOption "F# LSP support" // {default = config.vim.languages.enableLSP;};
server = mkOption {
type = enum (attrNames servers);
default = defaultServer;
description = "F# LSP server to use";
};
package = mkOption {
type = either package (listOf str);
default = servers.${cfg.lsp.server}.package;
example = ''[lib.getExe pkgs.fsautocomplete "--state-directory" "~/.cache/fsautocomplete"]'';
description = "F# LSP server package, or the command to run as a list of strings";
};
};
format = {
enable = mkEnableOption "F# formatting" // {default = config.vim.languages.enableFormat;};
type = mkOption {
type = enum (attrNames formats);
default = defaultFormat;
description = "F# formatter to use";
};
package = mkOption {
type = package;
default = formats.${cfg.format.type}.package;
description = "F# formatter package";
};
};
};
};
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.treesitter.enable {
vim.treesitter.enable = true;
vim.treesitter.grammars = [cfg.treesitter.package];
})
(mkIf cfg.lsp.enable {
vim.lsp.lspconfig.enable = true;
vim.lsp.lspconfig.sources.fsharp-lsp = servers.${cfg.lsp.server}.lspConfig;
})
(mkIf cfg.format.enable {
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.fsharp = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
]);
}

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

@ -5,7 +5,7 @@
...
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.options) mkEnableOption mkOption literalMD;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib.lists) isList;
@ -38,36 +38,15 @@
formats = {
gofmt = {
package = pkgs.go;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.gofmt.with({
command = "${cfg.format.package}/bin/gofmt",
})
)
'';
config.command = "${cfg.format.package}/bin/gofmt";
};
gofumpt = {
package = pkgs.gofumpt;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.gofumpt.with({
command = "${cfg.format.package}/bin/gofumpt",
})
)
'';
config.command = getExe cfg.format.package;
};
golines = {
package = pkgs.golines;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.golines.with({
command = "${cfg.format.package}/bin/golines",
})
)
'';
config.command = "${cfg.format.package}/bin/golines";
};
};
@ -105,7 +84,14 @@ in {
};
format = {
enable = mkEnableOption "Go formatting" // {default = config.vim.languages.enableFormat;};
enable =
mkEnableOption "Go formatting"
// {
default = !cfg.lsp.enable && config.vim.languages.enableFormat;
defaultText = literalMD ''
disabled if Go LSP is enabled, otherwise follows {option}`vim.languages.enableFormat`
'';
};
type = mkOption {
description = "Go formatter to use";
@ -153,8 +139,11 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.go-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.go = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
};
})
(mkIf cfg.dap.enable {

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

@ -6,6 +6,7 @@
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) package bool enum;
inherit (lib.nvim.types) mkGrammarOption;
@ -30,14 +31,6 @@
formats = {
hclfmt = {
package = pkgs.hclfmt;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.hclfmt.with({
command = "${lib.getExe cfg.format.package}",
})
)
'';
};
};
in {
@ -110,8 +103,13 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.hcl-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.hcl = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
]);
}

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

@ -7,7 +7,6 @@
inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe;
inherit (lib.nvim.languages) diagnosticsToLua;
inherit (lib.types) either package listOf str;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.lists) isList;
@ -19,14 +18,6 @@
diagnosticsProviders = {
ktlint = {
package = pkgs.ktlint;
nullConfig = pkg: ''
table.insert(
ls_sources,
null_ls.builtins.diagnostics.ktlint.with({
command = "${getExe pkg}",
})
)
'';
};
};
in {
@ -76,11 +67,13 @@ in {
})
(mkIf cfg.extraDiagnostics.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources = diagnosticsToLua {
lang = "kotlin";
config = cfg.extraDiagnostics.types;
inherit diagnosticsProviders;
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.kotlin = cfg.extraDiagnostics.types;
linters = mkMerge (map (name: {
${name}.cmd = getExe diagnosticsProviders.${name}.package;
})
cfg.extraDiagnostics.types);
};
})

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

@ -4,16 +4,30 @@
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.nvim.types) mkGrammarOption;
inherit (lib.types) bool either enum listOf package str;
inherit (lib.nvim.types) diagnostics mkGrammarOption;
inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.dag) entryBefore;
cfg = config.vim.languages.lua;
defaultFormat = "stylua";
formats = {
stylua = {
package = pkgs.stylua;
};
};
defaultDiagnosticsProvider = ["luacheck"];
diagnosticsProviders = {
luacheck = {
package = pkgs.luajitPackages.luacheck;
};
};
in {
imports = [
(lib.mkRemovedOptionModule ["vim" "languages" "lua" "lsp" "neodev"] ''
@ -39,6 +53,34 @@ in {
lazydev.enable = mkEnableOption "lazydev.nvim integration, useful for neovim plugin developers";
};
format = {
enable = mkOption {
type = bool;
default = config.vim.languages.enableFormat;
description = "Enable Lua formatting";
};
type = mkOption {
type = enum (attrNames formats);
default = defaultFormat;
description = "Lua formatter to use";
};
package = mkOption {
type = package;
default = formats.${cfg.format.type}.package;
description = "Lua formatter package";
};
};
extraDiagnostics = {
enable = mkEnableOption "extra Lua diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
types = diagnostics {
langDesc = "Lua";
inherit diagnosticsProviders;
inherit defaultDiagnosticsProvider;
};
};
};
config = mkMerge [
@ -74,6 +116,27 @@ in {
})
'';
})
(mkIf cfg.format.enable {
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.lua = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.lua = cfg.extraDiagnostics.types;
linters = mkMerge (map (name: {
${name}.cmd = getExe diagnosticsProviders.${name}.package;
})
cfg.extraDiagnostics.types);
};
})
]))
];
}

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

@ -5,12 +5,13 @@
...
}: let
inherit (builtins) attrNames;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.lists) isList concatLists;
inherit (lib.types) bool enum either package listOf str;
inherit (lib.lists) isList;
inherit (lib.types) bool enum either package listOf str nullOr;
inherit (lib.nvim.lua) expToLua toLuaObject;
inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption;
inherit (lib.nvim.types) diagnostics mkGrammarOption mkPluginSetupOption;
inherit (lib.nvim.dag) entryAnywhere;
cfg = config.vim.languages.markdown;
@ -32,31 +33,23 @@
};
};
defaultFormat = "denofmt";
defaultFormat = "deno_fmt";
formats = {
# for backwards compatibility
denofmt = {
package = pkgs.deno;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.deno_fmt.with({
filetypes = ${expToLua (concatLists [cfg.format.extraFiletypes ["markdown"]])},
command = "${cfg.format.package}/bin/deno",
})
)
'';
};
deno_fmt = {
package = pkgs.deno;
};
prettierd = {
package = pkgs.prettierd;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.prettierd.with({
filetypes = ${expToLua (concatLists [cfg.format.extraFiletypes ["markdown"]])},
command = "${cfg.format.package}/bin/prettierd",
})
)
'';
};
};
defaultDiagnosticsProvider = ["markdownlint-cli2"];
diagnosticsProviders = {
markdownlint-cli2 = {
package = pkgs.markdownlint-cli2;
};
};
in {
@ -96,7 +89,7 @@ in {
type = mkOption {
type = enum (attrNames formats);
default = defaultFormat;
description = "Markdown formatter to use";
description = "Markdown formatter to use. `denofmt` is deprecated and currently aliased to deno_fmt.";
};
package = mkOption {
@ -121,19 +114,32 @@ in {
[render-markdown.nvim]: https://github.com/MeanderingProgrammer/render-markdown.nvim
Inline Markdown rendering with [render-markdown.nvim]
'';
};
setupOpts = mkPluginSetupOption "render-markdown" {
auto_override_publish_diagnostics = mkOption {
description = "Automatically override the publish_diagnostics handler";
type = bool;
default = true;
file_types = lib.mkOption {
type = nullOr (listOf str);
default = null;
description = ''
List of buffer filetypes to enable this plugin in.
This will cause the plugin to attach to new buffers who
have any of these filetypes.
'';
};
};
};
};
extraDiagnostics = {
enable = mkEnableOption "extra Markdown diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
types = diagnostics {
langDesc = "Markdown";
inherit diagnosticsProviders;
inherit defaultDiagnosticsProvider;
};
};
};
config = mkIf cfg.enable (mkMerge [
@ -148,8 +154,17 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.markdown-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.markdown = [cfg.format.type];
setupOpts.formatters.${
if cfg.format.type == "denofmt"
then "deno_fmt"
else cfg.format.type
} = {
command = getExe cfg.format.package;
};
};
})
# Extensions
@ -159,5 +174,16 @@ in {
require("render-markdown").setup(${toLuaObject cfg.extensions.render-markdown-nvim.setupOpts})
'';
})
(mkIf cfg.extraDiagnostics.enable {
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.markdown = cfg.extraDiagnostics.types;
linters = mkMerge (map (name: {
${name}.cmd = getExe diagnosticsProviders.${name}.package;
})
cfg.extraDiagnostics.types);
};
})
]);
}

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

@ -6,6 +6,7 @@
}: 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;
@ -38,14 +39,9 @@
formats = {
nimpretty = {
package = pkgs.nim;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.nimpretty.with({
command = "${pkgs.nim}/bin/nimpretty",
})
)
'';
config = {
command = "${cfg.format.package}/bin/nimpretty";
};
};
};
in {
@ -110,8 +106,11 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.nim-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.nim = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
};
})
]);
}

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

@ -6,6 +6,7 @@
}: let
inherit (builtins) attrNames;
inherit (lib) concatStringsSep;
inherit (lib.meta) getExe;
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.lists) isList;
@ -13,7 +14,6 @@
inherit (lib.types) anything attrsOf enum either listOf nullOr package str;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.nvim.lua) expToLua toLuaObject;
inherit (lib.nvim.languages) diagnosticsToLua;
cfg = config.vim.languages.nix;
@ -100,26 +100,10 @@
formats = {
alejandra = {
package = pkgs.alejandra;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.alejandra.with({
command = "${cfg.format.package}/bin/alejandra"
})
)
'';
};
nixfmt = {
package = pkgs.nixfmt-rfc-style;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.nixfmt.with({
command = "${cfg.format.package}/bin/nixfmt"
})
)
'';
};
};
@ -237,17 +221,24 @@ in {
vim.lsp.lspconfig.sources.nix-lsp = servers.${cfg.lsp.server}.lspConfig;
})
(mkIf (cfg.format.enable && !servers.${cfg.lsp.server}.internalFormatter) {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.nix-format = formats.${cfg.format.type}.nullConfig;
(mkIf (cfg.format.enable && (!cfg.lsp.enable || !servers.${cfg.lsp.server}.internalFormatter)) {
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.nix = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources = diagnosticsToLua {
lang = "nix";
config = cfg.extraDiagnostics.types;
inherit diagnosticsProviders;
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.nix = cfg.extraDiagnostics.types;
linters = mkMerge (map (name: {
${name}.cmd = getExe diagnosticsProviders.${name}.package;
})
cfg.extraDiagnostics.types);
};
})
]);

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

@ -37,14 +37,6 @@
formats = {
ocamlformat = {
package = pkgs.ocamlPackages.ocamlformat;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.ocamlformat.with({
command = "${cfg.format.package}/bin/ocamlformat",
})
)
'';
};
};
in {
@ -97,9 +89,13 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.ocamlformat = formats.${cfg.format.type}.nullConfig;
vim.extraPackages = [formats.${cfg.format.type}.package];
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.ocaml = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
]);
}

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

@ -47,7 +47,7 @@
};
python-lsp-server = {
package = pkgs.python-lsp-server;
package = pkgs.python3Packages.python-lsp-server;
lspConfig = ''
lspconfig.pylsp.setup{
capabilities = capabilities;
@ -66,26 +66,10 @@
formats = {
black = {
package = pkgs.black;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.black.with({
command = "${cfg.format.package}/bin/black",
})
)
'';
};
isort = {
package = pkgs.isort;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.isort.with({
command = "${cfg.format.package}/bin/isort",
})
)
'';
};
black-and-isort = {
@ -96,15 +80,6 @@
black --quiet - "$@" | isort --profile black -
'';
};
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.black.with({
command = "${cfg.format.package}/bin/black",
})
)
'';
};
ruff = {
@ -115,14 +90,6 @@
ruff format -
'';
};
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.ruff.with({
command = "${cfg.format.package}/bin/ruff",
})
)
'';
};
};
@ -132,7 +99,7 @@
# idk if this is the best way to install/run debugpy
package = pkgs.python3.withPackages (ps: with ps; [debugpy]);
dapConfig = ''
dap.adapters.python = function(cb, config)
dap.adapters.debugpy = function(cb, config)
if config.request == 'attach' then
---@diagnostic disable-next-line: undefined-field
local port = (config.connect or config).port
@ -161,7 +128,7 @@
dap.configurations.python = {
{
-- The first three options are required by nvim-dap
type = 'python'; -- the type here established the link to the adapter definition: `dap.adapters.python`
type = 'debugpy'; -- the type here established the link to the adapter definition: `dap.adapters.debugpy`
request = 'launch';
name = "Launch file";
@ -272,8 +239,22 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.python-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
# HACK: I'm planning to remove these soon so I just took the easiest way out
setupOpts.formatters_by_ft.python =
if cfg.format.type == "black-and-isort"
then ["black"]
else [cfg.format.type];
setupOpts.formatters =
if (cfg.format.type == "black-and-isort")
then {
black.command = "${cfg.format.package}/bin/black";
}
else {
${cfg.format.type}.command = getExe cfg.format.package;
};
};
})
(mkIf cfg.dap.enable {

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

@ -24,28 +24,29 @@
package = pkgs.rWrapper.override {
packages = [pkgs.rPackages.styler];
};
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.styler.with({
command = "${cfg.format.package}/bin/R",
})
)
'';
config = {
command = "${cfg.format.package}/bin/R";
};
};
format_r = {
package = pkgs.rWrapper.override {
packages = [pkgs.rPackages.formatR];
};
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.format_r.with({
command = "${cfg.format.package}/bin/R",
})
)
'';
config = {
command = "${cfg.format.package}/bin/R";
stdin = true;
args = [
"--slave"
"--no-restore"
"--no-save"
"-s"
"-e"
''formatR::tidy_source(source="stdin")''
];
# TODO: range_args seem to be possible
# https://github.com/nvimtools/none-ls.nvim/blob/main/lua/null-ls/builtins/formatting/format_r.lua
};
};
};
@ -118,8 +119,11 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.r-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.r = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
};
})
(mkIf cfg.lsp.enable {

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

@ -6,10 +6,10 @@
}: let
inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.types) either listOf package str enum;
inherit (lib.nvim.languages) diagnosticsToLua;
cfg = config.vim.languages.ruby;
@ -35,24 +35,8 @@
defaultFormat = "rubocop";
formats = {
rubocop = {
# TODO: is this right?
package = pkgs.rubyPackages.rubocop;
nullConfig = ''
local conditional = function(fn)
local utils = require("null-ls.utils").make_conditional_utils()
return fn(utils)
end
table.insert(
ls_sources,
null_ls.builtins.formatting.rubocop.with({
command="${pkgs.bundler}/bin/bundle",
args = vim.list_extend(
{"exec", "rubocop", "-a" },
null_ls.builtins.formatting.rubocop._opts.args
),
})
)
'';
};
};
@ -60,14 +44,7 @@
diagnosticsProviders = {
rubocop = {
package = pkgs.rubyPackages.rubocop;
nullConfig = pkg: ''
table.insert(
ls_sources,
null_ls.builtins.diagnostics.rubocop.with({
command = "${lib.getExe pkg}",
})
)
'';
config.command = getExe cfg.format.package;
};
};
in {
@ -136,16 +113,23 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.ruby-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.ruby = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources = diagnosticsToLua {
lang = "ruby";
config = cfg.extraDiagnostics.types;
inherit diagnosticsProviders;
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.ruby = cfg.extraDiagnostics.types;
linters = mkMerge (map (name: {
${name}.cmd = getExe diagnosticsProviders.${name}.package;
})
cfg.extraDiagnostics.types);
};
})
]);

18
modules/plugins/languages/rust.nix
View file

@ -5,6 +5,7 @@
...
}: let
inherit (builtins) attrNames;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.strings) optionalString;
@ -21,14 +22,6 @@
formats = {
rustfmt = {
package = pkgs.rustfmt;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.rustfmt.with({
command = "${cfg.format.package}/bin/rustfmt",
})
)
'';
};
};
in {
@ -128,8 +121,13 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.rust-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.rust = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
(mkIf (cfg.lsp.enable || cfg.dap.enable) {

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

@ -6,11 +6,11 @@
}: 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.nvim.lua) expToLua;
inherit (lib.nvim.languages) diagnosticsToLua;
inherit (lib.nvim.types) diagnostics;
cfg = config.vim.languages.sql;
@ -41,15 +41,10 @@
formats = {
sqlfluff = {
package = sqlfluffDefault;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.sqlfluff.with({
command = "${cfg.format.package}/bin/sqlfluff",
extra_args = {"--dialect", "${cfg.dialect}"}
})
)
'';
config = {
command = getExe cfg.format.package;
append_args = ["--dialect=${cfg.dialect}"];
};
};
};
@ -57,15 +52,10 @@
diagnosticsProviders = {
sqlfluff = {
package = sqlfluffDefault;
nullConfig = pkg: ''
table.insert(
ls_sources,
null_ls.builtins.diagnostics.sqlfluff.with({
command = "${pkg}/bin/sqlfluff",
extra_args = {"--dialect", "${cfg.dialect}"}
})
)
'';
config = {
cmd = getExe sqlfluffDefault;
args = ["lint" "--format=json" "--dialect=${cfg.dialect}"];
};
};
};
in {
@ -150,16 +140,20 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources."sql-format" = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.sql = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources = diagnosticsToLua {
lang = "sql";
config = cfg.extraDiagnostics.types;
inherit diagnosticsProviders;
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.sql = cfg.extraDiagnostics.types;
linters =
mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
cfg.extraDiagnostics.types);
};
})
]);

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

@ -9,9 +9,9 @@
inherit (lib.modules) mkIf mkMerge;
inherit (lib.lists) isList;
inherit (lib.meta) getExe;
inherit (lib.generators) mkLuaInline;
inherit (lib.types) enum either listOf package str;
inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.languages) diagnosticsToLua;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
cfg = config.vim.languages.svelte;
@ -39,52 +39,31 @@
formats = {
prettier = {
package = pkgs.nodePackages.prettier;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.prettier.with({
command = "${cfg.format.package}/bin/prettier",
})
)
'';
};
biome = {
package = pkgs.biome;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.biome.with({
command = "${cfg.format.package}/bin/biome",
})
)
'';
};
};
# TODO: specify packages
defaultDiagnosticsProvider = ["eslint_d"];
diagnosticsProviders = {
eslint_d = {
package = pkgs.eslint_d;
nullConfig = pkg: ''
table.insert(
ls_sources,
null_ls.builtins.diagnostics.eslint_d.with({
command = "${getExe pkg}",
condition = function(utils)
return utils.root_has_file({
"eslint.config.js",
"eslint.config.mjs",
".eslintrc",
".eslintrc.json",
".eslintrc.js",
".eslintrc.yml",
})
end,
})
)
'';
eslint_d = let
pkg = pkgs.eslint_d;
in {
package = pkg;
config = {
cmd = getExe pkg;
required_files = [
"eslint.config.js"
"eslint.config.mjs"
".eslintrc"
".eslintrc.json"
".eslintrc.js"
".eslintrc.yml"
];
};
};
};
in {
@ -153,16 +132,22 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.svelte-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.svelte = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources = diagnosticsToLua {
lang = "svelte";
config = cfg.extraDiagnostics.types;
inherit diagnosticsProviders;
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.svelte = cfg.extraDiagnostics.types;
linters =
mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
cfg.extraDiagnostics.types);
};
})
]);

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

@ -9,10 +9,10 @@
inherit (lib.modules) mkIf mkMerge;
inherit (lib.lists) isList;
inherit (lib.meta) getExe;
inherit (lib.generators) mkLuaInline;
inherit (lib.types) enum either listOf package str bool;
inherit (lib.nvim.lua) expToLua toLuaObject;
inherit (lib.nvim.types) mkGrammarOption diagnostics mkPluginSetupOption;
inherit (lib.nvim.languages) diagnosticsToLua;
inherit (lib.nvim.dag) entryAnywhere;
cfg = config.vim.languages.ts;
@ -77,65 +77,35 @@
formats = {
prettier = {
package = pkgs.nodePackages.prettier;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.prettier.with({
command = "${cfg.format.package}/bin/prettier",
filetypes = { "typescript", "javascript" },
})
)
'';
};
prettierd = {
package = pkgs.prettierd;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.prettier.with({
command = "${cfg.format.package}/bin/prettierd",
})
)
'';
};
biome = {
package = pkgs.biome;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.biome.with({
command = "${cfg.format.package}/bin/biome",
})
)
'';
};
};
# TODO: specify packages
defaultDiagnosticsProvider = ["eslint_d"];
diagnosticsProviders = {
eslint_d = {
package = pkgs.eslint_d;
nullConfig = pkg: ''
table.insert(
ls_sources,
null_ls.builtins.diagnostics.eslint_d.with({
command = "${getExe pkg}",
condition = function(utils)
return utils.root_has_file({
"eslint.config.js",
"eslint.config.mjs",
".eslintrc",
".eslintrc.json",
".eslintrc.js",
".eslintrc.yml",
})
end,
})
)
'';
eslint_d = let
pkg = pkgs.eslint_d;
in {
package = pkg;
config = {
cmd = getExe pkg;
required_files = [
"eslint.config.js"
"eslint.config.mjs"
".eslintrc"
".eslintrc.json"
".eslintrc.js"
".eslintrc.yml"
];
};
};
};
in {
@ -225,16 +195,28 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.ts-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts = {
formatters_by_ft.typescript = [cfg.format.type];
# .tsx files
formatters_by_ft.typescriptreact = [cfg.format.type];
formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
};
})
(mkIf cfg.extraDiagnostics.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources = diagnosticsToLua {
lang = "ts";
config = cfg.extraDiagnostics.types;
inherit diagnosticsProviders;
vim.diagnostics.nvim-lint = {
enable = true;
linters_by_ft.typescript = cfg.extraDiagnostics.types;
linters_by_ft.typescriptreact = cfg.extraDiagnostics.types;
linters =
mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
cfg.extraDiagnostics.types);
};
})

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

@ -9,7 +9,6 @@
inherit (lib.lists) isList;
inherit (lib.types) nullOr enum either attrsOf listOf package str;
inherit (lib.attrsets) attrNames;
inherit (lib.generators) mkLuaInline;
inherit (lib.meta) getExe;
inherit (lib.nvim.lua) expToLua toLuaObject;
inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption;
@ -61,26 +60,10 @@
formats = {
typstfmt = {
package = pkgs.typstfmt;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.typstfmt.with({
command = "${cfg.format.package}/bin/typstfmt",
})
)
'';
};
# https://github.com/Enter-tainer/typstyle
typstyle = {
package = pkgs.typstyle;
nullConfig = ''
table.insert(
ls_sources,
null_ls.builtins.formatting.typstfmt.with({
command = "${cfg.format.package}/bin/typstyle",
})
)
'';
};
};
in {
@ -176,8 +159,13 @@ in {
})
(mkIf cfg.format.enable {
vim.lsp.null-ls.enable = true;
vim.lsp.null-ls.sources.typst-format = formats.${cfg.format.type}.nullConfig;
vim.formatter.conform-nvim = {
enable = true;
setupOpts.formatters_by_ft.typst = [cfg.format.type];
setupOpts.formatters.${cfg.format.type} = {
command = getExe cfg.format.package;
};
};
})
(mkIf cfg.lsp.enable {

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

@ -4,6 +4,7 @@
pkgs,
...
}: let
inherit (lib.generators) mkLuaInline;
inherit (lib.modules) mkIf;
inherit (lib.strings) optionalString;
inherit (lib.trivial) boolToString;
@ -28,6 +29,25 @@ in {
sourcePlugins = ["cmp-nvim-lsp"];
};
autocmds =
if cfg.inlayHints.enable
then [
{
callback = mkLuaInline ''
function(event)
local bufnr = event.buf
local client = vim.lsp.get_client_by_id(event.data.client_id)
if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_inlayHint) then
vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({ bufnr = bufnr }), { bufnr = bufnr })
end
end
'';
desc = "LSP on-attach enable inlay hints autocmd";
event = ["LspAttach"];
}
]
else [];
pluginRC.lsp-setup = ''
vim.g.formatsave = ${boolToString cfg.formatOnSave};

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

@ -15,7 +15,6 @@
./lightbulb
./otter
./lspkind
./lsplines
./nvim-docs-view
];
}

21
modules/plugins/lsp/lsplines/config.nix
View file

@ -1,21 +0,0 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.dag) entryAfter;
cfg = config.vim.lsp;
in {
config = mkIf (cfg.enable && cfg.lsplines.enable) {
vim.startPlugins = ["lsp-lines"];
vim.pluginRC.lsplines = entryAfter ["lspconfig"] ''
require("lsp_lines").setup()
vim.diagnostic.config({
virtual_text = false,
})
'';
};
}

11
modules/plugins/lsp/lsplines/lsplines.nix
View file

@ -1,11 +0,0 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
in {
options.vim.lsp = {
lsplines = {
enable = mkEnableOption ''
diagnostics using virtual lines on top of the real line of code. [lsp_lines]
'';
};
};
}

29
modules/plugins/lsp/lspsaga/lspsaga.nix
View file

@ -6,6 +6,19 @@
inherit (lib.modules) mkRemovedOptionModule;
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.nvim.types) borderType mkPluginSetupOption;
inherit (lib.nvim.lua) mkLuaInline;
uiKindSetupOpts =
if config.vim.theme.enable && config.vim.theme.name == "catppuccin"
then {
ui.kind =
mkLuaInline
# lua
''
require("catppuccin.groups.integrations.lsp_saga").custom_kind()
'';
}
else {};
in {
imports = [
(mkRemovedOptionModule ["vim" "lsp" "lspsaga" "mappings"] ''
@ -21,12 +34,14 @@ in {
options.vim.lsp.lspsaga = {
enable = mkEnableOption "LSP Saga";
setupOpts = mkPluginSetupOption "lspsaga" {
border_style = mkOption {
type = borderType;
default = config.vim.ui.borders.globalStyle;
description = "Border type, see {command}`:help nvim_open_win`";
};
};
setupOpts =
mkPluginSetupOption "lspsaga" {
border_style = mkOption {
type = borderType;
default = config.vim.ui.borders.globalStyle;
description = "Border type, see {command}`:help nvim_open_win`";
};
}
// uiKindSetupOpts;
};
}

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

@ -5,6 +5,9 @@ in {
options.vim.lsp = {
enable = mkEnableOption "LSP, also enabled automatically through null-ls and lspconfig options";
formatOnSave = mkEnableOption "format on save";
inlayHints = {
enable = mkEnableOption "inlay hints";
};
mappings = {
goToDefinition =
mkMappingOption "Go to definition"

40
modules/plugins/lsp/null-ls/config.nix
View file

@ -4,13 +4,12 @@
...
}: let
inherit (lib.modules) mkIf mkMerge;
inherit (lib.attrsets) mapAttrs;
inherit (lib.trivial) boolToString;
inherit (lib.nvim.dag) entryAnywhere entryAfter entryBetween;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.dag) entryAfter;
cfg = config.vim.lsp;
cfg = config.vim.lsp.null-ls;
in {
config = mkIf cfg.null-ls.enable (mkMerge [
config = mkIf cfg.enable (mkMerge [
{
vim = {
startPlugins = [
@ -18,35 +17,14 @@ in {
"plenary-nvim"
];
# null-ls implies LSP already being set up
# since it will hook into LSPs to receive information
# null-ls implies that LSP is already being set up
# as it will hook into LSPs to receive information.
lsp.enable = true;
pluginRC = {
# early setup for null-ls
null_ls-setup = entryAnywhere ''
local null_ls = require("null-ls")
local null_helpers = require("null-ls.helpers")
local null_methods = require("null-ls.methods")
local ls_sources = {}
'';
# null-ls setup
null_ls = entryAfter ["null_ls-setup" "lsp-setup"] ''
require('null-ls').setup({
debug = ${boolToString cfg.null-ls.debug},
diagnostics_format = "${cfg.null-ls.diagnostics_format}",
debounce = ${toString cfg.null-ls.debounce},
default_timeout = ${toString cfg.null-ls.default_timeout},
sources = ls_sources,
on_attach = default_on_attach
})
'';
};
pluginRC.null_ls = entryAfter ["lsp-setup"] ''
require('null-ls').setup(${toLuaObject cfg.setupOpts})
'';
};
}
{
vim.pluginRC = mapAttrs (_: v: (entryBetween ["null_ls"] ["null_ls-setup"] v)) cfg.null-ls.sources;
}
]);
}

99
modules/plugins/lsp/null-ls/null-ls.nix
View file

@ -1,34 +1,87 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) attrsOf str int;
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.types) listOf str int nullOr;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.types) luaInline mkPluginSetupOption;
inherit (lib.nvim.config) batchRenameOptions;
migrationTable = {
debug = "debug";
diagnostics_format = "diagnostics_format";
debounce = "debounce";
default_timeout = "default_timeout";
sources = "sources";
};
renamedSetupOpts =
batchRenameOptions
["vim" "lsp" "null-ls"]
["vim" "lsp" "null-ls" "setupOpts"]
migrationTable;
in {
imports = renamedSetupOpts;
options.vim.lsp.null-ls = {
enable = mkEnableOption "null-ls, also enabled automatically";
enable = mkEnableOption ''
null-ls, plugin to use Neovim as a language server to inject LSP diagnostics,
code actions, and more via Lua.
'';
debug = mkEnableOption "debugging information for `null-ls";
setupOpts = mkPluginSetupOption "null-ls" {
debug = mkEnableOption ''
debugging information for null-ls.
diagnostics_format = mkOption {
type = str;
default = "[#{m}] #{s} (#{c})";
description = "Diagnostic output format for null-ls";
};
Displays all possible log messages and writes them to the null-ls log,
which you can view with the command `:NullLsLog`
'';
debounce = mkOption {
type = int;
default = 250;
description = "Default debounce";
};
diagnostics_format = mkOption {
type = str;
default = "[#{m}] #{s} (#{c})";
description = ''
Sets the default format used for diagnostics. null-ls will replace th
e following special components with the relevant diagnostic information:
default_timeout = mkOption {
type = int;
default = 5000;
description = "Default timeout value, in milliseconds";
};
* `#{m}`: message
* `#{s}`: source name (defaults to null-ls if not specified)
* `#{c}`: code (if available)
'';
};
sources = mkOption {
description = "null-ls sources";
type = attrsOf str;
default = {};
debounce = mkOption {
type = int;
default = 250;
description = ''
Amount of time between the last change to a buffer and the next `textDocument/didChange` notification.
'';
};
default_timeout = mkOption {
type = int;
default = 5000;
description = ''
Amount of time (in milliseconds) after which built-in sources will time out.
:::{.note}
Built-in sources can define their own timeout period and users can override
the timeout period on a per-source basis
:::
'';
};
sources = mkOption {
type = nullOr (listOf luaInline);
default = null;
description = "Sources for null-ls to register";
};
on_attach = mkOption {
type = nullOr luaInline;
default = mkLuaInline "on_attach";
description = ''
Defines an on_attach callback to run whenever null-ls attaches to a buffer.
'';
};
};
};
}

19
modules/plugins/mini/cursorword/config.nix Normal file
View file

@ -0,0 +1,19 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.lua) toLuaObject;
cfg = config.vim.mini.cursorword;
in {
vim = mkIf cfg.enable {
startPlugins = ["mini-cursorword"];
pluginRC.mini-ai = entryAnywhere ''
require("mini.cursorword").setup(${toLuaObject cfg.setupOpts})
'';
};
}

9
modules/plugins/mini/cursorword/cursorword.nix Normal file
View file

@ -0,0 +1,9 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {
options.vim.mini.cursorword = {
enable = mkEnableOption "mini.cursorword";
setupOpts = mkPluginSetupOption "mini.cursorword" {};
};
}

6
modules/plugins/mini/cursorword/default.nix Normal file
View file

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

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

@ -11,6 +11,7 @@
./colors
./comment
./completion
./cursorword
./diff
./doc
./extra

16
modules/plugins/mini/indentscope/config.nix
View file

@ -3,6 +3,7 @@
lib,
...
}: let
inherit (lib.generators) mkLuaInline;
inherit (lib.modules) mkIf;
inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.lua) toLuaObject;
@ -10,6 +11,21 @@
cfg = config.vim.mini.indentscope;
in {
vim = mkIf cfg.enable {
autocmds = [
{
callback = mkLuaInline ''
function()
local ignore_filetypes = ${toLuaObject cfg.setupOpts.ignore_filetypes}
if vim.tbl_contains(ignore_filetypes, vim.bo.filetype) then
vim.b.miniindentscope_disable = true
end
end
'';
desc = "Disable indentscope for certain filetypes";
event = ["FileType"];
}
];
startPlugins = ["mini-indentscope"];
pluginRC.mini-indentscope = entryAnywhere ''

17
modules/plugins/mini/indentscope/indentscope.nix
View file

@ -1,13 +1,16 @@
{
config,
lib,
...
}: let
inherit (lib.options) mkEnableOption;
{lib, ...}: let
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
inherit (lib.types) str listOf;
in {
options.vim.mini.indentscope = {
enable = mkEnableOption "mini.indentscope";
setupOpts = mkPluginSetupOption "mini.indentscope" {};
setupOpts = mkPluginSetupOption "mini.indentscope" {
ignore_filetypes = mkOption {
type = listOf str;
default = ["help" "neo-tree" "notify" "NvimTree" "TelescopePrompt"];
description = "File types to ignore for illuminate";
};
};
};
}

28
modules/plugins/statusline/lualine/config.nix
View file

@ -14,12 +14,28 @@
bCfg = config.vim.ui.breadcrumbs;
in {
config = mkMerge [
# TODO: move into nvim-tree file
(mkIf config.vim.filetree.nvimTree.enable {
vim.statusline.lualine.setupOpts = {
extensions = ["nvim-tree"];
};
})
{
vim.statusline.lualine.setupOpts.extensions =
(lib.optionals config.vim.filetree.nvimTree.enable ["nvim-tree"])
++ (lib.optionals config.vim.filetree.neo-tree.enable ["neo-tree"])
++ (lib.optionals config.vim.utility.snacks-nvim.enable [
{
# same extensions as nerdtree / neo-tree
# https://github.com/nvim-lualine/lualine.nvim/blob/master/lua/lualine/extensions/nerdtree.lua
# https://github.com/nvim-lualine/lualine.nvim/blob/master/lua/lualine/extensions/neo-tree.lua
sections = {
lualine_a = mkLuaInline ''
{
function()
return vim.fn.fnamemodify(vim.fn.getcwd(), ":~")
end,
}
'';
};
filetypes = ["snacks_picker_list" "snacks_picker_input"];
}
]);
}
(mkIf (bCfg.enable && bCfg.lualine.winbar.enable && bCfg.source == "nvim-navic") {
vim.statusline.lualine.setupOpts = {

35
modules/plugins/statusline/lualine/lualine.nix
View file

@ -239,35 +239,26 @@ in {
{
-- Lsp server name
function()
local buf_ft = vim.api.nvim_get_option_value('filetype', {})
local buf_ft = vim.bo.filetype
local excluded_buf_ft = { toggleterm = true, NvimTree = true, ["neo-tree"] = true, TelescopePrompt = true }
-- List of buffer types to exclude
local excluded_buf_ft = {"toggleterm", "NvimTree", "neo-tree", "TelescopePrompt"}
-- Check if the current buffer type is in the excluded list
for _, excluded_type in ipairs(excluded_buf_ft) do
if buf_ft == excluded_type then
return ""
if excluded_buf_ft[buf_ft] then
return ""
end
local bufnr = vim.api.nvim_get_current_buf()
local clients = vim.lsp.get_clients({ bufnr = bufnr })
if vim.tbl_isempty(clients) then
return "No Active LSP"
end
-- Get the name of the LSP server active in the current buffer
local clients = vim.lsp.get_active_clients()
local msg = 'No Active Lsp'
-- if no lsp client is attached then return the msg
if next(clients) == nil then
return msg
end
local active_clients = {}
for _, client in ipairs(clients) do
local filetypes = client.config.filetypes
if filetypes and vim.fn.index(filetypes, buf_ft) ~= -1 then
return client.name
end
table.insert(active_clients, client.name)
end
return msg
return table.concat(active_clients, ", ")
end,
icon = ' ',
separator = {left = ''},

2
modules/plugins/tabline/nvim-bufferline/config.nix
View file

@ -9,7 +9,7 @@
inherit (lib.nvim.lua) toLuaObject;
cfg = config.vim.tabline.nvimBufferline;
self = import ./nvim-bufferline.nix {inherit lib;};
self = import ./nvim-bufferline.nix {inherit config lib;};
inherit (self.options.vim.tabline.nvimBufferline) mappings;
in {
config = mkIf cfg.enable {

29
modules/plugins/tabline/nvim-bufferline/nvim-bufferline.nix
View file

@ -1,4 +1,8 @@
{lib, ...}: let
{
config,
lib,
...
}: let
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.types) enum bool either nullOr str int listOf attrs;
inherit (lib.generators) mkLuaInline;
@ -23,7 +27,14 @@ in {
setupOpts = mkPluginSetupOption "Bufferline-nvim" {
highlights = mkOption {
type = either attrs luaInline;
default = {};
default =
if config.vim.theme.enable && config.vim.theme.name == "catppuccin"
then
mkLuaInline
''
require("catppuccin.groups.integrations.bufferline").get()
''
else {};
description = ''
Overrides the highlight groups of bufferline.
@ -261,14 +272,12 @@ in {
offsets = mkOption {
type = listOf attrs;
default = [
{
filetype = "NvimTree";
text = "File Explorer";
highlight = "Directory";
separator = true;
}
];
default = map (filetype: {
inherit filetype;
text = "File Explorer";
highlight = "Directory";
separator = true;
}) ["NvimTree" "neo-tree" "snacks_layout_box"];
description = "The windows to offset bufferline above, see `:help bufferline-offset`";
};

25
modules/plugins/theme/supported-themes.nix
View file

@ -66,21 +66,22 @@ in {
transparent_background = ${boolToString transparent},
term_colors = true,
integrations = {
nvimtree = {
enabled = true,
transparent_panel = ${boolToString transparent},
show_root = true,
},
nvimtree = {
enabled = true,
transparent_panel = ${boolToString transparent},
show_root = true,
},
hop = true,
gitsigns = true,
telescope = true,
treesitter = true,
gitsigns = true,
telescope = true,
treesitter = true,
treesitter_context = true,
ts_rainbow = true,
ts_rainbow = true,
fidget = true,
alpha = true,
leap = true,
lsp_saga = true,
markdown = true,
noice = true,
notify = true, -- nvim-notify
@ -106,9 +107,9 @@ in {
style' =
warnIf (style == "light") "oxocarbon: light theme is not well-supported" style;
in ''
require('oxocarbon')
vim.opt.background = "${style'}"
vim.cmd.colorscheme = "oxocarbon"
require('oxocarbon')
vim.opt.background = "${style'}"
vim.cmd.colorscheme = "oxocarbon"
${optionalString transparent ''
vim.api.nvim_set_hl(0, "Normal", { bg = "none" })
vim.api.nvim_set_hl(0, "NormalFloat", { bg = "none" })

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

@ -24,12 +24,19 @@ in {
grammars = mkOption {
type = listOf package;
default = [];
example = literalExpression ''
pkgs.vimPlugins.nvim-treesitter.builtGrammars; [
regex
kdl
];
'';
description = ''
List of treesitter grammars to install.
List of treesitter grammars to install. For grammars to be installed properly,
you must use grammars from `pkgs.vimPlugins.nvim-treesitter.builtGrammars`.
For languages already supported by nvf, you may
use the {option}`vim.language.<lang>.treesitter` options, which
will automatically add the required grammars to this.
For languages already supported by nvf, you may use
{option}`vim.language.<lang>.treesitter` options, which will automatically add
the required grammars to this.
'';
};

2
modules/plugins/ui/illuminate/illuminate.nix
View file

@ -11,7 +11,7 @@ in {
setupOpts = mkPluginSetupOption "vim-illuminate" {
filetypes_denylist = mkOption {
type = listOf str;
default = ["dirvish" "fugitive" "NvimTree" "TelescopePrompt"];
default = ["dirvish" "fugitive" "help" "neo-tree" "notify" "NvimTree" "TelescopePrompt"];
description = "Filetypes to not illuminate, this overrides `filetypes_allowlist`";
};
};

2
modules/plugins/utility/default.nix
View file

@ -15,8 +15,10 @@
./multicursors
./new-file-template
./nix-develop
./oil-nvim
./outline
./preview
./sleuth
./snacks-nvim
./surround
./telescope

8
modules/plugins/utility/fzf-lua/fzf-lua.nix
View file

@ -1,15 +1,21 @@
{
config,
lib,
pkgs,
...
}: let
inherit (lib.types) nullOr enum;
inherit (lib.types) enum str;
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.nvim.types) mkPluginSetupOption borderType;
in {
options.vim.fzf-lua = {
enable = mkEnableOption "fzf-lua";
setupOpts = mkPluginSetupOption "fzf-lua" {
fzf_bin = mkOption {
type = str;
default = "${lib.getExe pkgs.fzf}";
description = "Path to fzf executable";
};
winopts.border = mkOption {
type = borderType;
default = config.vim.ui.borders.globalStyle;

1
modules/plugins/utility/motion/default.nix
View file

@ -1,5 +1,6 @@
_: {
imports = [
./flash
./hop
./leap
./precognition

34
modules/plugins/utility/motion/flash/config.nix Normal file
View file

@ -0,0 +1,34 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.binds) mkKeymap;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.dag) entryAnywhere;
cfg = config.vim.utility.motion.flash-nvim;
in {
config = mkIf cfg.enable {
vim = {
lazy.plugins = {
"flash-nvim" = {
package = "flash-nvim";
setupModule = "flash";
setupOpts = cfg.setupOpts;
lazy = true;
keys = [
(mkKeymap ["n" "o" "x"] cfg.mappings.jump "<cmd>lua require(\"flash\").jump()<cr>" {desc = "Flash";})
(mkKeymap ["n" "o" "x"] cfg.mappings.treesitter "<cmd>lua require(\"flash\").treesitter()<cr>" {desc = "Flash Treesitter";})
(mkKeymap "o" cfg.mappings.remote "<cmd>lua require(\"flash\").remote()<cr>" {desc = "Remote Flash";})
(mkKeymap ["o" "x"] cfg.mappings.treesitter_search "<cmd>lua require(\"flash\").treesitter_search()<cr>" {desc = "Treesitter Search";})
(mkKeymap "c" cfg.mappings.toggle "<cmd>lua require(\"flash\").toggle()<cr>" {desc = "Toggle Flash Search";})
];
};
};
};
};
}

2
modules/plugins/lsp/lsplines/default.nix → modules/plugins/utility/motion/flash/default.nix
View file

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

38
modules/plugins/utility/motion/flash/flash.nix Normal file
View file

@ -0,0 +1,38 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) nullOr str;
inherit (lib.nvim.types) mkPluginSetupOption;
in {
options.vim.utility.motion.flash-nvim = {
enable = mkEnableOption "enhanced code navigation with flash.nvim";
setupOpts = mkPluginSetupOption "flash-nvim" {};
mappings = {
jump = mkOption {
type = nullOr str;
default = "s";
description = "Jump";
};
treesitter = mkOption {
type = nullOr str;
default = "S";
description = "Treesitter";
};
remote = mkOption {
type = nullOr str;
default = "r";
description = "Remote Flash";
};
treesitter_search = mkOption {
type = nullOr str;
default = "R";
description = "Treesitter Search";
};
toggle = mkOption {
type = nullOr str;
default = "<c-s>";
description = "Toggle Flash Search";
};
};
};
}

20
modules/plugins/utility/oil-nvim/config.nix Normal file
View file

@ -0,0 +1,20 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.dag) entryAnywhere;
cfg = config.vim.utility.oil-nvim;
in {
config = mkIf cfg.enable {
vim = {
startPlugins = ["oil-nvim"];
pluginRC.oil-nvim = entryAnywhere ''
require("oil").setup(${toLuaObject cfg.setupOpts});
'';
};
};
}

6
modules/plugins/utility/oil-nvim/default.nix Normal file
View file

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

12
modules/plugins/utility/oil-nvim/oil-nvim.nix Normal file
View file

@ -0,0 +1,12 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {
options.vim.utility.oil-nvim = {
enable = mkEnableOption ''
Neovim file explorer: edit your filesystem like a buffer [oil-nvim]
'';
setupOpts = mkPluginSetupOption "oil-nvim" {};
};
}

10
modules/plugins/utility/sleuth/config.nix Normal file
View file

@ -0,0 +1,10 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
cfg = config.vim.utility.sleuth;
in {
vim.startPlugins = mkIf cfg.enable ["vim-sleuth"];
}

6
modules/plugins/utility/sleuth/default.nix Normal file
View file

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

7
modules/plugins/utility/sleuth/sleuth.nix Normal file
View file

@ -0,0 +1,7 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
in {
options.vim.utility.sleuth.enable = mkEnableOption ''
automatically adjusting options such as `shiftwidth` or `expandtab`, using `vim-sleuth`
'';
}

9
modules/plugins/utility/telescope/telescope.nix
View file

@ -11,6 +11,12 @@
cfg = config.vim.telescope;
setupOptions = {
pickers.find_files.find_command = mkOption {
description = "cmd to use for finding files";
type = either (listOf str) luaInline;
default = ["${pkgs.fd}/bin/fd" "--type=file"];
};
defaults = {
vimgrep_arguments = mkOption {
type = listOf str;
@ -138,8 +144,7 @@
file_ignore_patterns = mkOption {
type = listOf str;
default = ["node_modules" ".git/" "dist/" "build/" "target/" "result/"];
description = "A table of lua regex that define the files that should be ignored.";
default = ["node_modules" "%.git/" "dist/" "build/" "target/" "result/"];
};
color_devicons = mkOption {

3
modules/plugins/visuals/nvim-scrollbar/config.nix
View file

@ -12,8 +12,7 @@ in {
config = mkIf cfg.enable {
vim = {
startPlugins = ["nvim-scrollbar"];
pluginRC.cursorline = entryAnywhere ''
pluginRC.nvim-scrollbar = entryAnywhere ''
require("scrollbar").setup(${toLuaObject cfg.setupOpts})
'';
};

2
modules/plugins/visuals/nvim-scrollbar/scrollbar-nvim.nix
View file

@ -13,7 +13,7 @@ in {
setupOpts = mkPluginSetupOption "scrollbar-nvim" {
excluded_filetypes = mkOption {
type = listOf str;
default = ["prompt" "TelescopePrompt" "noice" "noice" "NvimTree" "neo-tree" "alpha" "notify" "Navbuddy"];
default = ["prompt" "TelescopePrompt" "noice" "NvimTree" "neo-tree" "alpha" "notify" "Navbuddy" "fastaction_popup"];
description = "Filetypes to hide the scrollbar on";
};
};