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

Merge branch 'NotAShelf:main' into solarized-osaka

Browse source
This commit is contained in:
Jhuan Nycolas 2025-05-15 09:14:33 -03:00 • committed by GitHub
commit 8f87f05b45
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
97 changed files with 1232 additions and 562 deletions
Download patch file Download diff file Expand all files Collapse all files

55
.github/labels.yml vendored Normal file
View file

@ -0,0 +1,55 @@
# This file is used by .github/workflows/labels.yml
"topic: plugins":
- any:
- changed-files:
- any-glob-to-any-file:
- modules/plugins/**/*
"topic: modules":
- any:
- changed-files:
- any-glob-to-any-file:
- modules/**/*
"topic: dependencies":
- any:
- changed-files:
- any-glob-to-any-file:
- npins
- flake.lock
"topic: CI":
- any:
- changed-files:
- any-glob-to-any-file:
- .github/workflows/*.yml
- .github/typos.toml
- .github/dependabot.yml
"topic: meta":
- any:
- changed-files:
- any-glob-to-any-file:
- .github/CODEOWNERS
- LICENSE
- .github/README.md
- .github/funding.yml
- .github/assets
- .github/*_TEMPLATE
- .gitignore
- .editorconfig
- release.json
"topic: documentation":
- any:
- changed-files:
- any-glob-to-any-file:
- docs/**/*
- .github/CONTRIBUTING.md
- .github/README.md
"topic: packaging":
- any:
- changed-files:
- any-glob-to-any-file:
- flake.nix
- flake/packages.nix

33
.github/workflows/backport.yml vendored Normal file
View file

@ -0,0 +1,33 @@
name: Backport PR on Label
on:
pull_request_target:
types:
- labeled
# Permissions needed for the korthout/backport-action to create branches and PRs
permissions:
contents: write
pull-requests: write
jobs:
backport:
name: Create Backport PR
runs-on: ubuntu-latest
if: |
github.event.pull_request.merged == true && startsWith(github.event.label.name, 'backport-')
steps:
- uses: actions/checkout@v4
with:
ref: ${{ github.event.pull_request.head.sha }}
token: ${{ steps.app-token.outputs.token }}
- name: Backport Action
uses: korthout/backport-action@v3
with:
# Regex pattern for labels that should trigger a backport AND extracts the target branch
# from the name (e.g. v0.x or v0.x.y; we use zerover). This action will ONLY proceed if
# the label that triggered the workflow fully matches this pattern.
# Example matching labels: "backport-v0.1", "backport-v0.10.1"
# Example non-matching labels: "backport-foo", "backport-v1.0"
label_pattern: '^backport-(v0\.\d+(\.\d+)?)$'

21
.github/workflows/labeler.yml vendored Normal file
View file

@ -0,0 +1,21 @@
name: "Label PR"
on:
pull_request_target:
types: [edited, opened, synchronize, reopened]
permissions:
contents: read
pull-requests: write
jobs:
labels:
name: "Label PR"
runs-on: ubuntu-latest
if: "!contains(github.event.pull_request.title, '[skip ci]')"
steps:
- uses: actions/labeler@v5
with:
repo-token: ${{ secrets.GITHUB_TOKEN }}
configuration-path: .github/labels.yml
sync-labels: true

19
configuration.nix
View file

@ -18,12 +18,16 @@ isMaximal: {
};
lsp = {
# This must be enabled for the language modules to hook into
# the LSP API.
enable = true;
formatOnSave = true;
lspkind.enable = false;
lightbulb.enable = true;
lspsaga.enable = false;
trouble.enable = true;
lspSignature.enable = true;
lspSignature.enable = !isMaximal; # conflicts with blink in maximal
otter-nvim.enable = isMaximal;
nvim-docs-view.enable = isMaximal;
};
@ -38,8 +42,7 @@ isMaximal: {
# This section does not include a comprehensive list of available language modules.
# To list all available language module options, please visit the nvf manual.
languages = {
enableLSP = true;
enableFormat = true;
enableFormat = true; #
enableTreesitter = true;
enableExtraDiagnostics = true;
@ -124,7 +127,15 @@ isMaximal: {
autopairs.nvim-autopairs.enable = true;
autocomplete.nvim-cmp.enable = true;
# nvf provides various autocomplete options. The tried and tested nvim-cmp
# is enabled in default package, because it does not trigger a build. We
# enable blink-cmp in maximal because it needs to build its rust fuzzy
# matcher library.
autocomplete = {
nvim-cmp.enable = !isMaximal;
blink-cmp.enable = isMaximal;
};
snippets.luasnip.enable = true;
filetree = {

1
docs/default.nix
View file

@ -12,6 +12,7 @@
inherit
(
(lib.evalModules {
specialArgs = {inherit inputs;};
modules =
import ../modules/modules.nix {
inherit lib pkgs;

11
docs/manual/configuring.md
View file

@ -1,5 +1,15 @@
# Configuring nvf {#ch-configuring}
[helpful tips section]: #ch-helpful-tips
nvf allows for _very_ extensive configuration in Neovim through the Nix module
interface. The below chapters describe several of the options exposed in nvf for
your convenience. You might also be interested in the [helpful tips section] for
more advanced or unusual configuration options supported by nvf.
Note that this section does not cover module _options_. For an overview of all
module options provided by nvf, please visit the [appendix](/options.html)
```{=include=} chapters
configuring/custom-package.md
configuring/custom-plugins.md
@ -7,4 +17,5 @@ configuring/overriding-plugins.md
configuring/languages.md
configuring/dags.md
configuring/dag-entries.md
configuring/autocmds.md
```

119
docs/manual/configuring/autocmds.md Normal file
View file

@ -0,0 +1,119 @@
# Autocommands and Autogroups {#ch-autocmds-augroups}
This module allows you to declaratively configure Neovim autocommands and
autogroups within your Nix configuration.
## Autogroups (`vim.augroups`) {#sec-vim-augroups}
Autogroups (`augroup`) organize related autocommands. This allows them to be
managed collectively, such as clearing them all at once to prevent duplicates.
Each entry in the list is a submodule with the following options:
| Option | Type | Default | Description | Example |
| :------- | :----- | :------ | :--------------------------------------------------------------------------------------------------- | :---------------- |
| `enable` | `bool` | `true` | Enables or disables this autogroup definition. | `true` |
| `name` | `str` | _None_ | **Required.** The unique name for the autogroup. | `"MyFormatGroup"` |
| `clear` | `bool` | `true` | Clears any existing autocommands within this group before adding new ones defined in `vim.autocmds`. | `true` |
**Example:**
```nix
{
vim.augroups = [
{
name = "MyCustomAuGroup";
clear = true; # Clear previous autocommands in this group on reload
}
{
name = "Formatting";
# clear defaults to true
}
];
}
```
## Autocommands (`vim.autocmds`) {#sec-vim-autocmds}
Autocommands (`autocmd`) trigger actions based on events happening within Neovim
(e.g., saving a file, entering a buffer). Each entry in the list is a submodule
with the following options:
| Option | Type | Default | Description | Example |
| :--------- | :-------------------- | :------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------- |
| `enable` | `bool` | `true` | Enables or disables this autocommand definition. | `true` |
| `event` | `nullOr (listOf str)` | `null` | **Required.** List of Neovim events that trigger this autocommand (e.g., `BufWritePre`, `FileType`). | `[ "BufWritePre" ]` |
| `pattern` | `nullOr (listOf str)` | `null` | List of file patterns (globs) to match against (e.g., `*.py`, `*`). If `null`, matches all files for the given event. | `[ "*.lua", "*.nix" ]` |
| `callback` | `nullOr luaInline` | `null` | A Lua function to execute when the event triggers. Use `lib.nvim.types.luaInline` or `lib.options.literalExpression "mkLuaInline '''...'''"`. **Cannot be used with `command`.** | `lib.nvim.types.luaInline "function() print('File saved!') end"` |
| `command` | `nullOr str` | `null` | A Vimscript command to execute when the event triggers. **Cannot be used with `callback`.** | `"echo 'File saved!'"` |
| `group` | `nullOr str` | `null` | The name of an `augroup` (defined in `vim.augroups`) to associate this autocommand with. | `"MyCustomAuGroup"` |
| `desc` | `nullOr str` | `null` | A description for the autocommand (useful for introspection). | `"Format buffer on save"` |
| `once` | `bool` | `false` | If `true`, the autocommand runs only once and then automatically removes itself. | `false` |
| `nested` | `bool` | `false` | If `true`, allows this autocommand to trigger other autocommands. | `false` |
:::{.warning}
You cannot define both `callback` (for Lua functions) and `command` (for
Vimscript) for the same autocommand. Choose one.
:::
**Examples:**
```nix
{ lib, ... }:
{
vim.augroups = [ { name = "UserSetup"; } ];
vim.autocmds = [
# Example 1: Using a Lua callback
{
event = [ "BufWritePost" ];
pattern = [ "*.lua" ];
group = "UserSetup";
desc = "Notify after saving Lua file";
callback = lib.nvim.types.luaInline ''
function()
vim.notify("Lua file saved!", vim.log.levels.INFO)
end
'';
}
# Example 2: Using a Vim command
{
event = [ "FileType" ];
pattern = [ "markdown" ];
group = "UserSetup";
desc = "Set spellcheck for Markdown";
command = "setlocal spell";
}
# Example 3: Autocommand without a specific group
{
event = [ "BufEnter" ];
pattern = [ "*.log" ];
desc = "Disable line numbers in log files";
command = "setlocal nonumber";
# No 'group' specified
}
# Example 4: Using Lua for callback
{
event = [ "BufWinEnter" ];
pattern = [ "*" ];
desc = "Simple greeting on entering a buffer window";
callback = lib.generators.mkLuaInline ''
function(args)
print("Entered buffer: " .. args.buf)
end
'';
# Run only once per session trigger
once = true;
}
];
}
```
These definitions are automatically translated into the necessary Lua code to
configure `vim.api.nvim_create_augroup` and `vim.api.nvim_create_autocmd` when
Neovim starts.

4
docs/manual/configuring/custom-package.md
View file

@ -1,12 +1,12 @@
# Custom Neovim Package {#ch-custom-package}
As of v0.5, you may now specify the Neovim package that will be wrapped with
your configuration. This is done with the `vim.package` option.
your configuration. This is done with the [](#opt-vim.package) option.
```nix
{inputs, pkgs, ...}: {
# using the neovim-nightly overlay
vim.package = inputs.neovim-overlay.packages.${pkgs.system}.neovim;
vim.package = inputs.neovim-overlay.packages.${pkgs.stdenv.system}.neovim;
}
```

35
docs/manual/configuring/custom-plugins.md
View file

@ -1,22 +1,33 @@
# Custom Plugins {#ch-custom-plugins}
**nvf**, by default, exposes a wide variety of plugins as module options for
your convenience and bundles necessary dependencies into **nvf**'s runtime. In
case a plugin is not available in **nvf**, you may consider making a pull
request to **nvf** to include it as a module or you may add it to your
configuration locally.
**nvf** exposes a very wide variety of plugins by default, which are consumed by
module options. This is done for your convenience, and to bundle all necessary
dependencies into **nvf**'s runtime with full control of versioning, testing and
dependencies. In the case a plugin you need is _not_ available, you may consider
making a pull request to add the package you're looking for, or you may add it
to your configuration locally. The below section describes how new plugins may
be added to the user's configuration.
## Adding Plugins {#ch-adding-plugins}
There are multiple ways of adding custom plugins to your **nvf** configuration.
Per **nvf**'s design choices, there are several ways of adding custom plugins to
your configuration as you need them. As we aim for extensive configuration, it
is possible to add custom plugins (from nixpkgs, pinning tools, flake inputs,
etc.) to your Neovim configuration before they are even implemented in **nvf**
as a module.
You can use custom plugins, before they are implemented in the flake. To add a
plugin to the runtime, you need to add it to the [](#opt-vim.startPlugins) list
in your configuration.
:::{.info}
Adding a plugin to `startPlugins` will not allow you to configure the plugin
that you have added, but **nvf** provides multiple ways of configuring any custom
plugins that you might have added to your configuration.
To add a plugin to your runtime, you will need to add it to
[](#opt-vim.startPlugins) list in your configuration. This is akin to cloning a
plugin to `~/.config/nvim`, but they are only ever placed in the Nix store and
never exposed to the outside world for purity and full isolation.
:::
As you would configure a cloned plugin, you must configure the new plugins that
you've added to `startPlugins.` **nvf** provides multiple ways of configuring
any custom plugins that you might have added to your configuration.
```{=include=} sections
custom-plugins/configuring.md

66
docs/manual/configuring/custom-plugins/configuring.md
View file

@ -1,13 +1,20 @@
# Configuring {#sec-configuring-plugins}
Just making the plugin to your Neovim configuration available might not always
be enough. In that case, you can write custom lua config using either
`config.vim.lazy.plugins.*.setupOpts` `config.vim.extraPlugins.*.setup` or
`config.vim.luaConfigRC`.
be enough., for example, if the plugin requires a setup table. In that case, you
can write custom Lua configuration using one of
The first option uses an extended version of `lz.n`'s PluginSpec. `setupModule`
and `setupOpt` can be used if the plugin uses a `require('module').setup(...)`
pattern. Otherwise, the `before` and `after` hooks should do what you need.
- `config.vim.lazy.plugins.*.setupOpts`
- `config.vim.extraPlugins.*.setup`
- `config.vim.luaConfigRC`.
## Lazy Plugins {#ch-vim-lazy-plugins}
`config.vim.lazy.plugins.*.setupOpts` is useful for lazy-loading plugins, and
uses an extended version of `lz.n's` `PluginSpec` to expose a familiar
interface. `setupModule` and `setupOpt` can be used if the plugin uses a
`require('module').setup(...)` pattern. Otherwise, the `before` and `after`
hooks should do what you need.
```nix
{
@ -25,50 +32,61 @@ pattern. Otherwise, the `before` and `after` hooks should do what you need.
}
```
The second option uses an attribute set, which maps DAG section names to a
## Standard API {#ch-vim-extra-plugins}
`vim.extraPlugins` uses an attribute set, which maps DAG section names to a
custom type, which has the fields `package`, `after`, `setup`. They allow you to
set the package of the plugin, the sections its setup code should be after (note
that the `extraPlugins` option has its own DAG scope), and the its setup code
respectively. For example:
```nix
config.vim.extraPlugins = with pkgs.vimPlugins; {
aerial = {
package = aerial-nvim;
setup = "require('aerial').setup {}";
};
{pkgs, ...}: {
config.vim.extraPlugins = {
aerial = {
package = pkgs.vimPlugins.aerial-nvim;
setup = "require('aerial').setup {}";
};
harpoon = {
package = harpoon;
setup = "require('harpoon').setup {}";
after = ["aerial"]; # place harpoon configuration after aerial
harpoon = {
package = pkgs.vimPlugins.harpoon;
setup = "require('harpoon').setup {}";
after = ["aerial"]; # place harpoon configuration after aerial
};
};
}
```
The third option also uses an attribute set, but this one is resolved as a DAG
### Setup using luaConfigRC {#setup-using-luaconfigrc}
`vim.luaConfigRC` also uses an attribute set, but this one is resolved as a DAG
directly. The attribute names denote the section names, and the values lua code.
For example:
```nix
{
# this will create an "aquarium" section in your init.lua with the contents of your custom config
# which will be *appended* to the rest of your configuration, inside your init.vim
# This will create a section called "aquarium" in the 'init.lua' with the
# contents of your custom configuration. By default 'entryAnywhere' is implied
# in DAGs, so this will be inserted to an arbitrary position. In the case you
# wish to control the position of this section with more precision, please
# look into the DAGs section of the manual.
config.vim.luaConfigRC.aquarium = "vim.cmd('colorscheme aquiarum')";
}
```
<!-- deno-fmt-ignore-start -->
[DAG system]: #ch-using-dags
[DAG section]: #ch-dag-entries
::: {.note}
One of the greatest strengths of nvf is the ability to order
snippets of configuration via the DAG system. It will allow specifying positions
of individual sections of configuration as needed. nvf provides helper functions
One of the **greatest strengths** of **nvf** is the ability to order
configuration snippets precisely using the [DAG system]. DAGs
are a very powerful mechanism that allows specifying positions
of individual sections of configuration as needed. We provide helper functions
in the extended library, usually under `inputs.nvf.lib.nvim.dag` that you may
use.
Please refer to the [DAG section](#ch-dag-entries) in the nvf manual
Please refer to the [DAG section] in the nvf manual
to find out more about the DAG system.
:::
<!-- deno-fmt-ignore-end -->

13
docs/manual/configuring/custom-plugins/lazy-method.md
View file

@ -1,7 +1,8 @@
# Lazy Method {#sec-lazy-method}
As of version **0.7**, we exposed an API for configuring lazy-loaded plugins via
`lz.n` and `lzn-auto-require`.
As of version **0.7**, an API is exposed to allow configuring lazy-loaded
plugins via `lz.n` and `lzn-auto-require`. Below is a comprehensive example of
how it may be loaded to lazy-load an arbitrary plugin.
```nix
{
@ -41,7 +42,8 @@ As of version **0.7**, we exposed an API for configuring lazy-loaded plugins via
## LazyFile event {#sec-lazyfile-event}
You can use the `LazyFile` user event to load a plugin when a file is opened:
**nvf** re-implements `LazyFile` as a familiar user event to load a plugin when
a file is opened:
```nix
{
@ -55,5 +57,6 @@ You can use the `LazyFile` user event to load a plugin when a file is opened:
}
```
You can consider `LazyFile` as an alias to
`["BufReadPost" "BufNewFile" "BufWritePre"]`
You can consider the `LazyFile` event as an alias to the combination of
`"BufReadPost"`, `"BufNewFile"` and `"BufWritePre"`, i.e., a list containing all
three of those events: `["BufReadPost" "BufNewFile" "BufWritePre"]`

29
docs/manual/configuring/custom-plugins/legacy-method.md
View file

@ -1,26 +1,31 @@
# Legacy Method {#sec-legacy-method}
Prior to version v0.5, the method of adding new plugins was adding the plugin
package to `vim.startPlugins` and add its configuration as a DAG under one of
`vim.configRC` or `vim.luaConfigRC`. Users who have not yet updated to 0.5, or
prefer a more hands-on approach may use the old method where the load order of
the plugins is determined by DAGs.
Prior to version **0.5**, the method of adding new plugins was adding the plugin
package to [](#opt-vim.startPlugins) and adding its configuration as a DAG under
one of `vim.configRC` or [](#opt-vim.luaConfigRC). While `configRC` has been
deprecated, users who have not yet updated to 0.5 or those who prefer a more
hands-on approach may choose to use the old method where the load order of the
plugins is explicitly determined by DAGs without internal abstractions.
## Adding plugins {#sec-adding-plugins}
## Adding New Plugins {#sec-adding-new-plugins}
To add a plugin not available in nvf as a module to your configuration, you may
add it to [](#opt-vim.startPlugins) in order to make it available to Neovim at
runtime.
To add a plugin not available in **nvf** as a module to your configuration using
the legacy method, you must add it to [](#opt-vim.startPlugins) in order to make
it available to Neovim at runtime.
```nix
{pkgs, ...}: {
# Add a Neovim plugin from Nixpkgs to the runtime.
# This does not need to come explicitly from packages. 'vim.startPlugins'
# takes a list of *string* (to load internal plugins) or *package* to load
# a Neovim package from any source.
vim.startPlugins = [pkgs.vimPlugins.aerial-nvim];
}
```
And to configure the added plugin, you can use the `luaConfigRC` option to
provide configuration as a DAG using the **nvf** extended library.
Once the package is available in Neovim's runtime, you may use the `luaConfigRC`
option to provide configuration as a DAG using the **nvf** extended library in
order to configure the added plugin,
```nix
{inputs, ...}: let
@ -29,6 +34,8 @@ provide configuration as a DAG using the **nvf** extended library.
# to specialArgs, the 'inputs' prefix may be omitted.
inherit (inputs.nvf.lib.nvim.dag) entryAnywhere;
in {
# luaConfigRC takes Lua configuration verbatim and inserts it at an arbitrary
# position by default or if 'entryAnywhere' is used.
vim.luaConfigRC.aerial-nvim= entryAnywhere ''
require('aerial').setup {
-- your configuration here

17
docs/manual/configuring/custom-plugins/non-lazy-method.md
View file

@ -1,14 +1,15 @@
# Non-lazy Method {#sec-non-lazy-method}
As of version **0.5**, we have a more extensive API for configuring plugins,
under `vim.extraPlugins`. Instead of using DAGs exposed by the library, you may
use the extra plugin module as follows:
As of version **0.5**, we have a more extensive API for configuring plugins that
should be preferred over the legacy method. This API is available as
[](#opt-vim.extraPlugins). Instead of using DAGs exposed by the library
_directly_, you may use the extra plugin module as follows:
```nix
{
config.vim.extraPlugins = with pkgs.vimPlugins; {
{pkgs, ...}: {
config.vim.extraPlugins = {
aerial = {
package = aerial-nvim;
package = pkgs.vimPlugins.aerial-nvim;
setup = ''
require('aerial').setup {
-- some lua configuration here
@ -17,10 +18,12 @@ use the extra plugin module as follows:
};
harpoon = {
package = harpoon;
package = pkgs.vimPlugins.harpoon;
setup = "require('harpoon').setup {}";
after = ["aerial"];
};
};
}
```
This provides a level of abstraction over the DAG system for faster iteration.

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

@ -1,17 +1,22 @@
# LSP Custom Packages/Command {#sec-languages-custom-lsp-packages}
In any of the `opt.languages.<language>.lsp.package` options you can provide
your own LSP package, or provide the command to launch the language server, as a
list of strings. You can use this to skip automatic installation of a language
server, and instead use the one found in your `$PATH` during runtime, for
example:
One of the strengths of **nvf** is convenient aliases to quickly configure LSP
servers through the Nix module system. By default the LSP packages for relevant
language modules will be pulled into the closure. If this is not desirable, you
may provide **a custom LSP package** (e.g., a Bash script that calls a command)
or **a list of strings** to be interpreted as the command to launch the language
server. By using a list of strings, you can use this to skip automatic
installation of a language server, and instead use the one found in your `$PATH`
during runtime, for example:
```nix
vim.languages.java = {
lsp = {
enable = true;
# this expects jdt-language-server to be in your PATH
# or in `vim.extraPackages`
# This expects 'jdt-language-server' to be in your PATH or in
# 'vim.extraPackages.' There are no additional checks performed to see
# if the command provided is valid.
package = ["jdt-language-server" "-data" "~/.cache/jdtls/workspace"];
};
}

10
docs/manual/default-configs.md
View file

@ -1,10 +0,0 @@
# Default Configs {#ch-default-configs}
While you can configure **nvf** yourself using the builder, you can also use the
pre-built configs that are available. Here are a few default configurations you
can use.
```{=include=} chapters
default-configs/maximal.md
default-configs/nix.md
```

11
docs/manual/default-configs/maximal.md
View file

@ -1,11 +0,0 @@
# Maximal {#sec-default-maximal}
```bash
$ nix run github:notashelf/nvf#maximal -- test.nix
```
It is the same fully configured Neovim as with the [Nix](#sec-default-nix)
configuration, but with every supported language enabled.
::: {.note} Running the maximal config will download _a lot_ of packages as it
is downloading language servers, formatters, and more. :::

9
docs/manual/default-configs/nix.md
View file

@ -1,9 +0,0 @@
# Nix {#sec-default-nix}
```bash
$ nix run github:notashelf/nvf#nix test.nix
```
Enables all the of Neovim plugins, with language support for specifically Nix.
This lets you see what a fully configured neovim setup looks like without
downloading a whole bunch of language servers and associated tools.

1
docs/manual/manual.md
View file

@ -8,7 +8,6 @@ try-it-out.md
```
```{=include=} parts
default-configs.md
installation.md
configuring.md
tips.md

9
docs/manual/tips.md
View file

@ -1,7 +1,14 @@
# Helpful Tips {#ch-helpful-tips}
This section provides helpful tips that may be considered "unorthodox" or "too
advanced" for some users. We will cover basic debugging steps, offline
documentation, configuring **nvf** with pure Lua and using custom plugin sources
in **nvf** in this section. For general configuration tips, please see previous
chapters.
```{=include=} chapters
tips/pure-lua-config.md
tips/debugging-nvf.md
tips/offline-docs.md
tips/pure-lua-config.md
tips/plugin-sources.md
```

131
docs/manual/tips/plugin-sources.md Normal file
View file

@ -0,0 +1,131 @@
# Adding Plugins From Different Sources {#sec-plugin-sources}
**nvf** attempts to avoid depending on Nixpkgs for Neovim plugins. For the most
part, this is accomplished by defining each plugin's source and building them
from source.
[npins]: https://github.com/andir/npins
To define plugin sources, we use [npins] and pin each plugin source using
builtin fetchers. You are not bound by this restriction. In your own
configuration, any kind of fetcher or plugin source is fine.
## Nixpkgs & Friends {#ch-plugins-from-nixpkgs}
`vim.startPlugins` and `vim.optPlugins` options take either a **string**, in
which case a plugin from nvf's internal plugins registry will be used, or a
**package**. If your plugin does not require any setup, or ordering for it s
configuration, then it is possible to add it to `vim.startPlugins` to load it on
startup.
```nix
{pkgs, ...}: {
# Aerial does require some setup. In the case you pass a plugin that *does*
# require manual setup, then you must also call the setup function.
vim.startPlugins = [pkgs.vimPlugins.aerial-nvim];
}
```
[`vim.extraPlugins`]: https://notashelf.github.io/nvf/options.html#opt-vim.extraPlugins
This will fetch aerial.nvim from nixpkgs, and add it to Neovim's runtime path to
be loaded manually. Although for plugins that require manual setup, you are
encouraged to use [`vim.extraPlugins`].
```nix
{
vim.extraPlugins = {
aerial = {
package = pkgs.vimPlugins.aerial-nvim;
setup = "require('aerial').setup {}";
};
};
}
```
[custom plugins section]: https://notashelf.github.io/nvf/index.xhtml#ch-custom-plugins
More details on the extraPlugins API is documented in the
[custom plugins section].
## Building Your Own Plugins {#ch-plugins-from-source}
In the case a plugin is not available in Nixpkgs, or the Nixpkgs package is
outdated (or, more likely, broken) it is possible to build the plugins from
source using a tool, such as [npins]. You may also use your _flake inputs_ as
sources.
Example using plugin inputs:
```nix
{
# In your flake.nix
inputs = {
aerial-nvim = {
url = "github:stevearc/aerial.nvim"
flake = false;
};
};
# Make sure that 'inputs' is properly propagated into Nvf, for example, through
# specialArgs.
outputs = { ... };
}
```
In the case, you may use the input directly for the plugin's source attribute in
`buildVimPlugin`.
```nix
# Make sure that 'inputs' is properly propagated! It will be missing otherwise
# and the resulting errors might be too obscure.
{inputs, ...}: let
aerial-from-source = pkgs.vimUtils.buildVimPlugin {
name = "aerial-nvim";
src = inputs.aerial-nvim;
};
in {
vim.extraPlugins = {
aerial = {
package = aerial-from-source;
setup = "require('aerial').setup {}";
};
};
}
```
Alternatively, if you do not want to keep track of the source using flake inputs
or npins, you may call `fetchFromGitHub` (or other fetchers) directly. An
example would look like this.
```nix
regexplainer = buildVimPlugin {
name = "nvim-regexplainer";
src = fetchFromGitHub {
owner = "bennypowers";
repo = "nvim-regexplainer";
rev = "4250c8f3c1307876384e70eeedde5149249e154f";
hash = "sha256-15DLbKtOgUPq4DcF71jFYu31faDn52k3P1x47GL3+b0=";
};
# The 'buildVimPlugin' imposes some "require checks" on all plugins build from
# source. Failing tests, if they are not relevant, can be disabled using the
# 'nvimSkipModule' argument to the 'buildVimPlugin' function.
nvimSkipModule = [
"regexplainer"
"regexplainer.buffers.init"
"regexplainer.buffers.popup"
"regexplainer.buffers.register"
"regexplainer.buffers.shared"
"regexplainer.buffers.split"
"regexplainer.component.descriptions"
"regexplainer.component.init"
"regexplainer.renderers.narrative.init"
"regexplainer.renderers.narrative.narrative"
"regexplainer.renderers.init"
"regexplainer.utils.defer"
"regexplainer.utils.init"
"regexplainer.utils.treesitter"
];
}
```

30
docs/manual/try-it-out.md
View file

@ -26,7 +26,12 @@ $ nix run github:notashelf/nvf#nix
$ nix run github:notashelf/nvf#maximal
```
### Available Configs {#sec-available-configs}
### Available Configurations {#sec-available-configs}
:::{.info}
The below configurations are provided for demonstration purposes, and are
**not** designed to be installed as is. You may
#### Nix {#sec-configs-nix}
@ -34,15 +39,32 @@ $ nix run github:notashelf/nvf#maximal
a set of visual and functional plugins. By running `nix run .#`, which is the
default package, you will build Neovim with this config.
```bash
$ nix run github:notashelf/nvf#nix test.nix
```
This command will start Neovim with some opinionated plugin configurations, and
is designed specifically for Nix. the `nix` configuration lets you see how a
fully configured Neovim setup _might_ look like without downloading too many
packages or shell utilities.
#### Maximal {#sec-configs-maximal}
`Maximal` is the ultimate configuration that will enable support for more
commonly used language as well as additional complementary plugins. Keep in
mind, however, that this will pull a lot of dependencies.
::: {.tip}
```bash
$ nix run github:notashelf/nvf#maximal -- test.nix
```
You are _strongly_ recommended to use the binary cache if you would like to try
the Maximal configuration.
It uses the same configuration template with the [Nix](#sec-configs-nix)
configuration, but supports many more languages, and enables more utility,
companion or fun plugins.
::: {.warning}
Running the maximal config will download _a lot_ of packages as it is
downloading language servers, formatters, and more.
:::

5
docs/release-notes/rl-0.3.md
View file

@ -50,9 +50,8 @@ soon.
- A new section has been added for language support: `vim.languages.<language>`.
- The options [](#opt-vim.languages.enableLSP),
[](#opt-vim.languages.enableTreesitter), etc. will enable the respective
section for all languages that have been enabled.
- The options `enableLSP` [](#opt-vim.languages.enableTreesitter), etc. will
enable the respective section for all languages that have been enabled.
- All LSP languages have been moved here
- `plantuml` and `markdown` have been moved here
- A new section has been added for `html`. The old

35
docs/release-notes/rl-0.8.md
View file

@ -19,6 +19,11 @@
unavailable as they have been refactored out of the main none-ls repository
upstream.
- `vim.useSystemClipboard` has been deprecated as a part of removing most
top-level convenience options, and should instead be configured in the new
module interface. You may set [](#opt-vim.clipboard.registers) appropriately
to configure Neovim to use the system clipboard.
[NotAShelf](https://github.com/notashelf):
[typst-preview.nvim]: https://github.com/chomosuke/typst-preview.nvim
@ -91,6 +96,11 @@
options for `vim.diagnostic.config()` can now be customized through the
[](#opt-vim.diagnostics.config) in nvf.
- Add `vim.clipboard` module for easily managing Neovim clipboard providers and
relevant packages in a simple UI.
- This deprecates `vim.useSystemClipboard` as well, see breaking changes
section above for migration options.
[amadaluzia](https://github.com/amadaluzia):
[haskell-tools.nvim]: https://github.com/MrcJkb/haskell-tools.nvim
@ -109,6 +119,7 @@
- Add tsx support in conform and lint
- Moved code setting `additionalRuntimePaths` and `enableLuaLoader` out of
`luaConfigPre`'s default to prevent being overridden
- Use conform over custom autocmds for LSP format on save
[diniamo](https://github.com/diniamo):
@ -278,6 +289,7 @@
[BANanaD3V](https://github.com/BANanaD3V):
- `alpha` is now configured with nix.
- Add `markview-nvim` markdown renderer.
[viicslen](https://github.com/viicslen):
@ -312,6 +324,8 @@
- Fix fzf-lua having a hard dependency on fzf.
- Enable inlay hints support - `config.vim.lsp.inlayHints`.
- Add `neo-tree`, `snacks.picker` extensions to `lualine`.
- Add support for `vim.lsp.formatOnSave` and
`vim.lsp.mappings.toggleFormatOnSave`
[tebuevd](https://github.com/tebuevd):
@ -325,11 +339,13 @@
[flash.nvim]: https://github.com/folke/flash.nvim
[gitlinker.nvim]: https://github.com/linrongbin16/gitlinker.nvim
[nvim-treesitter-textobjects]: https://github.com/nvim-treesitter/nvim-treesitter-textobjects
- Fix oil config referencing snacks
- Add [flash.nvim] plugin to `vim.utility.motion.flash-nvim`
- Fix default telescope ignore list entry for '.git/' to properly match
- Add [gitlinker.nvim] plugin to `vim.git.gitlinker-nvim`
- Add [nvim-treesitter-textobjects] plugin to `vim.treesitter.textobjects`
[rrvsh](https://github.com/rrvsh):
@ -359,5 +375,20 @@
[Haskex](https://github.com/haskex):
- Add Plugin [Hardtime.nvim](https://github.com/m4xshen/hardtime.nvim).
- Add option `vim.binds.hardtime-nvim` with `enable` and `setupOpts` options.
[Hardtime.nvim]: https://github.com/m4xshen/hardtime.nvim
- Add Plugin [Hardtime.nvim] under `vim.binds.hardtime-nvim` with `enable` and
`setupOpts` options
[taylrfnt](https://github.com/taylrfnt):
[nvim-tree](https://github.com/nvim-tree/nvim-tree.lua):
- Add missing `right_align` option for existing `renderer.icons` options.
- Add missing `render.icons` options (`hidden_placement`,
`diagnostics_placement`, and `bookmarks_placement`).
[cramt](https://github.com/cramt):
- Add `rubylsp` option in `vim.languages.ruby.lsp.server` to use shopify's
ruby-lsp language server

12
flake.lock generated
View file

@ -38,11 +38,11 @@
},
"mnw": {
"locked": {
"lastModified": 1745705214,
"narHash": "sha256-XGfaHbFI4vvDuaoVO3IFYZKezXIO8rhUaMCGcjY71Ac=",
"lastModified": 1746338991,
"narHash": "sha256-GbyoHjf14LOxZQc+0NFblI4xf/uwGrYo3W8lwE4HcwI=",
"owner": "Gerg-L",
"repo": "mnw",
"rev": "c1f4587db4c53dcefa432c46c7a899a116d8e924",
"rev": "c65407ee9387ef75985dad3e30f58c822c766ec1",
"type": "github"
},
"original": {
@ -77,11 +77,11 @@
},
"nixpkgs": {
"locked": {
"lastModified": 1745377448,
"narHash": "sha256-jhZDfXVKdD7TSEGgzFJQvEEZ2K65UMiqW5YJ2aIqxMA=",
"lastModified": 1746152631,
"narHash": "sha256-zBuvmL6+CUsk2J8GINpyy8Hs1Zp4PP6iBWSmZ4SCQ/s=",
"owner": "nixos",
"repo": "nixpkgs",
"rev": "507b63021ada5fee621b6ca371c4fca9ca46f52c",
"rev": "032bc6539bd5f14e9d0c51bd79cfe9a055b094c3",
"type": "github"
},
"original": {

3
flake.nix
View file

@ -18,10 +18,7 @@
systems = import inputs.systems;
imports = [
./flake/templates
./flake/apps.nix
./flake/legacyPackages.nix
./flake/overlays.nix
./flake/packages.nix
./flake/develop.nix
];

38
flake/blink/default.nix Normal file
View file

@ -0,0 +1,38 @@
{
rustPlatform,
fetchFromGitHub,
writeShellScriptBin,
}:
rustPlatform.buildRustPackage (finalAttrs: {
pname = "blink-cmp";
version = "1.2.0";
src = fetchFromGitHub {
owner = "Saghen";
repo = "blink.cmp";
tag = "v${finalAttrs.version}";
hash = "sha256-bKe8SSg1HPWE7b4iRQJwiOVCrvvgttuHCOIa4U/38AY=";
};
forceShare = [
"man"
"info"
];
postInstall = ''
cp -r {lua,plugin} "$out"
mkdir -p "$out/doc"
cp 'doc/'*'.txt' "$out/doc/"
mkdir -p "$out/target"
mv "$out/lib" "$out/target/release"
'';
cargoHash = "sha256-IDoDugtNWQovfSstbVMkKHLBXKa06lxRWmywu4zyS3M=";
useFetchCargoVendor = true;
nativeBuildInputs = [
(writeShellScriptBin "git" "exit 1")
];
env.RUSTC_BOOTSTRAP = true;
})

3
flake/develop.nix
View file

@ -3,13 +3,14 @@
pkgs,
config,
self',
inputs',
...
}: {
devShells = {
default = self'.devShells.lsp;
nvim-nix = pkgs.mkShellNoCC {packages = [config.packages.nix];};
lsp = pkgs.mkShellNoCC {
packages = with pkgs; [nil statix deadnix alejandra npins];
packages = with pkgs; [inputs'.nil.packages.default statix deadnix alejandra npins];
};
};

35
flake/legacyPackages.nix
View file

@ -1,35 +0,0 @@
{
inputs,
self,
...
}: {
perSystem = {
system,
inputs',
...
}: {
legacyPackages = import inputs.nixpkgs {
inherit system;
overlays = [
inputs.self.overlays.default
(final: prev: {
# Build nil from source to get most recent
# features as they are added.
nil = inputs'.nil.packages.default;
blink-cmp = let
pin = self.pins.blink-cmp;
in
final.callPackage ./legacyPackages/blink-cmp.nix {
inherit (pin) version;
src = prev.fetchFromGitHub {
inherit (pin.repository) owner repo;
rev = pin.revision;
sha256 = pin.hash;
};
};
})
];
};
};
}

37
flake/legacyPackages/blink-cmp.nix
View file

@ -1,37 +0,0 @@
{
stdenv,
rustPlatform,
vimUtils,
gitMinimal,
src,
version,
}: let
blink-fuzzy-lib = rustPlatform.buildRustPackage {
pname = "blink-fuzzy-lib";
inherit version src;
# TODO: remove this if plugin stops using nightly rust
env.RUSTC_BOOTSTRAP = true;
useFetchCargoVendor = true;
cargoHash = "sha256-MWElqh7ENJ6CbLOnvz0DsP5YYu+e+y12GSUOfW1IKGU=";
nativeBuildInputs = [gitMinimal];
};
in
vimUtils.buildVimPlugin {
pname = "blink-cmp";
inherit version src;
# blink references a repro.lua which is placed outside the lua/ directory
doCheck = false;
preInstall = let
ext = stdenv.hostPlatform.extensions.sharedLibrary;
in ''
mkdir -p target/release
ln -s ${blink-fuzzy-lib}/lib/libblink_cmp_fuzzy${ext} target/release/libblink_cmp_fuzzy${ext}
'';
# Module for reproducing issues
nvimSkipModules = ["repro"];
}

19
flake/overlays.nix
View file

@ -1,19 +0,0 @@
{
pkgs,
lib,
...
}: let
inherit (lib.nvim) neovimConfiguration;
buildPkg = pkgs: modules: (neovimConfiguration {inherit pkgs modules;}).neovim;
nixConfig = import ../configuration.nix false;
maximalConfig = import ../configuration.nix true;
in {
flake.overlays.default = final: _prev: {
inherit neovimConfiguration;
neovim-nix = buildPkg final [nixConfig];
neovim-maximal = buildPkg final [maximalConfig];
devPkg = buildPkg pkgs [nixConfig {config.vim.languages.html.enable = pkgs.lib.mkForce true;}];
};
}

15
flake/packages.nix
View file

@ -1,4 +1,4 @@
{inputs, ...}: {
{inputs, ...} @ args: {
perSystem = {
config,
pkgs,
@ -6,8 +6,15 @@
...
}: let
docs = import ../docs {inherit pkgs inputs lib;};
buildPkg = maximal:
(args.config.flake.lib.nvim.neovimConfiguration {
inherit pkgs;
modules = [(import ../configuration.nix maximal)];
}).neovim;
in {
packages = {
blink-cmp = pkgs.callPackage ./blink {};
inherit (docs.manual) htmlOpenTool;
# Documentation
docs = docs.manual.html;
@ -61,9 +68,9 @@
'';
# Exposed neovim configurations
nix = config.legacyPackages.neovim-nix;
maximal = config.legacyPackages.neovim-maximal;
default = config.legacyPackages.neovim-nix;
nix = buildPkg false;
maximal = buildPkg true;
default = config.packages.nix;
};
};
}

12
flake/templates/standalone/flake.nix
View file

@ -26,12 +26,22 @@
config.vim = {
theme.enable = true;
lsp = {
# Enable LSP functionality globally. This is required for modules found
# in `vim.languages` to enable relevant LSPs.
enable = true;
# You may define your own LSP configurations using `vim.lsp.servers` in
# nvf without ever needing lspconfig to do it. This will use the native
# API provided by Neovim > 0.11
servers = {};
};
# Language support and automatic configuration of companion plugins.
# Note that enabling, e.g., languages.<lang>.diagnostics will automatically
# enable top-level options such as enableLSP or enableExtraDiagnostics as
# they are needed.
languages = {
enableLSP = true;
enableFormat = true;
enableTreesitter = true;
enableExtraDiagnostics = true;

2
lib/default.nix
View file

@ -4,7 +4,7 @@
lib,
...
}: {
types = import ./types {inherit lib;};
types = import ./types {inherit lib self;};
config = import ./config.nix {inherit lib;};
binds = import ./binds.nix {inherit lib;};
dag = import ./dag.nix {inherit lib;};

7
lib/types/default.nix
View file

@ -1,6 +1,9 @@
{lib}: let
{
lib,
self,
}: let
typesDag = import ./dag.nix {inherit lib;};
typesPlugin = import ./plugins.nix {inherit lib;};
typesPlugin = import ./plugins.nix {inherit lib self;};
typesLanguage = import ./languages.nix {inherit lib;};
customTypes = import ./custom.nix {inherit lib;};
in {

7
lib/types/plugins.nix
View file

@ -1,4 +1,7 @@
{lib}: let
{
lib,
self,
}: let
inherit (lib.options) mkOption;
inherit (lib.attrsets) attrNames mapAttrs' filterAttrs nameValuePair;
inherit (lib.strings) hasPrefix removePrefix;
@ -12,7 +15,7 @@
mapAttrs' (n: v: nameValuePair (removePrefix prefix n) {src = v;}) (filterAttrs (n: _: hasPrefix prefix n) inputs);
# Get the names of all npins
pluginInputNames = attrNames (lib.importJSON ../../npins/sources.json).pins;
pluginInputNames = ["blink-cmp"] ++ attrNames self.pins;
# You can either use the name of the plugin or a package.
pluginType = nullOr (

9
modules/extra/deprecations.nix
View file

@ -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.

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

@ -34,12 +34,6 @@ in {
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 +138,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) nullOr either str listOf 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 = either str (listOf 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 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

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.
'';
};
};
};

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.
'';
};
};
};
}

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;

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

@ -81,7 +81,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);

2
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";

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";

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);

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

@ -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

14
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 = [
@ -48,13 +45,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;

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

@ -54,7 +54,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;

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

@ -2,6 +2,7 @@
config,
pkgs,
lib,
inputs,
...
}: let
inherit (builtins) attrNames;
@ -27,7 +28,7 @@
else ''{"${package}/bin/${defaultCmd}"}'';
servers = {
nil = {
package = pkgs.nil;
package = inputs.nil.packages.${pkgs.stdenv.system}.nil;
internalFormatter = true;
lspConfig = ''
lspconfig.nil_ls.setup{
@ -143,7 +144,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);

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

@ -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"]'';

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";

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

@ -77,7 +77,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";

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

@ -101,6 +101,7 @@
"eslint.config.js"
"eslint.config.mjs"
".eslintrc"
".eslintrc.cjs"
".eslintrc.json"
".eslintrc.js"
".eslintrc.yml"
@ -120,7 +121,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";

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

@ -76,7 +76,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";

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);

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

@ -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);

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

@ -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"

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

@ -109,7 +109,7 @@ in {
type = nullOr str;
default = null;
description = ''
The indicatotor icon to use for the current buffer.
The indicator icon to use for the current buffer.
::: {.warning}
This **must** be omitted while style is not `icon`

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

@ -2,6 +2,7 @@
imports = [
# treesitter extras
./ts-context
./ts-textobjects
./treesitter.nix
./config.nix

23
modules/plugins/treesitter/ts-textobjects/config.nix Normal file
View file

@ -0,0 +1,23 @@
{
config,
lib,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.dag) entryAfter;
inherit (config.vim) treesitter;
cfg = treesitter.textobjects;
in {
config = mkIf (treesitter.enable && cfg.enable) {
vim = {
startPlugins = ["nvim-treesitter-textobjects"];
# set up treesitter-textobjects after Treesitter, whose config we're adding to.
pluginRC.treesitter-textobjects = entryAfter ["treesitter"] ''
require("nvim-treesitter.configs").setup({textobjects = ${toLuaObject cfg.setupOpts}})
'';
};
};
}

6
modules/plugins/treesitter/ts-textobjects/default.nix Normal file
View file

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

21
modules/plugins/treesitter/ts-textobjects/textobjects.nix Normal file
View file

@ -0,0 +1,21 @@
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.types) mkPluginSetupOption;
in {
options.vim.treesitter.textobjects = {
enable = mkEnableOption "Treesitter textobjects";
setupOpts =
mkPluginSetupOption "treesitter-textobjects" {}
// {
example = {
select = {
enable = true;
lookahead = true;
keymaps = {
af = "@function.outer";
};
};
};
};
};
}

96
modules/plugins/ui/breadcrumbs/breadcrumbs.nix
View file

@ -4,7 +4,7 @@
...
}: let
inherit (lib.options) mkOption mkEnableOption;
inherit (lib.types) nullOr listOf enum bool str int either;
inherit (lib.types) nullOr listOf enum bool str int;
inherit (lib.modules) mkRenamedOptionModule;
inherit (lib.nvim.types) mkPluginSetupOption borderType;
mkSimpleIconOption = default:
@ -74,7 +74,7 @@ in {
::: {.note}
This will pass `draw_empty` to the `nvim_navic` winbar
component, which causes the component to be drawn even
if it's empty
if it's empty.
:::
'';
};
@ -86,145 +86,163 @@ in {
close = mkOption {
type = str;
default = "<esc>";
description = "keybinding to close Navbuddy UI";
description = "Close and return the cursor to its original location.";
};
nextSibling = mkOption {
type = str;
default = "j";
description = "keybinding to navigate to the next sibling node";
description = "Navigate to the next sibling node.";
};
previousSibling = mkOption {
type = str;
default = "k";
description = "keybinding to navigate to the previous sibling node";
description = "Navigate to the previous sibling node.";
};
parent = mkOption {
type = str;
default = "h";
description = "keybinding to navigate to the parent node";
description = "Navigate to the parent node.";
};
children = mkOption {
type = str;
default = "l";
description = "keybinding to navigate to the child node";
description = "Navigate to the child node.";
};
root = mkOption {
type = str;
default = "0";
description = "keybinding to navigate to the root node";
description = "Navigate to the root node.";
};
visualName = mkOption {
type = str;
default = "v";
description = "visual selection of name";
description = "Select the name visually.";
};
visualScope = mkOption {
type = str;
default = "V";
description = "visual selection of scope";
description = "Select the scope visually.";
};
yankName = mkOption {
type = str;
default = "y";
description = "yank the name to system clipboard";
description = "Yank the name to system clipboard.";
};
yankScope = mkOption {
type = str;
default = "Y";
description = "yank the scope to system clipboard";
description = "Yank the scope to system clipboard.";
};
insertName = mkOption {
type = str;
default = "i";
description = "insert at start of name";
description = "Insert at the start of name.";
};
insertScope = mkOption {
type = str;
default = "I";
description = "insert at start of scope";
description = "Insert at the start of scope.";
};
appendName = mkOption {
type = str;
default = "a";
description = "insert at end of name";
description = "Insert at the end of name.";
};
appendScope = mkOption {
type = str;
default = "A";
description = "insert at end of scope";
description = "Insert at the end of scope.";
};
rename = mkOption {
type = str;
default = "r";
description = "rename the node";
description = "Rename the node.";
};
delete = mkOption {
type = str;
default = "d";
description = "delete the node";
description = "Delete the node.";
};
foldCreate = mkOption {
type = str;
default = "f";
description = "create a new fold";
description = "Create a new fold of the node.";
};
foldDelete = mkOption {
type = str;
default = "F";
description = "delete the current fold";
description = "Delete the current fold of the node.";
};
comment = mkOption {
type = str;
default = "c";
description = "comment the node";
description = "Comment the node.";
};
select = mkOption {
type = str;
default = "<enter>";
description = "goto selected symbol";
description = "Goto the node.";
};
moveDown = mkOption {
type = str;
default = "J";
description = "move focused node down";
description = "Move the node down.";
};
moveUp = mkOption {
type = str;
default = "K";
description = "move focused node up";
description = "Move the node up.";
};
togglePreview = mkOption {
type = str;
default = "s";
description = "Toggle the preview.";
};
vsplit = mkOption {
type = str;
default = "<C-v>";
description = "Open the node in a vertical split.";
};
hsplit = mkOption {
type = str;
default = "<C-s>";
description = "Open the node in a horizontal split.";
};
telescope = mkOption {
type = str;
default = "t";
description = "fuzzy finder at current level";
description = "Start fuzzy finder at the current level.";
};
help = mkOption {
type = str;
default = "g?";
description = "open mapping help window";
description = "Open the mappings help window.";
};
};
@ -232,7 +250,7 @@ in {
useDefaultMappings = mkOption {
type = bool;
default = true;
description = "use default Navbuddy keybindings (disables user-specified keybinds)";
description = "Add the default Navbuddy keybindings in addition to the keybinding added by this module.";
};
window = {
@ -242,13 +260,13 @@ in {
border = mkOption {
type = borderType;
default = config.vim.ui.borders.globalStyle;
description = "border style to use";
description = "The border style to use.";
};
scrolloff = mkOption {
type = nullOr int;
default = null;
description = "Scrolloff value within navbuddy window";
description = "The scrolloff value within a navbuddy window.";
};
sections = {
@ -265,7 +283,7 @@ in {
border = mkOption {
type = borderType;
default = config.vim.ui.borders.globalStyle;
description = "border style to use for the left section of Navbuddy UI";
description = "The border style to use for the left section of the Navbuddy UI.";
};
};
@ -282,7 +300,7 @@ in {
border = mkOption {
type = borderType;
default = config.vim.ui.borders.globalStyle;
description = "border style to use for the middle section of Navbuddy UI";
description = "The border style to use for the middle section of the Navbuddy UI.";
};
};
@ -292,13 +310,13 @@ in {
border = mkOption {
type = borderType;
default = config.vim.ui.borders.globalStyle;
description = "border style to use for the right section of Navbuddy UI";
description = "The border style to use for the right section of the Navbuddy UI.";
};
preview = mkOption {
type = enum ["leaf" "always" "never"];
default = "leaf";
description = "display mode of the preview on the right section";
description = "The display mode of the preview on the right section.";
};
};
};
@ -317,13 +335,13 @@ in {
auto_attach = mkOption {
type = bool;
default = true;
description = "Whether to attach to LSP server manually";
description = "Whether to attach to LSP server manually.";
};
preference = mkOption {
type = nullOr (listOf str);
default = null;
description = "list of lsp server names in order of preference";
description = "The preference list ranking LSP servers.";
};
};
@ -331,25 +349,25 @@ in {
followNode = mkOption {
type = bool;
default = true;
description = "keep the current node in focus on the source buffer";
description = "Whether to keep the current node in focus in the source buffer.";
};
highlight = mkOption {
type = bool;
default = true;
description = "highlight the currently focused node";
description = "Whether to highlight the currently focused node in the source buffer.";
};
reorient = mkOption {
type = enum ["smart" "top" "mid" "none"];
default = "smart";
description = "reorient buffer after changing nodes";
description = "The mode for reorienting the source buffer after moving nodes.";
};
scrolloff = mkOption {
type = nullOr int;
default = null;
description = "scrolloff value when navbuddy is open";
description = "The scrolloff value in the source buffer when Navbuddy is open.";
};
};

5
modules/plugins/ui/breadcrumbs/config.nix
View file

@ -64,6 +64,11 @@ in {
${cfg.navbuddy.mappings.moveDown} = mkLuaInline "actions.move_down()";
${cfg.navbuddy.mappings.moveUp} = mkLuaInline "actions.move_up()";
${cfg.navbuddy.mappings.togglePreview} = mkLuaInline "actions.toggle_preview()";
${cfg.navbuddy.mappings.vsplit} = mkLuaInline "actions.vsplit()";
${cfg.navbuddy.mappings.hsplit} = mkLuaInline "actions.hsplit()";
${cfg.navbuddy.mappings.telescope} = mkLuaInline ''
actions.telescope({
layout_strategy = "horizontal",

15
modules/wrapper/build/config.nix
View file

@ -51,7 +51,7 @@
doCheck = false;
};
inherit (inputs.self.legacyPackages.${pkgs.stdenv.system}) blink-cmp;
inherit (inputs.self.packages.${pkgs.stdenv.system}) blink-cmp;
};
buildConfigPlugins = plugins:
@ -62,17 +62,14 @@
filter (f: f != null) plugins
);
# built (or "normalized") plugins that are modified
builtStartPlugins = buildConfigPlugins config.vim.startPlugins;
builtOptPlugins = map (package: package // {optional = true;}) (
buildConfigPlugins config.vim.optPlugins
);
# Wrap the user's desired (unwrapped) Neovim package with arguments that'll be used to
# generate a wrapped Neovim package.
neovim-wrapped = inputs.mnw.lib.wrap pkgs {
neovim-wrapped = inputs.mnw.lib.wrap {inherit pkgs;} {
neovim = config.vim.package;
plugins = builtStartPlugins ++ builtOptPlugins;
plugins = {
start = buildConfigPlugins config.vim.startPlugins;
opt = buildConfigPlugins config.vim.optPlugins;
};
appName = "nvf";
extraBinPath = config.vim.extraPackages;
initLua = config.vim.builtLuaConfigRC;

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

@ -11,13 +11,14 @@ in {
description = ''
[official documentation]: https://neovim.io/doc/user/lua.html#vim.loader.enable()
the experimental Lua module loader to speed up the start up process
Whethere to enable the experimental Lua module loader to speed up the start
up process. If `true`, this will enable the experimental Lua module loader
which:
If `true`, this will enable the experimental Lua module loader which:
- overrides loadfile
- adds the lua loader using the byte-compilation cache
- adds the libs loader
- removes the default Neovim loader
* overrides loadfile
* adds the lua loader using the byte-compilation cache
* adds the libs loader
* removes the default Neovim loader
::: {.note}
The Lua module loader is *disabled* by default. Before setting this option, please

197
npins/sources.json
View file

@ -39,22 +39,6 @@
"url": "https://github.com/rrethy/base16-nvim/archive/965160025d0facbe9caa863e5beef2a7a488e9d1.tar.gz",
"hash": "02w1mn15gydma9canvqrlwf4l5z76s1vs01zanipwwflvwclsb8f"
},
"blink-cmp": {
"type": "GitRelease",
"repository": {
"type": "GitHub",
"owner": "saghen",
"repo": "blink.cmp"
},
"pre_releases": false,
"version_upper_bound": null,
"release_prefix": null,
"submodules": false,
"version": "v1.1.1",
"revision": "fe2e1d3e4498d60c5ce7440ff60f79f0920e34bf",
"url": "https://api.github.com/repos/saghen/blink.cmp/tarball/v1.1.1",
"hash": "0l2m4162vk6xqrx5v0zh1b5p6wrr1jailq1995f101isyjygikan"
},
"blink-cmp-spell": {
"type": "Git",
"repository": {
@ -103,9 +87,9 @@
},
"branch": "main",
"submodules": false,
"revision": "89c4d158bc6d6ca03b4059452f2f9ffaa850db8a",
"url": "https://github.com/mikavilpas/blink-ripgrep.nvim/archive/89c4d158bc6d6ca03b4059452f2f9ffaa850db8a.tar.gz",
"hash": "04xh5hzbzvm0nvipsy0cw7k1vb1kcrb09xiw0j66cqddjvvpv6zk"
"revision": "0a2c3c1ce8c3c56e7490cae835a981d5dbeb472c",
"url": "https://github.com/mikavilpas/blink-ripgrep.nvim/archive/0a2c3c1ce8c3c56e7490cae835a981d5dbeb472c.tar.gz",
"hash": "11wc0qdalz7fb6zpdvrdib1bx3qyvcbn3hr0h57plspln55rjhl5"
},
"bufdelete-nvim": {
"type": "Git",
@ -129,9 +113,9 @@
},
"branch": "main",
"submodules": false,
"revision": "5b5e3aef9ad7af84f463d17b5479f06b87d5c429",
"url": "https://github.com/catppuccin/nvim/archive/5b5e3aef9ad7af84f463d17b5479f06b87d5c429.tar.gz",
"hash": "0jmrwag2dx4b1g9x32xwxcr8y0l159hqks09z5miy99wav6dy7z2"
"revision": "b7bbdf93b42866f166af98d39a2563eedb7cabac",
"url": "https://github.com/catppuccin/nvim/archive/b7bbdf93b42866f166af98d39a2563eedb7cabac.tar.gz",
"hash": "0f8wcpig84kihbz31w0hap4qs5gsdvch4sk2krn29v3k5bh3kcv0"
},
"ccc-nvim": {
"type": "Git",
@ -272,9 +256,9 @@
},
"branch": "main",
"submodules": false,
"revision": "c861811f8b825d30c0343951336d2bb8c8f6d990",
"url": "https://github.com/olimorris/codecompanion.nvim/archive/c861811f8b825d30c0343951336d2bb8c8f6d990.tar.gz",
"hash": "0a1mzwh07lhrx893w7xdlhgiivbrwqp7a0b9wkdrna99x8kd9d77"
"revision": "e55bbf5f6969ab41414d3fd68011366d3b80d024",
"url": "https://github.com/olimorris/codecompanion.nvim/archive/e55bbf5f6969ab41414d3fd68011366d3b80d024.tar.gz",
"hash": "12jas52gh1dl33ir0bkxpqnfxjdkwh7h03qvfk1b3qk2fmr0abqn"
},
"codewindow-nvim": {
"type": "Git",
@ -350,9 +334,9 @@
},
"branch": "main",
"submodules": false,
"revision": "73d2c590c74a0c582144987a4decb4a642755859",
"url": "https://github.com/Saecki/crates.nvim/archive/73d2c590c74a0c582144987a4decb4a642755859.tar.gz",
"hash": "08dyl4blgi0lb3s0jbl4jcpr4j1ncyrdvxjkrqmhqcg6bmwl7iqy"
"revision": "2c8f4fab02e3e9ea42c6ad9b547e4207a914a397",
"url": "https://github.com/Saecki/crates.nvim/archive/2c8f4fab02e3e9ea42c6ad9b547e4207a914a397.tar.gz",
"hash": "0ddlm94v3gh1znacghvfpfmkgv6js9i62gf7mlqcrpz8snpf879s"
},
"csharpls-extended-lsp-nvim": {
"type": "Git",
@ -363,9 +347,9 @@
},
"branch": "master",
"submodules": false,
"revision": "53c6dfc9790d262edd3d6a4483294bedf53d70f5",
"url": "https://github.com/Decodetalkers/csharpls-extended-lsp.nvim/archive/53c6dfc9790d262edd3d6a4483294bedf53d70f5.tar.gz",
"hash": "0hy3jaq5lq72yfvy77hijp8wzpbad7a1xfwrdljzbpm4w5j59dm2"
"revision": "c1edd1eaad2e649d3de8121337e3c515ac6db46e",
"url": "https://github.com/Decodetalkers/csharpls-extended-lsp.nvim/archive/c1edd1eaad2e649d3de8121337e3c515ac6db46e.tar.gz",
"hash": "03sjrkay6c6ivd9zpm7isa9izxsvspkvbvy7f61nl020splhbl9m"
},
"dashboard-nvim": {
"type": "Git",
@ -376,9 +360,9 @@
},
"branch": "master",
"submodules": false,
"revision": "b0551fae871fc39454a67cca1adcf76fbe2f61f9",
"url": "https://github.com/glepnir/dashboard-nvim/archive/b0551fae871fc39454a67cca1adcf76fbe2f61f9.tar.gz",
"hash": "0m67ij62dwnzyspyckhqvcsk81nvc16gx8zphghw4w2w4vl9lsrj"
"revision": "591b5b29e2f17b97496ec3179f6ecd08bb8502cc",
"url": "https://github.com/glepnir/dashboard-nvim/archive/591b5b29e2f17b97496ec3179f6ecd08bb8502cc.tar.gz",
"hash": "1f9ii3scd3zh4fch6h0mfmnfjx2fk6y4v3qc0cijk1vnyp2fm9qc"
},
"diffview-nvim": {
"type": "Git",
@ -454,9 +438,9 @@
},
"branch": "main",
"submodules": false,
"revision": "2f2e8d7010a0e5e725957828476b4e1625eaf82c",
"url": "https://github.com/Chaitanyabsprip/fastaction.nvim/archive/2f2e8d7010a0e5e725957828476b4e1625eaf82c.tar.gz",
"hash": "0m2qplldlcgzb6n5lwnwiac5n56zpyf3df015abfwrwba95zflfv"
"revision": "41545d9d02a53d03b5f4da5881e8f30a7dc16031",
"url": "https://github.com/Chaitanyabsprip/fastaction.nvim/archive/41545d9d02a53d03b5f4da5881e8f30a7dc16031.tar.gz",
"hash": "1is587xa1b2fim4s3qc13ggwgpm02y4dmh64l4xjh6gyilh3fmkb"
},
"fidget-nvim": {
"type": "Git",
@ -506,9 +490,9 @@
},
"branch": "main",
"submodules": false,
"revision": "fc8f183479a472df60aa86f00e295462f2308178",
"url": "https://github.com/rafamadriz/friendly-snippets/archive/fc8f183479a472df60aa86f00e295462f2308178.tar.gz",
"hash": "1clmyxkw0gk9p9j72d75byws75vi3r7d04wica2dq5i0zkk49b27"
"revision": "572f5660cf05f8cd8834e096d7b4c921ba18e175",
"url": "https://github.com/rafamadriz/friendly-snippets/archive/572f5660cf05f8cd8834e096d7b4c921ba18e175.tar.gz",
"hash": "08q7vs7p4grav819b6hl5y9zla8bbb461b6m1w0mjz6n6rqjjc0p"
},
"fzf-lua": {
"type": "Git",
@ -519,9 +503,9 @@
},
"branch": "main",
"submodules": false,
"revision": "b11467c3fbfe48e4a815e4909f5c4e5b413ce6d0",
"url": "https://github.com/ibhagwan/fzf-lua/archive/b11467c3fbfe48e4a815e4909f5c4e5b413ce6d0.tar.gz",
"hash": "1yjfyz0fchibyb6wnnyxarn2v4fxxfvf9vy1pyvfc7mz5b4mzwc2"
"revision": "1cc70fb29e63ff26acba1e0cbca04705f8a485f1",
"url": "https://github.com/ibhagwan/fzf-lua/archive/1cc70fb29e63ff26acba1e0cbca04705f8a485f1.tar.gz",
"hash": "032y3djil7bsb2h0sv5a0a1qg805j5p2jxxp01jcpmn870b6mcjd"
},
"gesture-nvim": {
"type": "Git",
@ -584,9 +568,9 @@
},
"branch": "main",
"submodules": false,
"revision": "9cd665f46ab7af2e49d140d328b8e72ea1cf511b",
"url": "https://github.com/lewis6991/gitsigns.nvim/archive/9cd665f46ab7af2e49d140d328b8e72ea1cf511b.tar.gz",
"hash": "110ykgvd3hbjq8ilz1yvfcic1jpqzyz4r13dswmpv7nvsi7a2lb5"
"revision": "1796c7cedfe7e5dd20096c5d7b8b753d8f8d22eb",
"url": "https://github.com/lewis6991/gitsigns.nvim/archive/1796c7cedfe7e5dd20096c5d7b8b753d8f8d22eb.tar.gz",
"hash": "0xzmj3z3rd1zxv5hc87ncmnrzm6653ffaif9xkpvnc3n8l81ybsn"
},
"glow-nvim": {
"type": "Git",
@ -610,9 +594,9 @@
},
"branch": "main",
"submodules": false,
"revision": "c54db7f7e67832fbdd0ac14633f62c8a6997ddcf",
"url": "https://github.com/ellisonleao/gruvbox.nvim/archive/c54db7f7e67832fbdd0ac14633f62c8a6997ddcf.tar.gz",
"hash": "0i7dh2d3l1w6bga6gpfssam7w1qkd84q3cxyscdfsf4j9z4b62l2"
"revision": "91a0f8e460197a521d42a2e84a7a2a4010be4bbb",
"url": "https://github.com/ellisonleao/gruvbox.nvim/archive/91a0f8e460197a521d42a2e84a7a2a4010be4bbb.tar.gz",
"hash": "1bmxps0wawyvwyzcwzdxbf1wcqx6v7h6afj3yzgb38gz649wr8q7"
},
"hardtime-nvim": {
"type": "Git",
@ -649,9 +633,9 @@
},
"branch": "master",
"submodules": false,
"revision": "fda0e5082ecc1c9e892f38b715d6f61e8829081d",
"url": "https://github.com/mrcjkb/haskell-tools.nvim/archive/fda0e5082ecc1c9e892f38b715d6f61e8829081d.tar.gz",
"hash": "0hi0ww7q0j042ssjk7x3d4s4vaninawpw3s0yrv1c4l1q5v6gnz1"
"revision": "3bec28d8b0006be596497a5e1a03bda6ef6131cf",
"url": "https://github.com/mrcjkb/haskell-tools.nvim/archive/3bec28d8b0006be596497a5e1a03bda6ef6131cf.tar.gz",
"hash": "1kf3w7x8awa4iiw7ab8xfjh6fq47yvv6h2rmfw0jf8s99fvgarj2"
},
"highlight-undo-nvim": {
"type": "Git",
@ -847,9 +831,9 @@
},
"branch": "master",
"submodules": false,
"revision": "c9b9a22904c97d0eb69ccb9bab76037838326817",
"url": "https://github.com/L3MON4D3/LuaSnip/archive/c9b9a22904c97d0eb69ccb9bab76037838326817.tar.gz",
"hash": "03anxdspqz7ylq4239jyr9y51mw5qw1lkccyvfhj6wfk43jjdryx"
"revision": "7351d673f430e89f11962dc45b7360d6a0a26d2d",
"url": "https://github.com/L3MON4D3/LuaSnip/archive/7351d673f430e89f11962dc45b7360d6a0a26d2d.tar.gz",
"hash": "0dd42ss93cppq3cp27336gail955lckqqc6bafkmawplxh93qn1q"
},
"lz-n": {
"type": "Git",
@ -877,6 +861,18 @@
"url": "https://github.com/horriblename/lzn-auto-require/archive/ef746afb55467984ef3200d9709c8059ee0257d0.tar.gz",
"hash": "1mgka1mmvpd2gfya898qdbbwrp5rpqds8manjs1s7g5x63xp6b98"
},
"markview-nvim": {
"type": "Git",
"repository": {
"type": "GitHub",
"owner": "OXY2DEV",
"repo": "markview.nvim"
},
"branch": "main",
"revision": "6c92a6455e97c954a4a419265a032fedd69846f6",
"url": "https://github.com/OXY2DEV/markview.nvim/archive/6c92a6455e97c954a4a419265a032fedd69846f6.tar.gz",
"hash": "01sw4iscnciyifpba4cwjb6fs95wrkk60xvqq67b8d5j8yb5449a"
},
"mind-nvim": {
"type": "Git",
"repository": {
@ -1490,9 +1486,9 @@
},
"branch": "main",
"submodules": false,
"revision": "299e174c3b8373c9c1f9be0bc3967c852712d0f3",
"url": "https://github.com/nvim-neo-tree/neo-tree.nvim/archive/299e174c3b8373c9c1f9be0bc3967c852712d0f3.tar.gz",
"hash": "0vm7hbcqj548pvl9vfmzsgpx73lmrnmhp399bprizg87zn73m005"
"revision": "71bfdeddc90225e281ce34c378dc1b5914f5018d",
"url": "https://github.com/nvim-neo-tree/neo-tree.nvim/archive/71bfdeddc90225e281ce34c378dc1b5914f5018d.tar.gz",
"hash": "0cm4y2idpmf7i6daa4wl5b6n5ldzqr3pqmh29rc645c1xk2y0b80"
},
"neocord": {
"type": "Git",
@ -1516,9 +1512,9 @@
},
"branch": "main",
"submodules": false,
"revision": "35da593c55d78086a3203ee3e6d749fafe2e4e73",
"url": "https://github.com/nvim-neorg/neorg/archive/35da593c55d78086a3203ee3e6d749fafe2e4e73.tar.gz",
"hash": "0kxygwpfffa0blcy54g7cvm5laj77q0f72p69s43j9dpsps1h63y"
"revision": "8fdd9b2986acfb4ce310bebfc338111793862f00",
"url": "https://github.com/nvim-neorg/neorg/archive/8fdd9b2986acfb4ce310bebfc338111793862f00.tar.gz",
"hash": "0xv3aasbhambywp6idhz44nlsh3hlarw3j7wwx7wn1whm6xbwvf6"
},
"neorg-telescope": {
"type": "Git",
@ -1594,9 +1590,9 @@
},
"branch": "main",
"submodules": false,
"revision": "751349f21bdf1acf7af091fead456866bf9a7e7d",
"url": "https://github.com/nvimtools/none-ls.nvim/archive/751349f21bdf1acf7af091fead456866bf9a7e7d.tar.gz",
"hash": "1zhqyjs914ib1yq42xq3aphw8pl4168h2k3ybm92z00ahi51kbqn"
"revision": "a49f5a79cdb76e0dc1a98899c8598f4db014c5e7",
"url": "https://github.com/nvimtools/none-ls.nvim/archive/a49f5a79cdb76e0dc1a98899c8598f4db014c5e7.tar.gz",
"hash": "0x16saxsr3w3ivqpdjg05bkyfxzsiyfpsiwhyzsvqxg1qnkda3b2"
},
"nord": {
"type": "Git",
@ -1776,9 +1772,9 @@
},
"branch": "master",
"submodules": false,
"revision": "641e567f975feab3815b47c7d29e6148e07afa77",
"url": "https://github.com/neovim/nvim-lspconfig/archive/641e567f975feab3815b47c7d29e6148e07afa77.tar.gz",
"hash": "1238hk6v3mm6hzjbipz60rva7crv95h2vzg6ph9wzplq52kzryav"
"revision": "46434074f188e6bfccf9d9153dd8be6b1381498b",
"url": "https://github.com/neovim/nvim-lspconfig/archive/46434074f188e6bfccf9d9153dd8be6b1381498b.tar.gz",
"hash": "0h13n1vjw6v8gp41yfc6qffbwwrxw81vcilkmxx9sim6671w5pzp"
},
"nvim-metals": {
"type": "Git",
@ -1802,9 +1798,9 @@
},
"branch": "master",
"submodules": false,
"revision": "f22bac988f2dd073601d75ba39ea5636ab6e38cb",
"url": "https://github.com/SmiteshP/nvim-navbuddy/archive/f22bac988f2dd073601d75ba39ea5636ab6e38cb.tar.gz",
"hash": "034pmg403y0y1fxnb1jv291mr016bx1vn68y543v6v4dpbdlr7di"
"revision": "a34786c77a528519f6b8a142db7609f6e387842d",
"url": "https://github.com/SmiteshP/nvim-navbuddy/archive/a34786c77a528519f6b8a142db7609f6e387842d.tar.gz",
"hash": "0b6bazh531bixskpmmpkidqii4n3m7n2cp9bmzml5wb0wibazcac"
},
"nvim-navic": {
"type": "Git",
@ -1815,9 +1811,9 @@
},
"branch": "master",
"submodules": false,
"revision": "39231352aec0d1e09cebbffdd9dc20a5dc691ffe",
"url": "https://github.com/SmiteshP/nvim-navic/archive/39231352aec0d1e09cebbffdd9dc20a5dc691ffe.tar.gz",
"hash": "1xj2bzax8hynm2x9zbvsaxv1j22chklyygzm1kbqxxs077qn45ws"
"revision": "d0a8c17c4dc721b00bc2ac305c6ffbb036beeb74",
"url": "https://github.com/SmiteshP/nvim-navic/archive/d0a8c17c4dc721b00bc2ac305c6ffbb036beeb74.tar.gz",
"hash": "0mxsnwvrjirpy2ichsilx6207z55xi42syg5d3fdgs2r1p1npggc"
},
"nvim-neoclip-lua": {
"type": "Git",
@ -1910,6 +1906,19 @@
"url": "https://github.com/nvim-treesitter/nvim-treesitter-context/archive/6daca3ad780f045550b820f262002f35175a6c04.tar.gz",
"hash": "0qprwd44hw9sz0vh14p6lpvs9vxrick462pfkradmal6ak1kfwn3"
},
"nvim-treesitter-textobjects": {
"type": "Git",
"repository": {
"type": "GitHub",
"owner": "nvim-treesitter",
"repo": "nvim-treesitter-textobjects"
},
"branch": "master",
"submodules": false,
"revision": "0e3be38005e9673d044e994b1e4b123adb040179",
"url": "https://github.com/nvim-treesitter/nvim-treesitter-textobjects/archive/0e3be38005e9673d044e994b1e4b123adb040179.tar.gz",
"hash": "0y93pj3asarw7jhk4cdphhx6awxdyiwajc0n9nr4836gn48qcs85"
},
"nvim-ts-autotag": {
"type": "Git",
"repository": {
@ -1932,9 +1941,9 @@
},
"branch": "main",
"submodules": false,
"revision": "d4c8bdb06b7a589f004a53bf710196967752c63d",
"url": "https://github.com/kevinhwang91/nvim-ufo/archive/d4c8bdb06b7a589f004a53bf710196967752c63d.tar.gz",
"hash": "11zcr6vvj6gm5di63w55ccvwf2x7his8v9v8bingsz6l6n79dk6v"
"revision": "cac999ec9f6302d2fd4ad8a846bf8f731af6e7cf",
"url": "https://github.com/kevinhwang91/nvim-ufo/archive/cac999ec9f6302d2fd4ad8a846bf8f731af6e7cf.tar.gz",
"hash": "14lvlv1wmbpw0dpyfz3gq7k760ip1903w5ibajqiaflw06afv4pn"
},
"nvim-web-devicons": {
"type": "Git",
@ -1945,9 +1954,9 @@
},
"branch": "master",
"submodules": false,
"revision": "50b5b06bff13a9b4eab946de7c7033649a6618a1",
"url": "https://github.com/nvim-tree/nvim-web-devicons/archive/50b5b06bff13a9b4eab946de7c7033649a6618a1.tar.gz",
"hash": "1jsrwcsyjwlzk2l3x417pr6s6cq4zk6b6k417hhmrprrw66ajdb6"
"revision": "2c2b4eafce6cdd0cb165036faa17396eff18f847",
"url": "https://github.com/nvim-tree/nvim-web-devicons/archive/2c2b4eafce6cdd0cb165036faa17396eff18f847.tar.gz",
"hash": "11yp02zg60gdmqa6rdk3rjn704k2kvjcs41w85y01b68k36w7pw2"
},
"obsidian-nvim": {
"type": "Git",
@ -2010,9 +2019,9 @@
},
"branch": "master",
"submodules": false,
"revision": "27ab1cf9e7ae142f9e9ffb218be50dd920f04cb3",
"url": "https://github.com/nvim-orgmode/orgmode/archive/27ab1cf9e7ae142f9e9ffb218be50dd920f04cb3.tar.gz",
"hash": "176v9y36258jm8h3aaph57wgr6s7rgmgdnq9hgwialwn4bygfym0"
"revision": "15d66ead1285d99f8a21c4ef4874ac62e9320fe6",
"url": "https://github.com/nvim-orgmode/orgmode/archive/15d66ead1285d99f8a21c4ef4874ac62e9320fe6.tar.gz",
"hash": "05h766qj1vid5rs1mv8aiv6rsfrp0md9605sfr9vycip1rd8csgy"
},
"otter-nvim": {
"type": "Git",
@ -2140,9 +2149,9 @@
},
"branch": "main",
"submodules": false,
"revision": "78ffe3b0500bbc7e37fabde723d96661538e8b32",
"url": "https://github.com/MeanderingProgrammer/render-markdown.nvim/archive/78ffe3b0500bbc7e37fabde723d96661538e8b32.tar.gz",
"hash": "00dn9cpdvm7dy4xyhaij2rs0g0l926cqvjn03v06sray3adbyij5"
"revision": "57c7f33f276876c994898683680da9e3a3590d0d",
"url": "https://github.com/MeanderingProgrammer/render-markdown.nvim/archive/57c7f33f276876c994898683680da9e3a3590d0d.tar.gz",
"hash": "1lfypdqyka5idrkr3w62vx7j6p75r3ld7sz5i40y41svglnxyrsj"
},
"rose-pine": {
"type": "Git",
@ -2153,9 +2162,9 @@
},
"branch": "main",
"submodules": false,
"revision": "96ff3993a67356ee85d1cdab9be652cdc1c5d1ac",
"url": "https://github.com/rose-pine/neovim/archive/96ff3993a67356ee85d1cdab9be652cdc1c5d1ac.tar.gz",
"hash": "0p712rivi5i3zlrigm86p8vrn1nvg4qils86snlw717cq3scj9gj"
"revision": "614892e32e94378d976a238f287532cfe790c1fe",
"url": "https://github.com/rose-pine/neovim/archive/614892e32e94378d976a238f287532cfe790c1fe.tar.gz",
"hash": "1pi5z81xkgkx8yyfjfjj0hg66v2zcj04gxxbf5q2lqz70xcs3cgk"
},
"rtp-nvim": {
"type": "Git",
@ -2192,9 +2201,9 @@
},
"branch": "master",
"submodules": false,
"revision": "3f2b7a94b7fa3c0f301dfa9644c94b543000efc2",
"url": "https://github.com/mrcjkb/rustaceanvim/archive/3f2b7a94b7fa3c0f301dfa9644c94b543000efc2.tar.gz",
"hash": "1y3x6m3yglkyv37xgli9k3dlw59yy3jbsp1phx75xqma1480dzy5"
"revision": "4b8c2edb55f548ed9c683f88dde2ffb235413b03",
"url": "https://github.com/mrcjkb/rustaceanvim/archive/4b8c2edb55f548ed9c683f88dde2ffb235413b03.tar.gz",
"hash": "0d3kwvwj5cppwypvg8iasn5f8rviqyskkgh1wafs7chjm32dm4gb"
},
"smartcolumn-nvim": {
"type": "Git",
@ -2403,9 +2412,9 @@
},
"branch": "master",
"submodules": false,
"revision": "f985f5a4fbc410c9e5367f6b5863a8fa502e516d",
"url": "https://github.com/RRethy/vim-illuminate/archive/f985f5a4fbc410c9e5367f6b5863a8fa502e516d.tar.gz",
"hash": "0igx2i4k59vadhw7kgqvxjw9594n8p2n9yqszif9by8xq5gsd7g6"
"revision": "fbc16dee336d8cc0d3d2382ea4a53f4a29725abf",
"url": "https://github.com/RRethy/vim-illuminate/archive/fbc16dee336d8cc0d3d2382ea4a53f4a29725abf.tar.gz",
"hash": "072kgd7h7cjq4hskczxl60nsx3jpww9l7ypafcwk833ypahz899i"
},
"vim-markdown": {
"type": "Git",