NotAShelf/nvf
2
1
Fork 0
mirror of https://github.com/NotAShelf/nvf.git synced 2026-01-11 21:26:31 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Merge branch 'NotAShelf:main' into emmet-language-server

Browse source
This commit is contained in:
Bliztle 2025-10-15 13:49:01 +02:00 • committed by GitHub
commit c11f48e87a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
246 changed files with 4499 additions and 1736 deletions
Download patch file Download diff file Expand all files Collapse all files

11
modules/extra/deprecations.nix
View file

@ -18,7 +18,7 @@
showSignColumn = "signcolumn";
# 2025-02-07
scrollOff = "scrolloff";
scrollOffset = "scrolloff";
};
in {
imports = concatLists [
@ -111,6 +111,15 @@ in {
under the diagnostics module. Please consider using one of 'vim.diagnostics.config' or
'vim.luaConfigRC' to configure LSP lines for Neovim through its own diagnostics API.
'')
# 2025-05-04
(mkRemovedOptionModule ["vim" "useSystemClipboard"] ''
Clipboard behaviour should now be controlled through the new, more fine-grained module
interface found in 'vim.clipboard'. To replicate previous behaviour, you may either
add 'vim.opt.clipboard:append("unnamedplus")' in luaConfigRC, or preferably set it
in 'vim.clipboard.registers'. Please see the documentation for the new module for more
details, or open an issue if you are confused.
'')
]
# Migrated via batchRenameOptions. Further batch renames must be below this line.

3
modules/modules.nix
View file

@ -33,11 +33,12 @@
"minimap"
"notes"
"projects"
"repl"
"rich-presence"
"runner"
"session"
"snippets"
# "spellcheck" # FIXME: see neovim/init/spellcheck.nix
"spellcheck"
"statusline"
"tabline"
"terminal"

2
modules/neovim/init/autocmds.nix
View file

@ -38,7 +38,7 @@
type = nullOr luaInline;
default = null;
example = literalExpression ''
mkLuaInline '''
lib.generators.mkLuaInline '''
function()
print("Saving a Lua file...")
end

19
modules/neovim/init/basic.nix
View file

@ -6,11 +6,10 @@
inherit (lib.options) mkOption mkEnableOption literalMD;
inherit (lib.strings) optionalString;
inherit (lib.attrsets) optionalAttrs;
inherit (lib.types) enum bool str int either;
inherit (lib.types) enum bool str either;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.dag) entryAfter;
inherit (lib.nvim.binds) pushDownDefault;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.types) luaInline;
cfg = config.vim;
@ -22,24 +21,12 @@ in {
description = "Hide search highlight so it doesn't stay highlighted";
};
scrollOffset = mkOption {
type = int;
default = 8;
description = "Start scrolling this number of lines from the top or bottom of the page.";
};
syntaxHighlighting = mkOption {
type = bool;
default = !config.vim.treesitter.highlight.enable;
description = "Enable syntax highlighting";
};
useSystemClipboard = mkOption {
type = bool;
default = false;
description = "Make use of the clipboard for default yank and paste operations. Don't use * and +";
};
lineNumberMode = mkOption {
type = enum ["relative" "number" "relNumber" "none"];
default = "relNumber";
@ -144,10 +131,6 @@ in {
# to pre-set Neovim options. Fear not, though as the Lua DAG is still as powerful as it
# could be.
luaConfigRC.basic = entryAfter ["globalsScript"] ''
${optionalString cfg.useSystemClipboard ''
vim.opt.clipboard:append("unnamedplus")
''}
${optionalString cfg.syntaxHighlighting ''
vim.cmd("syntax on")
''}

80
modules/neovim/init/clipboard.nix Normal file
View file

@ -0,0 +1,80 @@
{
config,
pkgs,
lib,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.options) mkOption mkEnableOption mkPackageOption;
inherit (lib.types) str submodule;
inherit (lib.attrsets) mapAttrs mapAttrsToList filterAttrs;
cfg = config.vim.clipboard;
in {
options = {
vim = {
clipboard = {
enable = mkEnableOption ''
clipboard management for Neovim. Users may still choose to manage their
clipboard through [](#opt-vim.options) should they wish to avoid using
this module.
'';
registers = mkOption {
type = str;
default = "";
example = "unnamedplus";
description = ''
The register to be used by the Neovim clipboard. Recognized types are:
* unnamed: Vim will use the clipboard register `"*"` for all yank, delete,
change and put operations which would normally go to the unnamed register.
* unnamedplus: A variant of the "unnamed" flag which uses the clipboard register
`"+"` ({command}`:h quoteplus`) instead of register `"*"` for all yank, delete,
change and put operations which would normally go to the unnamed register.
When `unnamed` and `unnamedplus` is included simultaneously as `"unnamed,unnamedplus"`,
yank and delete operations (but not put) will additionally copy the text into register `"*"`.
Please see {command}`:h clipboard` for more details.
'';
};
providers = mkOption {
type = submodule {
options = let
clipboards = {
# name = "package name";
wl-copy = "wl-clipboard";
xclip = "xclip";
xsel = "xsel";
};
in
mapAttrs (name: pname: {
enable = mkEnableOption name;
package = mkPackageOption pkgs pname {nullable = true;};
})
clipboards;
};
default = {};
description = ''
Clipboard providers for which packages will be added to nvf's
{option}`extraPackages`. The `package` field may be set to `null`
if related packages are already found in system packages to
potentially reduce closure sizes.
'';
};
};
};
};
config = mkIf cfg.enable {
vim = {
options.clipboard = cfg.registers;
extraPackages = mapAttrsToList (_: v: v.package) (
filterAttrs (_: v: v.enable && v.package != null) cfg.providers
);
};
};
}

1
modules/neovim/init/default.nix
View file

@ -2,6 +2,7 @@
imports = [
./autocmds.nix
./basic.nix
./clipboard.nix
./debug.nix
./diagnostics.nix
./highlight.nix

21
modules/neovim/init/diagnostics.nix
View file

@ -57,14 +57,21 @@
signs = mkOption {
type = diagnosticType;
default = false;
example = {
signs.text = {
"vim.diagnostic.severity.ERROR" = "󰅚 ";
"vim.diagnostic.severity.WARN" = "󰀪 ";
};
};
example = literalExpression ''
signs.text = lib.generators.mkLuaInline '''
{
[vim.diagnostic.severity.ERROR] = "󰅚 ",
[vim.diagnostic.severity.WARN] = "󰀪 ",
}
''';
'';
description = ''
Use signs for diagnostics. See {command}`:help diagnostic-signs`.
:::{.note}
The code presented in that example section uses Lua expressions as object keys which
only translate well if you use `lib.generators.mkLuaInline` as in the example.
:::
'';
};
@ -81,7 +88,7 @@
in {
options.vim = {
diagnostics = {
enable = mkEnableOption "diagostics module for Neovim";
enable = mkEnableOption "diagnostics module for Neovim";
config = mkOption {
type = diagnosticsSubmodule;
default = {};

65
modules/neovim/init/lsp.nix
View file

@ -5,7 +5,7 @@
}: let
inherit (builtins) filter;
inherit (lib.modules) mkIf mkMerge mkDefault;
inherit (lib.options) mkOption;
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.types) attrsOf;
inherit (lib.strings) concatLines;
inherit (lib.attrsets) mapAttrsToList attrNames filterAttrs;
@ -27,37 +27,48 @@
enabledServers = filterAttrs (_: u: u.enable) cfg.servers;
in {
options = {
vim.lsp.servers = mkOption {
type = attrsOf lspOptions;
default = {};
example = ''
{
"*" = {
root_markers = [".git"];
capabilities = {
textDocument = {
semanticTokens = {
multilineTokenSupport = true;
vim.lsp = {
enable = mkEnableOption ''
global LSP functionality for Neovim.
This option controls whether to enable LSP functionality within modules under
{option}`vim.languages`. You do not need to set this to `true` for language
servers defined in {option}`vim.lsp.servers` to take effect, since they are
enabled automatically.
'';
servers = mkOption {
type = attrsOf lspOptions;
default = {};
example = ''
{
"*" = {
root_markers = [".git"];
capabilities = {
textDocument = {
semanticTokens = {
multilineTokenSupport = true;
};
};
};
};
};
"clangd" = {
filetypes = ["c"];
};
}
'';
description = ''
LSP configurations that will be managed using `vim.lsp.config()` and
related utilities added in Neovim 0.11. LSPs defined here will be
added to the resulting {file}`init.lua` using `vim.lsp.config` and
enabled through `vim.lsp.enable` below the configuration table.
"clangd" = {
filetypes = ["c"];
};
}
'';
description = ''
LSP configurations that will be managed using `vim.lsp.config()` and related
utilities added in Neovim 0.11. LSPs defined here will be added to the
resulting {file}`init.lua` using `vim.lsp.config` and enabled through
`vim.lsp.enable()` API from Neovim below the configuration table.
You may review the generated configuration by running {command}`nvf-print-config`
in a shell. Please see {command}`:help lsp-config` for more details
on the underlying API.
'';
You may review the generated configuration by running {command}`nvf-print-config`
in a shell. Please see {command}`:help lsp-config` for more details
on the underlying API.
'';
};
};
};

2
modules/neovim/init/spellcheck.nix
View file

@ -94,6 +94,8 @@ in {
Enabling this option will unconditionally set
{option}`vim.spellcheck.enable` to true as vim-dirtytalk
depends on spellchecking having been set up.
Run {command}`:DirtytalkUpdate` on first use to download the spellfile.
:::
'';
};

2
modules/neovim/mappings/config.nix
View file

@ -3,7 +3,7 @@
lib,
...
}: let
inherit (lib.modules) mkIf mkMerge;
inherit (lib.modules) mkMerge;
inherit (lib.trivial) pipe;
inherit (lib.attrsets) mapAttrsToList;
inherit (lib.lists) flatten;

341
modules/plugins/assistant/avante/avante-nvim.nix Normal file
View file

@ -0,0 +1,341 @@
{lib, ...}: let
inherit (lib.options) mkOption mkEnableOption literalMD;
inherit (lib.types) int str enum nullOr attrs bool;
inherit (lib.nvim.types) mkPluginSetupOption;
in {
options.vim.assistant = {
avante-nvim = {
enable = mkEnableOption "complementary Neovim plugin for avante.nvim";
setupOpts = mkPluginSetupOption "avante-nvim" {
provider = mkOption {
type = nullOr str;
default = null;
description = "The provider used in Aider mode or in the planning phase of Cursor Planning Mode.";
};
providers = mkOption {
type = nullOr attrs;
default = null;
description = "Define settings for builtin and custom providers.";
example = literalMD ''
```nix
openai = {
endpoint = "https://api.openai.com/v1";
model = "gpt-4o"; # your desired model (or use gpt-4o, etc.)
timeout = 30000; # Timeout in milliseconds, increase this for reasoning models
extra_request_body = {
temperature = 0;
max_completion_tokens = 8192; # Increase this to include reasoning tokens (for reasoning models)
reasoning_effort = "medium"; # low|medium|high, only used for reasoning models
};
};
ollama = {
endpoint = "http://127.0.0.1:11434";
timeout = 30000; # Timeout in milliseconds
extra_request_body = {
options = {
temperature = 0.75;
num_ctx = 20480;
keep_alive = "5m";
};
};
};
groq = {
__inherited_from = "openai";
api_key_name = "GROQ_API_KEY";
endpoint = "https://api.groq.com/openai/v1/";
model = "llama-3.3-70b-versatile";
disable_tools = true;
extra_request_body = {
temperature = 1;
max_tokens = 32768; # remember to increase this value, otherwise it will stop generating halfway
};
};
```
'';
};
auto_suggestions_provider = mkOption {
type = str;
default = "claude";
description = ''
Since auto-suggestions are a high-frequency operation and therefore expensive,
currently designating it as `copilot` provider is dangerous because:
https://github.com/yetone/avante.nvim/issues/1048
Of course, you can reduce the request frequency by increasing `suggestion.debounce`.
'';
};
cursor_applying_provider = mkOption {
type = nullOr str;
default = null;
description = ''
The provider used in the applying phase of Cursor Planning Mode, defaults to `nil`,
Config.provider will be used as the provider for the applying phase when `nil`.
'';
};
dual_boost = {
enabled = mkEnableOption "dual_boost mode.";
first_provider = mkOption {
type = str;
default = "openai";
description = "The first provider to generate response.";
};
second_provider = mkOption {
type = str;
default = "claude";
description = "The second provider to generate response.";
};
prompt = mkOption {
type = str;
default = ''
Based on the two reference outputs below, generate a response that incorporates
elements from both but reflects your own judgment and unique perspective.
Do not provide any explanation, just give the response directly. Reference Output 1:
[{{provider1_output}}], Reference Output 2: [{{provider2_output}}'';
description = "The prompt to generate response based on the two reference outputs.";
};
timeout = mkOption {
type = int;
default = 60000;
description = "Timeout in milliseconds.";
};
};
behaviour = {
auto_suggestions =
mkEnableOption "auto suggestions.";
auto_set_highlight_group =
mkEnableOption "automatically set the highlight group for the current line."
// {
default = true;
};
auto_set_keymaps =
mkEnableOption "automatically set the keymap for the current line."
// {
default = true;
};
auto_apply_diff_after_generation =
mkEnableOption "automatically apply diff after LLM response.";
support_paste_from_clipboard = mkEnableOption ''
pasting image from clipboard.
This will be determined automatically based whether img-clip is available or not.
'';
minimize_diff =
mkEnableOption "remove unchanged lines when applying a code block."
// {
default = true;
};
enable_token_counting =
mkEnableOption "token counting."
// {
default = true;
};
enable_cursor_planning_mode =
mkEnableOption "Cursor Planning Mode.";
enable_claude_text_editor_tool_mode =
mkEnableOption "Claude Text Editor Tool Mode.";
};
mappings = {
diff = mkOption {
type = nullOr attrs;
default = null;
description = "Define or override the default keymaps for diff.";
};
suggestion = mkOption {
type = nullOr attrs;
default = null;
description = "Define or override the default keymaps for suggestion actions.";
};
jump = mkOption {
type = nullOr attrs;
default = null;
description = "Define or override the default keymaps for jump actions.";
};
submit = mkOption {
type = nullOr attrs;
default = null;
description = "Define or override the default keymaps for submit actions.";
};
cancel = mkOption {
type = nullOr attrs;
default = null;
description = "Define or override the default keymaps for cancel actions.";
};
sidebar = mkOption {
type = nullOr attrs;
default = null;
description = "Define or override the default keymaps for sidebar actions.";
};
};
hints.enabled =
mkEnableOption ""
// {
default = true;
description = ''
Whether to enable hints.
'';
};
windows = {
position = mkOption {
type = enum ["right" "left" "top" "bottom"];
default = "right";
description = "The position of the sidebar.";
};
wrap =
mkEnableOption ""
// {
default = true;
description = ''
similar to vim.o.wrap.
'';
};
width = mkOption {
type = int;
default = 30;
description = "Default % based on available width.";
};
sidebar_header = {
enabled = mkOption {
type = bool;
default = true;
description = "enable/disable the header.";
};
align = mkOption {
type = enum ["right" "center" "left"];
default = "center";
description = "Position of the title.";
};
rounded = mkOption {
type = bool;
default = true;
description = "Enable rounded sidebar header";
};
};
input = {
prefix = mkOption {
type = str;
default = "> ";
description = "The prefix used on the user input.";
};
height = mkOption {
type = int;
default = 8;
description = ''
Height of the input window in vertical layout.
'';
};
};
edit = {
border = mkOption {
type = str;
default = "rounded";
description = "The border type on the edit window.";
};
start_insert = mkOption {
type = bool;
default = true;
description = ''
Start insert mode when opening the edit window.
'';
};
};
ask = {
floating = mkOption {
type = bool;
default = false;
description = ''
Open the 'AvanteAsk' prompt in a floating window.
'';
};
start_insert = mkOption {
type = bool;
default = true;
description = ''
Start insert mode when opening the ask window.
'';
};
border = mkOption {
type = str;
default = "rounded";
description = "The border type on the ask window.";
};
focus_on_apply = mkOption {
type = enum ["ours" "theirs"];
default = "ours";
description = "Which diff to focus after applying.";
};
};
};
diff = {
autojump =
mkEnableOption ""
// {
default = true;
description = "Automatically jumps to the next change.";
};
override_timeoutlen = mkOption {
type = int;
default = 500;
example = -1;
description = ''
Override the 'timeoutlen' setting while hovering over a diff (see {command}`:help timeoutlen`).
Helps to avoid entering operator-pending mode with diff mappings starting with `c`.
Disable by setting to -1.
'';
};
};
suggestion = {
debounce = mkOption {
type = int;
default = 600;
description = "Suggestion debounce in milliseconds.";
};
throttle = mkOption {
type = int;
default = 600;
description = "Suggestion throttle in milliseconds.";
};
};
};
};
};
}

41
modules/plugins/assistant/avante/config.nix Normal file
View file

@ -0,0 +1,41 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.lists) optionals;
cfg = config.vim.assistant.avante-nvim;
in {
config = mkIf cfg.enable {
vim = {
startPlugins =
[
"nvim-treesitter"
"plenary-nvim"
"dressing-nvim"
"nui-nvim"
]
++ (optionals config.vim.mini.pick.enable ["mini-pick"])
++ (optionals config.vim.telescope.enable ["telescope"])
++ (optionals config.vim.autocomplete.nvim-cmp.enable ["nvim-cmp"])
++ (optionals config.vim.fzf-lua.enable ["fzf-lua"])
++ (optionals config.vim.visuals.nvim-web-devicons.enable ["nvim-web-devicons"])
++ (optionals config.vim.utility.images.img-clip.enable ["img-clip"]);
lazy.plugins = {
avante-nvim = {
package = "avante-nvim";
setupModule = "avante";
inherit (cfg) setupOpts;
event = ["DeferredUIEnter"];
};
};
treesitter.enable = true;
languages.markdown.extensions.render-markdown-nvim.setupOpts.file_types = lib.mkAfter ["Avante"];
};
};
}

6
modules/plugins/assistant/avante/default.nix Normal file
View file

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

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

@ -21,7 +21,17 @@ in {
};
};
treesitter.enable = true;
treesitter = {
enable = true;
# Codecompanion depends on the YAML grammar being added. Below is
# an easy way of adding an user-configurable grammar package exposed
# by the YAML language module *without* enabling the whole YAML language
# module. The package is defined even when the module is disabled.
grammars = [
config.vim.languages.yaml.treesitter.package
];
};
autocomplete.nvim-cmp = {
sources = {codecompanion-nvim = "[codecompanion]";};

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

@ -5,7 +5,6 @@
}: let
inherit (builtins) toJSON;
inherit (lib.modules) mkIf;
inherit (lib.strings) optionalString;
cfg = config.vim.assistant.copilot;

2
modules/plugins/assistant/copilot/copilot.nix
View file

@ -93,7 +93,7 @@ in {
accept = mkOption {
type = nullOr str;
default = "<M-l>";
description = "Accept suggetion";
description = "Accept suggestion";
};
acceptWord = mkOption {

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

@ -3,5 +3,7 @@
./chatgpt
./copilot
./codecompanion
./supermaven-nvim
./avante
];
}

17
modules/plugins/assistant/supermaven-nvim/config.nix Normal file
View file

@ -0,0 +1,17 @@
{
config,
lib,
...
}: let
cfg = config.vim.assistant.supermaven-nvim;
in {
config = lib.mkIf cfg.enable {
vim.lazy.plugins = {
supermaven-nvim = {
package = "supermaven-nvim";
setupModule = "supermaven-nvim";
inherit (cfg) setupOpts;
};
};
};
}

6
modules/plugins/assistant/supermaven-nvim/default.nix Normal file
View file

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

94
modules/plugins/assistant/supermaven-nvim/supermaven-nvim.nix Normal file
View file

@ -0,0 +1,94 @@
{lib, ...}: let
inherit
(lib.types)
nullOr
str
bool
attrsOf
ints
enum
;
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption luaInline;
in {
options.vim.assistant.supermaven-nvim = {
enable = mkEnableOption "Supermaven AI assistant";
setupOpts = mkPluginSetupOption "Supermaven" {
keymaps = {
accept_suggestion = mkOption {
type = nullOr str;
default = null;
example = "<Tab>";
description = "The key to accept a suggestion";
};
clear_suggestion = mkOption {
type = nullOr str;
default = null;
example = "<C-]>";
description = "The key to clear a suggestion";
};
accept_word = mkOption {
type = nullOr str;
default = null;
example = "<C-j>";
description = "The key to accept a word";
};
};
ignore_file = mkOption {
type = nullOr (attrsOf bool);
default = null;
example = {
markdown = true;
};
description = "List of fileto ignore";
};
color = {
suggestion_color = mkOption {
type = nullOr str;
default = null;
example = "#ffffff";
description = "The hex color of the suggestion";
};
cterm = mkOption {
type = nullOr ints.u8;
default = null;
example = 244;
description = "The cterm color of the suggestion";
};
};
log_level = mkOption {
type = nullOr (enum [
"off"
"trace"
"debug"
"info"
"warn"
"error"
]);
default = null;
example = "info";
description = "The log level. Set to `\"off\"` to disable completely";
};
disable_inline_completion = mkOption {
type = nullOr bool;
default = null;
description = "Disable inline completion for use with cmp";
};
disable_keymaps = mkOption {
type = nullOr bool;
default = null;
description = "Disable built-in keymaps for more manual control";
};
condition = mkOption {
type = nullOr luaInline;
default = null;
description = ''
Condition function to check for stopping supermaven.
A returned `true` means to stop supermaven
'';
};
};
};
}

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

@ -1,7 +1,6 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption mkOption literalMD;
inherit (lib.types) bool listOf str either attrsOf submodule enum anything int nullOr;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.types) mkPluginSetupOption luaInline pluginType;
inherit (lib.nvim.binds) mkMappingOption;
inherit (lib.nvim.config) mkBool;
@ -10,7 +9,7 @@
freeformType = attrsOf (listOf (either str luaInline));
options = {
preset = mkOption {
type = enum ["default" "none" "super-tab" "enter"];
type = enum ["inherit" "default" "none" "super-tab" "enter" "cmdline"];
default = "none";
description = "keymap presets";
};
@ -48,7 +47,7 @@ in {
cmdline = {
sources = mkOption {
type = nullOr (listOf str);
default = [];
default = null;
description = "List of sources to enable for cmdline. Null means use default source list.";
};

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

@ -5,11 +5,12 @@
}: let
inherit (lib.modules) mkIf;
inherit (lib.strings) optionalString;
inherit (lib.attrsets) optionalAttrs;
inherit (lib.generators) mkLuaInline;
inherit (lib.attrsets) attrValues filterAttrs mapAttrsToList;
inherit (lib.lists) map optional elem;
inherit (lib.lists) map optional optionals elem;
inherit (lib.nvim.lua) toLuaObject;
inherit (builtins) concatStringsSep typeOf tryEval attrNames mapAttrs;
inherit (builtins) concatStringsSep typeOf tryEval attrNames mapAttrs removeAttrs;
cfg = config.vim.autocomplete.blink-cmp;
cmpCfg = config.vim.autocomplete.nvim-cmp;
@ -55,7 +56,7 @@ in {
after =
# lua
''
${optionalString config.vim.lazy.enable
${optionalString (config.vim.lazy.enable && cmpCfg.enable)
(concatStringsSep "\n" (map
(package: "require('lz.n').trigger_load(${toLuaObject (getPluginName package)})")
cmpCfg.sourcePlugins))}
@ -66,7 +67,10 @@ in {
autocomplete = {
enableSharedCmpSources = true;
blink-cmp.setupOpts = {
sources = {
sources = let
# We do not want nvim-cmp compat sources overriding built-in blink sources
filteredCmpSources = removeAttrs cmpCfg.sources blinkBuiltins;
in {
default =
[
"lsp"
@ -74,14 +78,16 @@ in {
"snippets"
"buffer"
]
++ (attrNames cmpCfg.sources)
++ optionals cmpCfg.enable (attrNames filteredCmpSources)
++ (attrNames enabledBlinkSources);
providers =
mapAttrs (name: _: {
inherit name;
module = "blink.compat.source";
})
cmpCfg.sources
optionalAttrs cmpCfg.enable (
mapAttrs (name: _: {
inherit name;
module = "blink.compat.source";
})
filteredCmpSources
)
// (mapAttrs (name: definition: {
inherit name;
inherit (definition) module;
@ -122,6 +128,21 @@ in {
"fallback"
];
};
# cmdline is not enabled by default, we're just providing keymaps in
# case the user enables them
cmdline.keymap = {
${mappings.complete} = ["show" "fallback"];
${mappings.close} = ["hide" "fallback"];
${mappings.scrollDocsUp} = ["scroll_documentation_up" "fallback"];
${mappings.scrollDocsDown} = ["scroll_documentation_down" "fallback"];
# NOTE: mappings.confirm is skipped because our default, <CR> would
# lead to accidental triggers of blink.accept instead of executing
# the cmd
${mappings.next} = ["select_next" "show" "fallback"];
${mappings.previous} = ["select_prev" "fallback"];
};
};
};
};

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

@ -3,11 +3,10 @@
config,
...
}: let
inherit (lib.modules) mkIf mkMerge;
inherit (lib.modules) mkIf;
inherit (lib.strings) optionalString;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (builtins) attrNames typeOf tryEval concatStringsSep;
borders = config.vim.ui.borders.plugins.nvim-cmp;

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

@ -3,7 +3,7 @@
config,
...
}: let
inherit (lib.options) mkEnableOption mkOption literalExpression literalMD;
inherit (lib.options) mkEnableOption mkOption literalMD;
inherit (lib.types) str attrsOf nullOr either listOf;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.binds) mkMappingOption;

1
modules/plugins/dashboard/alpha/config.nix
View file

@ -4,7 +4,6 @@
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.lua) toLuaObject;
cfg = config.vim.dashboard.alpha;

86
modules/plugins/dashboard/startify/startify.nix
View file

@ -3,46 +3,47 @@
inherit (lib.types) listOf attrs bool enum str oneOf int;
in {
options.vim.dashboard.startify = {
enable = mkEnableOption "dashboard via vim-startify";
enable = mkEnableOption "fancy start screen for Vim [vim-startify]";
bookmarks = mkOption {
default = [];
description = ''List of book marks to disaply on start page'';
type = listOf attrs;
default = [];
example = {"c" = "~/.vimrc";};
description = "List of book marks to display on start page";
};
changeToDir = mkOption {
default = true;
description = "Should vim change to the directory of the file you open";
type = bool;
default = true;
description = "Whether Vim should change to the directory of the file you open";
};
changeToVCRoot = mkOption {
default = false;
description = "Should vim change to the version control root when opening a file";
type = bool;
default = false;
description = "Whether Vim should change to the version control root when opening a file";
};
changeDirCmd = mkOption {
default = "lcd";
description = "Command to change the current window with. Can be cd, lcd or tcd";
type = enum ["cd" "lcd" "tcd"];
default = "lcd";
description = "Command to change the current window with.";
};
customHeader = mkOption {
type = listOf str;
default = [];
description = "Text to place in the header";
type = listOf str;
};
customFooter = mkOption {
type = listOf str;
default = [];
description = "Text to place in the footer";
type = listOf str;
};
lists = mkOption {
type = listOf attrs;
default = [
{
type = "files";
@ -66,121 +67,136 @@ in {
}
];
description = "Specify the lists and in what order they are displayed on startify.";
type = listOf attrs;
};
skipList = mkOption {
type = listOf str;
default = [];
description = "List of regex patterns to exclude from MRU lists";
type = listOf str;
};
updateOldFiles = mkOption {
type = bool;
default = false;
description = "Set if you want startify to always update and not just when neovim closes";
type = bool;
};
sessionAutoload = mkOption {
default = false;
description = "Make startify auto load Session.vim files from the current directory";
type = bool;
default = false;
description = "Make vim-startify auto load Session.vim files from the current directory";
};
commands = mkOption {
type = listOf (oneOf [str attrs (listOf str)]);
default = [];
description = "Commands that are presented to the user on startify page";
type = listOf (oneOf [str attrs (listOf str)]);
};
filesNumber = mkOption {
type = int;
default = 10;
description = "How many files to list";
type = int;
};
customIndices = mkOption {
type = listOf str;
default = [];
description = "Specify a list of default characters to use instead of numbers";
type = listOf str;
};
disableOnStartup = mkOption {
default = false;
description = "Prevent startify from opening on startup but can be called with :Startify";
type = bool;
default = false;
description = ''
Whether vim-startify should be disabled on startup.
This will prevent startify from opening on startup, but it can still
be called with `:Startify`
'';
};
unsafe = mkOption {
default = false;
description = "Turns on unsafe mode for Startify. Stops resolving links, checking files are readable and filtering bookmark list";
type = bool;
default = false;
description = ''
Whether to turn on unsafe mode for Startify.
While enabld, vim-startify will stops resolving links, checking files
are readable and filtering bookmark list
'';
};
paddingLeft = mkOption {
type = int;
default = 3;
description = "Number of spaces used for left padding.";
type = int;
};
useEnv = mkOption {
type = bool;
default = false;
description = "Show environment variables in path if name is shorter than value";
type = bool;
};
sessionBeforeSave = mkOption {
type = listOf str;
default = [];
description = "Commands to run before saving a session";
type = listOf str;
};
sessionPersistence = mkOption {
type = bool;
default = false;
description = "Persist session before leaving vim or switching session";
type = bool;
};
sessionDeleteBuffers = mkOption {
type = bool;
default = true;
description = "Delete all buffers when loading or closing a session";
type = bool;
};
sessionDir = mkOption {
type = str;
default = "~/.vim/session";
description = "Directory to save and load sessions from";
type = str;
};
skipListServer = mkOption {
type = listOf str;
default = [];
description = "List of vim servers to not load startify for";
type = listOf str;
};
sessionRemoveLines = mkOption {
type = listOf str;
default = [];
description = "Patterns to remove from session files";
type = listOf str;
};
sessionSavevars = mkOption {
type = listOf str;
default = [];
description = "List of variables to save into a session file.";
type = listOf str;
};
sessionSavecmds = mkOption {
type = listOf str;
default = [];
description = "List of commands to run when loading a session.";
type = listOf str;
};
sessionSort = mkOption {
default = false;
description = "Set if you want items sorted by date rather than alphabetically";
type = bool;
default = false;
example = true;
description = ''
While true, sessions will be sorted by date rather than alphabetically.
'';
};
};
}

41
modules/plugins/filetree/nvimtree/nvimtree.nix
View file

@ -683,15 +683,48 @@ in {
};
git_placement = mkOption {
type = enum ["before" "after" "signcolumn"];
description = "Place where the git icons will be rendered. `signcolumn` requires `view.signcolumn` to be enabled.";
type = enum ["before" "after" "signcolumn" "right_align"];
default = "before";
description = ''
Place where the git icons will be rendered.
`signcolumn` requires `view.signcolumn` to be enabled.
'';
};
modified_placement = mkOption {
type = enum ["before" "after" "signcolumn"];
description = "Place where the modified icons will be rendered. `signcolumn` requires `view.signcolumn` to be enabled.";
type = enum ["before" "after" "signcolumn" "right_align"];
default = "after";
description = ''
Place where the modified icons will be rendered.
`signcolumn` requires `view.signcolumn` to be enabled.
'';
};
hidden_placement = mkOption {
type = enum ["before" "after" "signcolumn" "right_align"];
default = "after";
description = ''
Place where the hidden icons will be rendered.
`signcolumn` requires `view.signcolumn` to be enabled.
'';
};
diagnostics_placement = mkOption {
type = enum ["before" "after" "signcolumn" "right_align"];
default = "after";
description = ''
Place where the diagnostics icons will be rendered.
`signcolumn` requires `view.signcolumn` to be enabled.
'';
};
bookmarks_placement = mkOption {
type = enum ["before" "after" "signcolumn" "right_align"];
default = "after";
description = ''
Place where the bookmark icons will be rendered.
`signcolumn` requires `view.signcolumn` to be enabled.
'';
};
padding = mkOption {

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

@ -1,12 +1,9 @@
{
pkgs,
lib,
...
}: let
inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.types) attrs enum nullOr;
inherit (lib.nvim.types) mkPluginSetupOption;
inherit (lib.nvim.lua) mkLuaInline;
{lib, ...}: let
inherit (lib.generators) mkLuaInline;
inherit (lib.options) mkOption mkEnableOption literalMD;
inherit (lib.types) attrs either nullOr;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.types) luaInline mkPluginSetupOption;
in {
options.vim.formatter.conform-nvim = {
enable = mkEnableOption "lightweight yet powerful formatter plugin for Neovim [conform-nvim]";
@ -31,26 +28,46 @@ in {
};
format_on_save = mkOption {
type = nullOr attrs;
default = {
lsp_format = "fallback";
timeout_ms = 500;
};
type = nullOr (either attrs luaInline);
default = mkLuaInline ''
function()
if not vim.g.formatsave or vim.b.disableFormatSave then
return
else
return {lsp_format = "fallback", timeout_ms = 500}
end
end
'';
defaultText = literalMD ''
enabled by default, and respects {option}`vim.lsp.formatOnSave` and
{option}`vim.lsp.mappings.toggleFormatSave`
'';
description = ''
Table that will be passed to `conform.format()`. If this
is set, Conform will run the formatter on save.
Attribute set or Lua function that will be passed to
`conform.format()`. If this is set, Conform will run the formatter
on save.
'';
};
format_after_save = mkOption {
type = nullOr attrs;
default = {lsp_format = "fallback";};
description = ''
Table that will be passed to `conform.format()`. If this
is set, Conform will run the formatter asynchronously after
save.
'';
};
format_after_save = let
defaultFormatAfterSaveOpts = {lsp_format = "fallback";};
in
mkOption {
type = nullOr (either attrs luaInline);
default = mkLuaInline ''
function()
if not vim.g.formatsave or vim.b.disableFormatSave then
return
else
return ${toLuaObject defaultFormatAfterSaveOpts}
end
end
'';
description = ''
Table or function(luainline) that will be passed to `conform.format()`. If this
is set, Conform will run the formatter asynchronously after save.
'';
};
};
};
}

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

@ -3,9 +3,11 @@
in {
imports = [
./gitsigns
./hunk-nvim
./vim-fugitive
./git-conflict
./gitlinker-nvim
./neogit
];
options.vim.git = {
@ -13,7 +15,9 @@ in {
git integration suite.
Enabling this option will enable the following plugins:
* gitsigns
* hunk-nvim
* vim-fugitive
* git-conflict
* gitlinker-nvim

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

@ -69,7 +69,7 @@ in {
};
binds.whichKey.register = pushDownDefault {
"<leader>g" = "+Gitsigns";
"<leader>h" = "+Gitsigns";
};
pluginRC.gitsigns = entryAnywhere ''
@ -81,9 +81,11 @@ in {
(mkIf cfg.codeActions.enable {
vim.lsp.null-ls = {
enable = true;
setupOpts.sources.gitsigns-ca = mkLuaInline ''
require("null-ls").builtins.code_actions.gitsigns
'';
setupOpts.sources = [
(mkLuaInline ''
require("null-ls").builtins.code_actions.gitsigns
'')
];
};
})
]);

27
modules/plugins/git/hunk-nvim/config.nix Normal file
View file

@ -0,0 +1,27 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
cfg = config.vim.git.hunk-nvim;
in {
config = mkIf cfg.enable {
vim = {
startPlugins = [
# dependencies
"nui-nvim" # ui library
"nvim-web-devicons" # glyphs
];
lazy.plugins = {
"hunk-nvim" = {
package = "hunk-nvim";
setupModule = "hunk";
inherit (cfg) setupOpts;
};
};
};
};
}

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

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

13
modules/plugins/git/hunk-nvim/hunk-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.hunk-nvim = {
enable = mkEnableOption "tool for splitting diffs in Neovim [hunk-nvim]" // {default = config.vim.git.enable;};
setupOpts = mkPluginSetupOption "hunk-nvim" {};
};
}

39
modules/plugins/git/neogit/config.nix Normal file
View file

@ -0,0 +1,39 @@
{
options,
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.binds) pushDownDefault mkKeymap;
cfg = config.vim.git.neogit;
keys = cfg.mappings;
inherit (options.vim.git.neogit) mappings;
in {
config = mkIf cfg.enable {
vim = {
startPlugins = ["plenary-nvim"];
lazy.plugins.neogit = {
package = "neogit";
setupModule = "neogit";
inherit (cfg) setupOpts;
cmd = ["Neogit"];
keys = [
(mkKeymap "n" keys.open "<Cmd>Neogit<CR>" {desc = mappings.open.description;})
(mkKeymap "n" keys.commit "<Cmd>Neogit commit<CR>" {desc = mappings.commit.description;})
(mkKeymap "n" keys.pull "<Cmd>Neogit pull<CR>" {desc = mappings.pull.description;})
(mkKeymap "n" keys.push "<Cmd>Neogit push<CR>" {desc = mappings.push.description;})
];
};
binds.whichKey.register = pushDownDefault {
"<leader>g" = "+Git";
};
};
};
}

6
modules/plugins/git/neogit/default.nix Normal file
View file

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

17
modules/plugins/git/neogit/neogit.nix Normal file
View file

@ -0,0 +1,17 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.binds) mkMappingOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {
options.vim.git.neogit = {
enable = mkEnableOption "An Interactive and powerful Git interface [Neogit]";
setupOpts = mkPluginSetupOption "neogit" {};
mappings = {
open = mkMappingOption "Git Status [Neogit]" "<leader>gs";
commit = mkMappingOption "Git Commit [Neogit]" "<leader>gc";
pull = mkMappingOption "Git pull [Neogit]" "<leader>gp";
push = mkMappingOption "Git push [Neogit]" "<leader>gP";
};
};
}

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

@ -20,7 +20,7 @@ in {
};
lsp = {
enable = mkEnableOption "Assembly LSP support (asm-lsp)" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Assembly LSP support (asm-lsp)" // {default = config.vim.lsp.enable;};
package = mkOption {
type = package;

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

@ -10,7 +10,6 @@
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.types) mkGrammarOption diagnostics;
@ -38,7 +37,7 @@
defaultFormat = "prettier";
formats = {
prettier = {
package = pkgs.nodePackages.prettier;
package = pkgs.prettier;
};
prettierd = {
@ -81,7 +80,7 @@ in {
};
lsp = {
enable = mkEnableOption "Astro LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Astro LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
type = enum (attrNames servers);

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

@ -56,7 +56,7 @@ in {
};
lsp = {
enable = mkEnableOption "Enable Bash LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Enable Bash LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Bash LSP server to use";
@ -66,7 +66,7 @@ in {
package = mkOption {
description = "bash-language-server package, or the command to run as a list of strings";
example = literalExpression ''[lib.getExe pkgs.nodePackages.bash-language-server "start"]'';
example = literalExpression ''[lib.getExe pkgs.bash-language-server "start"]'';
type = either package (listOf str);
default = pkgs.bash-language-server;
};

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

@ -98,7 +98,7 @@ in {
};
lsp = {
enable = mkEnableOption "clang LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "clang LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "The clang LSP server to use";

56
modules/plugins/languages/clojure.nix Normal file
View file

@ -0,0 +1,56 @@
{
config,
pkgs,
lib,
...
}: let
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.nvim.lua) expToLua;
cfg = config.vim.languages.clojure;
in {
options.vim.languages.clojure = {
enable = mkEnableOption "Clojure language support";
treesitter = {
enable = mkEnableOption "Clojure treesitter" // {default = config.vim.languages.enableTreesitter;};
package = mkGrammarOption pkgs "clojure";
};
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";
};
};
};
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}"}''
};
}
'';
})
(mkIf cfg.treesitter.enable {
vim.treesitter.enable = true;
vim.treesitter.grammars = [cfg.treesitter.package];
})
]);
}

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

@ -91,7 +91,7 @@ in {
};
lsp = {
enable = mkEnableOption "C# LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "C# LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "C# LSP server to use";
type = enum (attrNames servers);

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

@ -42,7 +42,7 @@
defaultFormat = "prettier";
formats = {
prettier = {
package = pkgs.nodePackages.prettier;
package = pkgs.prettier;
};
prettierd = {
@ -80,7 +80,7 @@ in {
};
lsp = {
enable = mkEnableOption "CSS LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "CSS LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "CSS LSP server to use";

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

@ -21,7 +21,7 @@ in {
};
lsp = {
enable = mkEnableOption "CUE LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "CUE LSP support" // {default = config.vim.lsp.enable;};
package = mkOption {
type = package;

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

@ -77,7 +77,7 @@ in {
flutter-tools = {
enable = mkOption {
type = bool;
default = config.vim.languages.enableLSP;
default = config.vim.lsp.enable;
description = "Enable flutter-tools for flutter support";
};
@ -143,8 +143,6 @@ in {
})
(mkIf ftcfg.enable {
lsp.enable = true;
startPlugins = [
(
if ftcfg.enableNoResolvePatch

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

@ -1,8 +1,5 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.modules) mkRenamedOptionModule;
inherit (lib.nvim.languages) mkEnable;
in {
imports = [
@ -12,6 +9,7 @@ in {
./cue.nix
./dart.nix
./clang.nix
./clojure.nix
./css.nix
./elixir.nix
./emmet.nix
@ -49,13 +47,12 @@ in {
./wgsl.nix
./yaml.nix
./ruby.nix
# This is now a hard deprecation.
(mkRenamedOptionModule ["vim" "languages" "enableLSP"] ["vim" "lsp" "enable"])
];
options.vim.languages = {
# LSPs are now built into Neovim, and we should enable them by default
# if `vim.lsp.enable` is true.
enableLSP = mkEnable "LSP" // {default = config.vim.lsp.enable;};
# Those are still managed by plugins, and should be enabled here.
enableDAP = mkEnable "Debug Adapter";
enableTreesitter = mkEnable "Treesitter";

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

@ -53,7 +53,7 @@ in {
};
lsp = {
enable = mkEnableOption "Elixir LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Elixir LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Elixir LSP server to use";

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

@ -51,7 +51,7 @@ in {
};
lsp = {
enable = mkEnableOption "F# LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "F# LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
type = enum (attrNames servers);
default = defaultServer;

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

@ -41,7 +41,7 @@ in {
};
lsp = {
enable = mkEnableOption "Gleam LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Gleam LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
type = enum (attrNames servers);

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

@ -67,7 +67,7 @@ in {
};
lsp = {
enable = mkEnableOption "Go LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Go LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Go LSP server to use";

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

@ -25,7 +25,7 @@ in {
};
lsp = {
enable = mkEnableOption "LSP support for Haskell" // {default = config.vim.languages.enableLSP;};
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" ]'';

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

@ -43,7 +43,7 @@ in {
};
lsp = {
enable = mkEnableOption "HCL LSP support (terraform-ls)" // {default = config.vim.languages.enableLSP;};
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;

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

@ -54,7 +54,7 @@ in {
};
lsp = {
enable = mkEnableOption "Helm LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Helm LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Helm LSP server to use";

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

@ -23,7 +23,7 @@ in {
};
lsp = {
enable = mkEnableOption "Java LSP support (java-language-server)" // {default = config.vim.languages.enableLSP;};
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"]'';

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

@ -78,7 +78,7 @@ in {
lsp = {
enable = mkOption {
type = bool;
default = config.vim.languages.enableLSP;
default = config.vim.lsp.enable;
description = ''
Whether to enable Julia LSP support.

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

@ -30,7 +30,7 @@ in {
};
lsp = {
enable = mkEnableOption "Kotlin LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Kotlin LSP support" // {default = config.vim.lsp.enable;};
package = mkOption {
description = "kotlin_language_server package with Kotlin runtime";

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

@ -43,7 +43,7 @@ in {
};
lsp = {
enable = mkEnableOption "Lua LSP support via LuaLS" // {default = config.vim.languages.enableLSP;};
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";

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

@ -67,7 +67,7 @@ in {
};
lsp = {
enable = mkEnableOption "Enable Markdown LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Enable Markdown LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
type = enum (attrNames servers);
@ -130,6 +130,18 @@ in {
};
};
};
markview-nvim = {
enable =
mkEnableOption ""
// {
description = ''
[markview.nvim]: https://github.com/OXY2DEV/markview.nvim
[markview.nvim] - a hackable markdown, Typst, latex, html(inline) & YAML previewer
'';
};
setupOpts = mkPluginSetupOption "markview-nvim" {};
};
};
extraDiagnostics = {
@ -175,6 +187,13 @@ in {
'';
})
(mkIf cfg.extensions.markview-nvim.enable {
vim.startPlugins = ["markview-nvim"];
vim.pluginRC.markview-nvim = entryAnywhere ''
require("markview").setup(${toLuaObject cfg.extensions.markview-nvim.setupOpts})
'';
})
(mkIf cfg.extraDiagnostics.enable {
vim.diagnostics.nvim-lint = {
enable = true;

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

@ -6,7 +6,6 @@
}: 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;
@ -54,7 +53,7 @@ in {
};
lsp = {
enable = mkEnableOption "Nim LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Nim LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Nim LSP server to use";
type = str;

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

@ -60,7 +60,17 @@
'';
};
nixd = {
nixd = let
settings.nixd = {
inherit (cfg.lsp) options;
formatting.command =
if !cfg.format.enable
then null
else if cfg.format.type == "alejandra"
then ["${cfg.format.package}/bin/alejandra" "--quiet"]
else ["${cfg.format.package}/bin/nixfmt"];
};
in {
package = pkgs.nixd;
internalFormatter = true;
lspConfig = ''
@ -72,25 +82,7 @@
else noFormat
},
cmd = ${packageToCmd cfg.lsp.package "nixd"},
${optionalString cfg.format.enable ''
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},
},
},
''}
settings = ${toLuaObject settings},
}
'';
};
@ -143,7 +135,7 @@ in {
};
lsp = {
enable = mkEnableOption "Nix LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Nix LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Nix LSP server to use";
type = enum (attrNames servers);

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

@ -40,7 +40,7 @@ in {
};
lsp = {
enable = mkEnableOption "Nu LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Nu LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
type = str;
default = defaultServer;

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

@ -49,7 +49,7 @@ in {
};
lsp = {
enable = mkEnableOption "OCaml LSP support (ocaml-lsp)" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "OCaml LSP support (ocaml-lsp)" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "OCaml LSP server to user";
type = enum (attrNames servers);

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

@ -41,7 +41,7 @@ in {
};
lsp = {
enable = mkEnableOption "Odin LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Odin LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
type = enum (attrNames servers);

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

@ -95,7 +95,7 @@ in {
};
lsp = {
enable = mkEnableOption "PHP LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "PHP LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "PHP LSP server to use";

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

@ -169,7 +169,7 @@ in {
};
lsp = {
enable = mkEnableOption "Python LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Python LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Python LSP server to use";

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

@ -79,7 +79,7 @@ in {
};
lsp = {
enable = mkEnableOption "R LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "R LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "R LSP server to use";

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

@ -9,6 +9,8 @@
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.nvim.lua) expToLua;
inherit (lib.lists) isList;
inherit (lib.types) either listOf package str enum;
cfg = config.vim.languages.ruby;
@ -24,7 +26,25 @@
flags = {
debounce_text_changes = 150,
},
cmd = { "${pkgs.solargraph}/bin/solargraph", "stdio" }
cmd = ${
if isList cfg.lsp.package
then expToLua cfg.lsp.package
else ''{ "${cfg.lsp.package}/bin/solargraph", "stdio" }''
}
}
'';
};
rubylsp = {
package = pkgs.ruby-lsp;
lspConfig = ''
lspconfig.ruby_lsp.setup {
capabilities = capabilities,
on_attach = default_on_attach,
cmd = ${
if isList cfg.lsp.package
then expToLua cfg.lsp.package
else ''{ "${cfg.lsp.package}/bin/ruby-lsp" }''
}
}
'';
};
@ -57,7 +77,7 @@ in {
};
lsp = {
enable = mkEnableOption "Ruby LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Ruby LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
type = enum (attrNames servers);

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

@ -7,7 +7,7 @@
inherit (builtins) attrNames;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.options) mkOption mkEnableOption literalMD;
inherit (lib.strings) optionalString;
inherit (lib.trivial) boolToString;
inherit (lib.lists) isList;
@ -43,7 +43,7 @@ in {
};
lsp = {
enable = mkEnableOption "Rust LSP support (rust-analyzer with extra tools)" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Rust LSP support (rust-analyzer with extra tools)" // {default = config.vim.lsp.enable;};
package = mkOption {
description = "rust-analyzer package, or the command to run as a list of strings";
example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
@ -68,7 +68,14 @@ in {
};
format = {
enable = mkEnableOption "Rust formatting" // {default = config.vim.languages.enableFormat;};
enable =
mkEnableOption "Rust formatting"
// {
default = !cfg.lsp.enable && config.vim.languages.enableFormat;
defaultText = literalMD ''
Disabled if Rust LSP is enabled, otherwise follows {option}`vim.languages.enableFormat`
'';
};
type = mkOption {
description = "Rust formatter to use";

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

@ -33,7 +33,7 @@ in {
};
lsp = {
enable = mkEnableOption "Scala LSP support (metals)" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Scala LSP support (metals)" // {default = config.vim.lsp.enable;};
package = mkPackageOption pkgs "metals" {
default = ["metals"];
};

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

@ -79,7 +79,7 @@ in {
};
lsp = {
enable = mkEnableOption "SQL LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "SQL LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "SQL LSP server to use";

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

@ -9,7 +9,6 @@
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.types) mkGrammarOption diagnostics;
@ -19,7 +18,7 @@
defaultServer = "svelte";
servers = {
svelte = {
package = pkgs.nodePackages.svelte-language-server;
package = pkgs.svelte-language-server;
lspConfig = ''
lspconfig.svelte.setup {
capabilities = capabilities;
@ -38,7 +37,7 @@
defaultFormat = "prettier";
formats = {
prettier = {
package = pkgs.nodePackages.prettier;
package = pkgs.prettier;
};
biome = {
@ -77,7 +76,7 @@ in {
};
lsp = {
enable = mkEnableOption "Svelte LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Svelte LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Svelte LSP server to use";

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

@ -35,7 +35,7 @@ in {
enable = mkEnableOption "Tailwindcss language support";
lsp = {
enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Tailwindcss LSP server to use";

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

@ -20,7 +20,7 @@ in {
};
lsp = {
enable = mkEnableOption "Terraform LSP support (terraform-ls)" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Terraform LSP support (terraform-ls)" // {default = config.vim.lsp.enable;};
package = mkOption {
description = "terraform-ls package";

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

@ -9,7 +9,6 @@
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;
@ -76,7 +75,7 @@
defaultFormat = "prettier";
formats = {
prettier = {
package = pkgs.nodePackages.prettier;
package = pkgs.prettier;
};
prettierd = {
@ -101,6 +100,7 @@
"eslint.config.js"
"eslint.config.mjs"
".eslintrc"
".eslintrc.cjs"
".eslintrc.json"
".eslintrc.js"
".eslintrc.yml"
@ -120,7 +120,7 @@ in {
};
lsp = {
enable = mkEnableOption "Typescript/Javascript LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Typescript/Javascript LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Typescript/Javascript LSP server to use";

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

@ -7,9 +7,10 @@
inherit (lib.options) mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge;
inherit (lib.lists) isList;
inherit (lib.types) nullOr enum either attrsOf listOf package str;
inherit (lib.types) nullOr enum either attrsOf listOf package str bool int;
inherit (lib.attrsets) attrNames;
inherit (lib.meta) getExe;
inherit (lib.nvim.binds) mkMappingOption mkKeymap;
inherit (lib.nvim.lua) expToLua toLuaObject;
inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption;
inherit (lib.nvim.dag) entryAnywhere;
@ -76,7 +77,7 @@ in {
};
lsp = {
enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Typst LSP server to use";
@ -150,6 +151,57 @@ in {
};
};
};
typst-concealer = {
enable = mkEnableOption ''
[typst-concealer]: https://github.com/PartyWumpus/typst-concealer
Inline typst preview for Neovim via [typst-concealer]
'';
mappings = {
toggleConcealing = mkMappingOption "Enable typst-concealer in buffer" "<leader>TT";
};
setupOpts = mkPluginSetupOption "typst-concealer" {
do_diagnostics = mkOption {
type = nullOr bool;
default = !cfg.lsp.enable;
description = "Should typst-concealer provide diagnostics on error?";
};
color = mkOption {
type = nullOr str;
default = null;
example = "rgb(\"#f012be\")";
description = "What color should typst-concealer render text/stroke with? (only applies when styling_type is 'colorscheme')";
};
enabled_by_default = mkOption {
type = nullOr bool;
default = null;
description = "Should typst-concealer conceal newly opened buffers by default?";
};
styling_type = mkOption {
type = nullOr (enum ["simple" "none" "colorscheme"]);
default = null;
description = "What kind of styling should typst-concealer apply to your typst?";
};
ppi = mkOption {
type = nullOr int;
default = null;
description = "What PPI should typst render at. Plugin default is 300, typst's normal default is 144.";
};
typst_location = mkOption {
type = str;
default = getExe pkgs.typst;
description = "Where should typst-concealer look for your typst binary?";
example = ''lib.getExe pkgs.typst'';
};
conceal_in_normal = mkOption {
type = nullOr bool;
default = null;
description = "Should typst-concealer still conceal when the normal mode cursor goes over a line.";
};
};
};
};
};
config = mkIf cfg.enable (mkMerge [
@ -180,5 +232,18 @@ in {
require("typst-preview").setup(${toLuaObject cfg.extensions.typst-preview-nvim.setupOpts})
'';
})
(mkIf cfg.extensions.typst-concealer.enable {
vim.lazy.plugins.typst-concealer = {
event = "BufRead *.typ";
package = "typst-concealer";
setupModule = "typst-concealer";
setupOpts = cfg.extensions.typst-concealer.setupOpts;
keys = [
(mkKeymap "n" cfg.extensions.typst-concealer.mappings.toggleConcealing "<cmd>lua require('typst-concealer').toggle_buf()<CR>" {desc = "Toggle typst-concealer in buffer";})
];
};
})
]);
}

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

@ -50,7 +50,7 @@ in {
};
lsp = {
enable = mkEnableOption "Vala LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Vala LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
description = "Vala LSP server to use";
type = enum (attrNames servers);

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

@ -26,7 +26,7 @@
cmd = ${
if isList cfg.lsp.package
then expToLua cfg.lsp.package
else "{'${cfg.lsp.package}/bin/wgsl_analyzer'}"
else "{'${cfg.lsp.package}/bin/wgsl-analyzer'}"
}
}
'';
@ -42,7 +42,7 @@ in {
};
lsp = {
enable = mkEnableOption "WGSL LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "WGSL LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
type = enum (attrNames servers);

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

@ -28,7 +28,7 @@
defaultServer = "yaml-language-server";
servers = {
yaml-language-server = {
package = pkgs.nodePackages.yaml-language-server;
package = pkgs.yaml-language-server;
lspConfig = ''
@ -55,7 +55,7 @@ in {
};
lsp = {
enable = mkEnableOption "YAML LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "YAML LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
type = enum (attrNames servers);

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

@ -72,7 +72,7 @@ in {
};
lsp = {
enable = mkEnableOption "Zig LSP support" // {default = config.vim.languages.enableLSP;};
enable = mkEnableOption "Zig LSP support" // {default = config.vim.lsp.enable;};
server = mkOption {
type = enum (attrNames servers);

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

@ -6,6 +6,7 @@
}: let
inherit (lib.generators) mkLuaInline;
inherit (lib.modules) mkIf;
inherit (lib.lists) optional;
inherit (lib.strings) optionalString;
inherit (lib.trivial) boolToString;
inherit (lib.nvim.binds) addDescriptionsToMappings;
@ -14,7 +15,10 @@
usingNvimCmp = config.vim.autocomplete.nvim-cmp.enable;
usingBlinkCmp = config.vim.autocomplete.blink-cmp.enable;
self = import ./module.nix {inherit config lib pkgs;};
conformCfg = config.vim.formatter.conform-nvim;
conformFormatOnSave = conformCfg.enable && conformCfg.setupOpts.format_on_save != null;
augroup = "nvf_lsp";
mappingDefinitions = self.options.vim.lsp.mappings;
mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
mkBinding = binding: action:
@ -29,24 +33,59 @@ in {
sourcePlugins = ["cmp-nvim-lsp"];
};
augroups = [{name = augroup;}];
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 })
(optional cfg.inlayHints.enable {
group = augroup;
event = ["LspAttach"];
desc = "LSP on-attach enable inlay hints autocmd";
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
'';
})
++ (optional (!conformFormatOnSave) {
group = augroup;
event = ["BufWritePre"];
desc = "LSP on-attach create format on save autocmd";
callback = mkLuaInline ''
function(ev)
if vim.b.disableFormatSave or not vim.g.formatsave then
return
end
local bufnr = ev.buf
${optionalString cfg.null-ls.enable ''
-- prefer null_ls formatter
do
local clients = vim.lsp.get_clients({
bufnr = bufnr,
name = "null-ls",
method = "textDocument/formatting",
})
if clients[1] then
vim.lsp.buf.format({ bufnr = bufnr, id = clients[1].id })
return
end
end
'';
desc = "LSP on-attach enable inlay hints autocmd";
event = ["LspAttach"];
}
]
else [];
''}
local clients = vim.lsp.get_clients({
bufnr = bufnr,
method = "textDocument/formatting",
})
if clients[1] then
vim.lsp.buf.format({ bufnr = bufnr, id = clients[1].id })
end
end
'';
});
pluginRC.lsp-setup = ''
vim.g.formatsave = ${boolToString cfg.formatOnSave};
@ -74,60 +113,9 @@ in {
${mkBinding mappings.toggleFormatOnSave "function() vim.b.disableFormatSave = not vim.b.disableFormatSave end"}
end
-- Enable formatting
local augroup = vim.api.nvim_create_augroup("LspFormatting", {})
format_callback = function(client, bufnr)
if vim.g.formatsave then
vim.api.nvim_clear_autocmds({ group = augroup, buffer = bufnr })
vim.api.nvim_create_autocmd("BufWritePre", {
group = augroup,
buffer = bufnr,
callback = function()
${
if config.vim.lsp.null-ls.enable
then ''
if vim.b.disableFormatSave then
return
end
local function is_null_ls_formatting_enabled(bufnr)
local file_type = vim.api.nvim_buf_get_option(bufnr, "filetype")
local generators = require("null-ls.generators").get_available(
file_type,
require("null-ls.methods").internal.FORMATTING
)
return #generators > 0
end
if is_null_ls_formatting_enabled(bufnr) then
vim.lsp.buf.format({
bufnr = bufnr,
filter = function(client)
return client.name == "null-ls"
end
})
else
vim.lsp.buf.format({
bufnr = bufnr,
})
end
''
else "
vim.lsp.buf.format({
bufnr = bufnr,
})
"
}
end,
})
end
end
${optionalString config.vim.ui.breadcrumbs.enable ''local navic = require("nvim-navic")''}
default_on_attach = function(client, bufnr)
attach_keymaps(client, bufnr)
format_callback(client, bufnr)
${optionalString config.vim.ui.breadcrumbs.enable ''
-- let navic attach to buffers
if client.server_capabilities.documentSymbolProvider then
@ -138,6 +126,7 @@ in {
local capabilities = vim.lsp.protocol.make_client_capabilities()
${optionalString usingNvimCmp ''
-- TODO(horriblename): migrate to vim.lsp.config['*']
-- HACK: copied from cmp-nvim-lsp. If we ever lazy load lspconfig we
-- should re-evaluate whether we can just use `default_capabilities`
capabilities = {

2
modules/plugins/lsp/lspconfig/config.nix
View file

@ -14,8 +14,6 @@ in {
config = mkIf cfg.lspconfig.enable (mkMerge [
{
vim = {
lsp.enable = true;
startPlugins = ["nvim-lspconfig"];
pluginRC.lspconfig = entryAfter ["lsp-setup"] ''

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

@ -3,11 +3,12 @@
inherit (lib.nvim.binds) mkMappingOption;
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"

7
modules/plugins/lsp/otter/config.nix
View file

@ -15,13 +15,6 @@
mappings = addDescriptionsToMappings cfg.otter-nvim.mappings mappingDefinitions;
in {
config = mkIf (cfg.enable && cfg.otter-nvim.enable) {
warnings = [
# TODO: remove warning when we update to nvim 0.11
(mkIf config.vim.utility.ccc.enable ''
ccc and otter occasionally have small conflicts that will disappear with nvim 0.11.
In the meantime, otter handles it by throwing a warning, but both plugins will work.
'')
];
vim = {
startPlugins = ["otter-nvim"];

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

@ -25,15 +25,6 @@ in {
};
};
buffers = {
set_filetype = mkOption {
type = bool;
default = false;
description = ''
if set to true, the filetype of the otterbuffers will be set. Other wide only
the autocommand of lspconfig that attaches the language server will be
executed without setting the filetype
'';
};
write_to_disk = mkOption {
type = bool;
default = false;

6
modules/plugins/mini/ai/ai.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/align/align.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/animate/animate.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/basics/basics.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/bracketed/bracketed.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/bufremove/bufremove.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/clue/clue.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/colors/colors.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
in {
options.vim.mini.colors = {

6
modules/plugins/mini/comment/comment.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/completion/completion.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/diff/diff.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/doc/doc.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/extra/extra.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
in {
options.vim.mini.extra = {

6
modules/plugins/mini/files/files.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/fuzzy/fuzzy.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

6
modules/plugins/mini/git/git.nix
View file

@ -1,8 +1,4 @@
{
config,
lib,
...
}: let
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {

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