NotAShelf/nvf
2
1
Fork 0
mirror of https://github.com/NotAShelf/nvf.git synced 2025-12-14 16:11:03 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Merge pull request #1160 from NotAShelf/notashelf/push-ysqzsqxwlsml

Browse source 
docs: migrate to feel-co/ndg
This commit is contained in:
Soliprem 2025-12-11 21:19:12 +01:00 • committed by GitHub
commit 966e96ff5d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
46 changed files with 940 additions and 1021 deletions
Download patch file Download diff file Expand all files Collapse all files

2
docs/default.nix
View file

@ -92,7 +92,7 @@
# Generate the HTML manual pages # Generate the HTML manual pages
html = pkgs.callPackage ./manual.nix { html = pkgs.callPackage ./manual.nix {
inherit release; inherit inputs release;
inherit (nvimModuleDocs) optionsJSON; inherit (nvimModuleDocs) optionsJSON;
}; };
in { in {

141
docs/manual.nix
View file

@ -1,114 +1,47 @@
{ {
lib, inputs,
stdenvNoCC,
fetchzip,
runCommandLocal,
# build inputs
nixos-render-docs,
documentation-highlighter,
dart-sass,
path, path,
# nrd configuration stdenvNoCC,
release, runCommandLocal,
optionsJSON, optionsJSON,
release,
} @ args: let } @ args: let
manual-release = args.release or "unstable"; manual-release = args.release or "unstable";
scss-reset = fetchzip {
url = "https://github.com/Frontend-Layers/scss-reset/archive/refs/tags/1.4.2.zip";
hash = "sha256-cif5Sx8Ca5vxdw/mNAgpulLH15TwmzyJFNM7JURpoaE=";
};
compileStylesheet = runCommandLocal "compile-nvf-stylesheet" {} ''
mkdir -p $out
tmpfile=$(mktemp -d)
trap "rm -r $tmpfile" EXIT
ln -s "${scss-reset}/build" "$tmpfile/scss-reset"
${dart-sass}/bin/sass --load-path "$tmpfile" \
${./static/style.scss} "$out/style.css"
echo "Generated styles"
'';
in in
stdenvNoCC.mkDerivation { runCommandLocal "nvf-docs-html" {
name = "nvf-manual"; nativeBuildInputs = [
src = builtins.path { (inputs.ndg.packages.${stdenvNoCC.system}.ndg.overrideAttrs
name = "nvf-manual-${manual-release}"; {
path = lib.sourceFilesBySuffices ./manual [".md" ".md.in"]; # FIXME: the tests take too long to build
}; doCheck = false;
})
];
} ''
mkdir -p $out/share/doc
strictDependencies = true; # Copy the markdown sources to be processed by ndg. This is not
nativeBuildInputs = [nixos-render-docs]; # strictly necessary, but allows us to modify the Markdown sources
# as we see fit.
cp -rvf ${./manual} ./manual
postPatch = '' # Replace variables following the @VARIABLE@ style in the manual
ln -s ${optionsJSON}/share/doc/nixos/options.json ./config-options.json # pages. This can be built into ndg at a later date.
''; substituteInPlace ./manual/index.md \
--subst-var-by NVF_VERSION ${manual-release}
buildPhase = '' # Generate the final manual from a set of parameters. This uses
dest="$out/share/doc/nvf" # feel-co/ndg to render the web manual.
mkdir -p "$(dirname "$dest")" ndg html \
mkdir -p $dest/{highlightjs,script} --jobs $NIX_BUILD_CORES --title "NVF" \
--module-options ${optionsJSON}/share/doc/nixos/options.json \
--manpage-urls ${path}/doc/manpage-urls.json \
--options-depth 3 \
--generate-search \
--highlight-code \
--input-dir ./manual \
--output-dir "$out/share/doc"
# Copy highlight scripts to /highlights in document root. # Hydra support. Probably not necessary.
cp -vt $dest/highlightjs \ mkdir -p $out/nix-support/
${documentation-highlighter}/highlight.pack.js \ echo "doc manual $dest index.html" >> $out/nix-support/hydra-build-products
${documentation-highlighter}/LICENSE \ ''
${documentation-highlighter}/mono-blue.css \
${documentation-highlighter}/loader.js
# Copy anchor scripts to the script directory in document root.
cp -vt "$dest"/script \
${./static/script}/anchor-min.js \
${./static/script}/anchor-use.js \
${./static/script}/search.js
substituteInPlace ./options.md \
--subst-var-by OPTIONS_JSON ./config-options.json
substituteInPlace ./manual.md \
--subst-var-by NVF_VERSION ${manual-release}
substituteInPlace ./hacking/additional-plugins.md \
--subst-var-by NVF_REPO "https://github.com/notashelf/nvf/blob/${manual-release}"
# Move compiled stylesheet
cp -vt $dest \
${compileStylesheet}/style.css
# Move release notes
cp -vr ${./release-notes} release-notes
# Generate final manual from a set of parameters. Explanation of the CLI flags are
# as follows:
#
# 1. --manpage-urls will allow you to use manual pages as they are defined in
# the nixpkgs documentation.
# 2. --revision is the project revision as it is defined in 'release.json' in the
# repository root
# 3. --script will inject a given Javascript file into the resulting pages inside
# the <script> tag.
# 4. --toc-depth will determine the depth of the initial Table of Contents while
# --section-toc-depth will determine the depth of per-section Table of Contents
# sections.
nixos-render-docs manual html \
--manpage-urls ${path + "/doc/manpage-urls.json"} \
--revision ${lib.trivial.revisionWithDefault manual-release} \
--stylesheet style.css \
--script highlightjs/highlight.pack.js \
--script highlightjs/loader.js \
--script script/anchor-use.js \
--script script/anchor-min.js \
--script script/search.js \
--toc-depth 1 \
--section-toc-depth 1 \
manual.md \
"$dest/index.xhtml"
# Hydra support. Probably not necessary.
mkdir -p $out/nix-support/
echo "doc manual $dest index.html" >> $out/nix-support/hydra-build-products
'';
}

5
docs/manual/configuring.md
View file

@ -1,6 +1,7 @@
# Configuring nvf {#ch-configuring} # Configuring nvf {#ch-configuring}
[helpful tips section]: #ch-helpful-tips [helpful tips section]: ./tips.html#ch-helpful-tips
[options reference]: ./options.html
nvf allows for _very_ extensive configuration in Neovim through the Nix module 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 interface. The below chapters describe several of the options exposed in nvf for
@ -8,7 +9,7 @@ your convenience. You might also be interested in the [helpful tips section] for
more advanced or unusual configuration options supported by nvf. more advanced or unusual configuration options supported by nvf.
Note that this section does not cover module _options_. For an overview of all Note that this section does not cover module _options_. For an overview of all
module options provided by nvf, please visit the [appendix](/nvf/options.html) module options provided by nvf, please visit the [options reference]
```{=include=} chapters ```{=include=} chapters
configuring/custom-package.md configuring/custom-package.md

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

@ -1,22 +0,0 @@
# 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 [](#opt-vim.package) option.
```nix
{inputs, pkgs, ...}: {
# using the neovim-nightly overlay
vim.package = inputs.neovim-overlay.packages.${pkgs.stdenv.system}.neovim;
}
```
The neovim-nightly-overlay always exposes an unwrapped package. If using a
different source, you are highly recommended to get an "unwrapped" version of
the neovim package, similar to `neovim-unwrapped` in nixpkgs.
```nix
{ pkgs, ...}: {
# using the neovim-nightly overlay
vim.package = pkgs.neovim-unwrapped;
}
```

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

@ -19,7 +19,7 @@ as a module.
:::{.info} :::{.info}
To add a plugin to your runtime, you will need to add it to 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 {option}`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 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. never exposed to the outside world for purity and full isolation.

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

@ -1,17 +1,17 @@
# Legacy Method {#sec-legacy-method} # Legacy Method {#sec-legacy-method}
Prior to version **0.5**, the method of adding new plugins was adding the plugin 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 package to {option}`vim.startPlugins` and adding its configuration as a DAG
one of `vim.configRC` or [](#opt-vim.luaConfigRC). While `configRC` has been under one of `vim.configRC` or {option}`vim.luaConfigRC`. While `configRC` has
deprecated, users who have not yet updated to 0.5 or those who prefer a more been deprecated, users who have not yet updated to 0.5 or those who prefer a
hands-on approach may choose to use the old method where the load order of the more hands-on approach may choose to use the old method where the load order of
plugins is explicitly determined by DAGs without internal abstractions. the plugins is explicitly determined by DAGs without internal abstractions.
## Adding New Plugins {#sec-adding-new-plugins} ## Adding New Plugins {#sec-adding-new-plugins}
To add a plugin not available in **nvf** as a module to your configuration using 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 the legacy method, you must add it to {option}`vim.startPlugins` in order to
it available to Neovim at runtime. make it available to Neovim at runtime.
```nix ```nix
{pkgs, ...}: { {pkgs, ...}: {

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

@ -2,7 +2,7 @@
As of version **0.5**, we have a more extensive API for configuring plugins that 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 should be preferred over the legacy method. This API is available as
[](#opt-vim.extraPlugins). Instead of using DAGs exposed by the library {option}`vim.extraPlugins`. Instead of using DAGs exposed by the library
_directly_, you may use the extra plugin module as follows: _directly_, you may use the extra plugin module as follows:
```nix ```nix

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

@ -6,49 +6,87 @@ formatters, and `nvim-lint` linter integration. This gets you capabilities
ranging from autocompletion to formatting to diagnostics. The following ranging from autocompletion to formatting to diagnostics. The following
languages have sections under the `vim.languages` attribute. languages have sections under the `vim.languages` attribute.
- Rust: [vim.languages.rust.enable](#opt-vim.languages.rust.enable) - Rust:
- Nix: [vim.languages.nix.enable](#opt-vim.languages.nix.enable) [vim.languages.rust.enable](./options.html#option-vim-languages-rust-enable)
- SQL: [vim.languages.sql.enable](#opt-vim.languages.sql.enable) - Nix:
- C/C++: [vim.languages.clang.enable](#opt-vim.languages.clang.enable) [vim.languages.nix.enable](./options.html#option-vim-languages-nix-enable)
- Typescript/Javascript: [vim.languages.ts.enable](#opt-vim.languages.ts.enable) - SQL:
- Python: [vim.languages.python.enable](#opt-vim.languages.python.enable): [vim.languages.sql.enable](./options.html#option-vim-languages-sql-enable)
- Zig: [vim.languages.zig.enable](#opt-vim.languages.zig.enable) - C/C++:
- Markdown: [vim.languages.markdown.enable](#opt-vim.languages.markdown.enable) [vim.languages.clang.enable](./options.html#option-vim-languages-clang-enable)
- HTML: [vim.languages.html.enable](#opt-vim.languages.html.enable) - Typescript/Javascript:
- Dart: [vim.languages.dart.enable](#opt-vim.languages.dart.enable) [vim.languages.ts.enable](./options.html#option-vim-languages-ts-enable)
- Go: [vim.languages.go.enable](#opt-vim.languages.go.enable) - Python:
- Lua: [vim.languages.lua.enable](#opt-vim.languages.lua.enable) [vim.languages.python.enable](./options.html#option-vim-languages-python-enable):
- PHP: [vim.languages.php.enable](#opt-vim.languages.php.enable) - Zig:
- F#: [vim.languages.fsharp.enable](#opt-vim.languages.fsharp.enable) [vim.languages.zig.enable](./options.html#option-vim-languages-zig-enable)
- Assembly: [vim.languages.assembly.enable](#opt-vim.languages.assembly.enable) - Markdown:
- Astro: [vim.languages.astro.enable](#opt-vim.languages.astro.enable) [vim.languages.markdown.enable](./options.html#option-vim-languages-markdown-enable)
- Bash: [vim.languages.bash.enable](#opt-vim.languages.bash.enable) - HTML:
- Clang: [vim.languages.clang.enable](#opt-vim.languages.clang.enable) [vim.languages.html.enable](./options.html#option-vim-languages-html-enable)
- Clojure: [vim.languages.clojure.enable](#opt-vim.languages.clojure.enable) - Dart:
- C#: [vim.languages.csharp.enable](#opt-vim.languages.csharp.enable) [vim.languages.dart.enable](./options.html#option-vim-languages-dart-enable)
- CSS: [vim.languages.css.enable](#opt-vim.languages.css.enable) - Go: [vim.languages.go.enable](./options.html#option-vim-languages-go-enable)
- CUE: [vim.languages.cue.enable](#opt-vim.languages.cue.enable) - Lua:
- Elixir: [vim.languages.elixir.enable](#opt-vim.languages.elixir.enable) [vim.languages.lua.enable](./options.html#option-vim-languages-lua-enable)
- Gleam: [vim.languages.gleam.enable](#opt-vim.languages.gleam.enable) - PHP:
- HCL: [vim.languages.hcl.enable](#opt-vim.languages.hcl.enable) [vim.languages.php.enable](./options.html#option-vim-languages-php-enable)
- Helm: [vim.languages.helm.enable](#opt-vim.languages.helm.enable) - F#:
- Julia: [vim.languages.julia.enable](#opt-vim.languages.julia.enable) [vim.languages.fsharp.enable](./options.html#option-vim-languages-fsharp-enable)
- Kotlin: [vim.languages.kotlin.enable](#opt-vim.languages.kotlin.enable) - Assembly:
- Nim: [vim.languages.nim.enable](#opt-vim.languages.nim.enable) [vim.languages.assembly.enable](./options.html#option-vim-languages-assembly-enable)
- Nu: [vim.languages.nu.enable](#opt-vim.languages.nu.enable) - Astro:
- OCaml: [vim.languages.ocaml.enable](#opt-vim.languages.ocaml.enable) [vim.languages.astro.enable](./options.html#option-vim-languages-astro-enable)
- Odin: [vim.languages.odin.enable](#opt-vim.languages.odin.enable) - Bash:
- R: [vim.languages.r.enable](#opt-vim.languages.r.enable) [vim.languages.bash.enable](./options.html#option-vim-languages-bash-enable)
- Ruby: [vim.languages.ruby.enable](#opt-vim.languages.ruby.enable) - Clang:
- Scala: [vim.languages.scala.enable](#opt-vim.languages.scala.enable) [vim.languages.clang.enable](./options.html#option-vim-languages-clang-enable)
- Svelte: [vim.languages.svelte.enable](#opt-vim.languages.svelte.enable) - Clojure:
- Tailwind: [vim.languages.tailwind.enable](#opt-vim.languages.tailwind.enable) [vim.languages.clojure.enable](./options.html#option-vim-languages-clojure-enable)
- C#:
[vim.languages.csharp.enable](./options.html#option-vim-languages-csharp-enable)
- CSS:
[vim.languages.css.enable](./options.html#option-vim-languages-css-enable)
- CUE:
[vim.languages.cue.enable](./options.html#option-vim-languages-cue-enable)
- Elixir:
[vim.languages.elixir.enable](./options.html#option-vim-languages-elixir-enable)
- Gleam:
[vim.languages.gleam.enable](./options.html#option-vim-languages-gleam-enable)
- HCL:
[vim.languages.hcl.enable](./options.html#option-vim-languages-hcl-enable)
- Helm:
[vim.languages.helm.enable](./options.html#option-vim-languages-helm-enable)
- Julia:
[vim.languages.julia.enable](./options.html#option-vim-languages-julia-enable)
- Kotlin:
[vim.languages.kotlin.enable](./options.html#option-vim-languages-kotlin-enable)
- Nim:
[vim.languages.nim.enable](./options.html#option-vim-languages-nim-enable)
- Nu: [vim.languages.nu.enable](./options.html#option-vim-languages-nu-enable)
- OCaml:
[vim.languages.ocaml.enable](./options.html#option-vim-languages-ocaml-enable)
- Odin:
[vim.languages.odin.enable](./options.html#option-vim-languages-odin-enable)
- R: [vim.languages.r.enable](./options.html#option-vim-languages-r-enable)
- Ruby:
[vim.languages.ruby.enable](./options.html#option-vim-languages-ruby-enable)
- Scala:
[vim.languages.scala.enable](./options.html#option-vim-languages-scala-enable)
- Svelte:
[vim.languages.svelte.enable](./options.html#option-vim-languages-svelte-enable)
- Tailwind:
[vim.languages.tailwind.enable](./options.html#option-vim-languages-tailwind-enable)
- Terraform: - Terraform:
[vim.languages.terraform.enable](#opt-vim.languages.terraform.enable) [vim.languages.terraform.enable](./options.html#option-vim-languages-terraform-enable)
- Typst: [vim.languages.typst.enable](#opt-vim.languages.typst.enable) - Typst:
- Vala: [vim.languages.vala.enable](#opt-vim.languages.vala.enable) [vim.languages.typst.enable](./options.html#option-vim-languages-typst-enable)
- WGSL: [vim.languages.wgsl.enable](#opt-vim.languages.wgsl.enable) - Vala:
- YAML: [vim.languages.yaml.enable](#opt-vim.languages.yaml.enable) [vim.languages.vala.enable](./options.html#option-vim-languages-vala-enable)
- WGSL:
[vim.languages.wgsl.enable](./options.html#option-vim-languages-wgsl-enable)
- YAML:
[vim.languages.yaml.enable](./options.html#option-vim-languages-yaml-enable)
Adding support for more languages, and improving support for existing ones are Adding support for more languages, and improving support for existing ones are
great places where you can contribute with a PR. great places where you can contribute with a PR.

12
docs/manual/configuring/overriding-plugins.md
View file

@ -1,10 +1,10 @@
# Overriding plugins {#ch-overriding-plugins} # Overriding plugins {#ch-overriding-plugins}
The [additional plugins section](#sec-additional-plugins) details the addition The [additional plugins section](./hacking.html#sec-additional-plugins) details
of new plugins to nvf under regular circumstances, i.e. while making a pull the addition of new plugins to nvf under regular circumstances, i.e. while
request to the project. You may _override_ those plugins in your config to making a pull request to the project. You may _override_ those plugins in your
change source versions, e.g., to use newer versions of plugins that are not yet config to change source versions, e.g., to use newer versions of plugins that
updated in **nvf**. are not yet updated in **nvf**.
```nix ```nix
vim.pluginOverrides = { vim.pluginOverrides = {
@ -22,7 +22,7 @@ vim.pluginOverrides = {
}; };
``` ```
This will override the source for the `neodev.nvim` plugin that is used in nvf This will override the source for the `lazydev.nvim` plugin that is used in nvf
with your own plugin. with your own plugin.
::: {.warning} ::: {.warning}

588
docs/manual/hacking.md
View file

@ -21,10 +21,586 @@ ideally also include relevant context in which an issue occurs or a feature
should be implemented. If you wish to make a contribution, but feel stuck - should be implemented. If you wish to make a contribution, but feel stuck -
please do not be afraid to submit a pull request, we will help you get it in. please do not be afraid to submit a pull request, we will help you get it in.
```{=include=} sections ## Getting Started {#sec-contrib-getting-started}
hacking/getting-started.md
hacking/guidelines.md You, naturally, would like to start by forking the repository to get started. If
hacking/testing.md you are new to Git and GitHub, do have a look at GitHub's
hacking/keybinds.md [Fork a repo guide](https://help.github.com/articles/fork-a-repo/) for
hacking/additional-plugins.md instructions on how you can do this. Once you have a fork of **nvf**, you should
create a separate branch based on the most recent `main` branch. Give your
branch a reasonably descriptive name (e.g. `feature/debugger` or
`fix/pesky-bug`) and you are ready to work on your changes
Implement your changes and commit them to the newly created branch and when you
are happy with the result, and positive that it fulfills our
[Contributing Guidelines](#sec-guidelines), push the branch to GitHub and
[create a pull request](https://help.github.com/articles/creating-a-pull-request).
The default pull request template available on the **nvf** repository will guide
you through the rest of the process, and we'll gently nudge you in the correct
direction if there are any mistakes.
## Guidelines {#sec-guidelines}
If your contribution tightly follows the guidelines, then there is a good chance
it will be merged without too much trouble. Some of the guidelines will be
strictly enforced, others will remain as gentle nudges towards the correct
direction. As we have no automated system enforcing those guidelines, please try
to double check your changes before making your pull request in order to avoid
"faulty" code slipping by.
If you are uncertain how these rules affect the change you would like to make
then feel free to start a discussion in the
[discussions tab](https://github.com/NotAShelf/nvf/discussions) ideally (but not
necessarily) before you start developing.
### Adding Documentation {#sec-guidelines-documentation}
[Nixpkgs Flavoured Markdown]: https://github.com/NixOS/nixpkgs/blob/master/doc/README.md#syntax
Almost all changes warrant updates to the documentation: at the very least, you
must update the changelog. Both the manual and module options use
[Nixpkgs Flavoured Markdown].
The HTML version of this manual containing both the module option descriptions
and the documentation of **nvf** (such as this page) can be generated and opened
by typing the following in a shell within a clone of the **nvf** Git repository:
```console
$ nix build .#docs-html
$ xdg-open $PWD/result/share/doc/nvf/index.html
``` ```
### Formatting Code {#sec-guidelines-formatting}
Make sure your code is formatted as described in
[code-style section](#sec-guidelines-code-style). To maintain consistency
throughout the project you are encouraged to browse through existing code and
adopt its style also in new code.
### Formatting Commits {#sec-guidelines-commit-message-style}
Similar to [code style guidelines](#sec-guidelines-code-style) we encourage a
consistent commit message format as described in
[commit style guidelines](#sec-guidelines-commit-style).
### Commit Style {#sec-guidelines-commit-style}
The commits in your pull request should be reasonably self-contained. Which
means each and every commit in a pull request should make sense both on its own
and in general context. That is, a second commit should not resolve an issue
that is introduced in an earlier commit. In particular, you will be asked to
amend any commit that introduces syntax errors or similar problems even if they
are fixed in a later commit.
The commit messages should follow the
[seven rules](https://chris.beams.io/posts/git-commit/#seven-rule), except for
"Capitalize the subject line". We also ask you to include the affected code
component or module in the first line. A commit message ideally, but not
necessarily, follow the given template from home-manager's own documentation
```
{component}: {description}
{long description}
```
where `{component}` refers to the code component (or module) your change
affects, `{description}` is a very brief description of your change, and
`{long description}` is an optional clarifying description. As a rare exception,
if there is no clear component, or your change affects many components, then the
`{component}` part is optional. See
[example commit message](#sec-guidelines-ex-commit-message) for a commit message
that fulfills these requirements.
#### Example Commit {#sec-guidelines-ex-commit-message}
The commit
[69f8e47e9e74c8d3d060ca22e18246b7f7d988ef](https://github.com/nix-community/home-manager/commit/69f8e47e9e74c8d3d060ca22e18246b7f7d988ef)
in home-manager contains the following commit message.
```
starship: allow running in Emacs if vterm is used
The vterm buffer is backed by libvterm and can handle Starship prompts
without issues.
```
Similarly, if you are contributing to **nvf**, you would include the scope of
the commit followed by the description:
```
languages/ruby: init module
Adds a language module for Ruby, adds appropriate formatters and Treesitter grammars
```
Long description can be omitted if the change is too simple to warrant it. A
minor fix in spelling or a formatting change does not warrant long description,
however, a module addition or removal does as you would like to provide the
relevant context, i.e. the reasoning behind it, for your commit.
Finally, when adding a new module, say `modules/foo.nix`, we use the fixed
commit format `foo: add module`. You can, of course, still include a long
description if you wish.
In case of nested modules, i.e `modules/languages/java.nix` you are recommended
to contain the parent as well - for example `languages/java: some major change`.
### Code Style {#sec-guidelines-code-style}
#### Treewide {#sec-code-style-treewide}
Keep lines at a reasonable width, ideally 80 characters or less. This also
applies to string literals and module descriptions and documentation.
#### Nix {#sec-code-style-nix}
[alejandra]: https://github.com/kamadorueda/alejandra
**nvf** is formatted by the [alejandra] tool and the formatting is checked in
the pull request and push workflows. Run the `nix fmt` command inside the
project repository before submitting your pull request.
While Alejandra is mostly opinionated on how code looks after formatting,
certain changes are done at the user's discretion based on how the original code
was structured.
Please use one line code for attribute sets that contain only one subset. For
example:
```nix
# parent modules should always be unfolded
# which means module = { value = ... } instead of module.value = { ... }
module = {
value = mkEnableOption "some description" // { default = true; }; # merges can be done inline where possible
# same as parent modules, unfold submodules
subModule = {
# this is an option that contains more than one nested value
# Note: try to be careful about the ordering of `mkOption` arguments.
# General rule of thumb is to order from least to most likely to change.
# This is, for most cases, type < default < description.
# Example, if present, would be between default and description
someOtherValue = mkOption {
type = lib.types.bool;
default = true;
description = "Some other description";
};
};
}
```
If you move a line down after the merge operator, Alejandra will automatically
unfold the whole merged attrset for you, which we **do not** want.
```nix
module = {
key = mkEnableOption "some description" // {
default = true; # we want this to be inline
}; # ...
}
```
For lists, it is mostly up to your own discretion how you want to format them,
but please try to unfold lists if they contain multiple items and especially if
they are to include comments.
```nix
# this is ok
acceptableList = [
item1 # comment
item2
item3 # some other comment
item4
];
# this is not ok
listToBeAvoided = [item1 item2 /* comment */ item3 item4];
# this is ok
acceptableList = [item1 item2];
# this is also ok if the list is expected to contain more elements
acceptableList= [
item1
item2
# more items if needed...
];
```
## Testing Changes {#sec-testing-changes}
Once you have made your changes, you will need to test them thoroughly. If it is
a module, add your module option to `configuration.nix` (located in the root of
this project) inside `neovimConfiguration`. Enable it, and then run the maximal
configuration with `nix run .#maximal -Lv` to check for build errors. If neovim
opens in the current directory without any error messages (you can check the
output of `:messages` inside neovim to see if there are any errors), then your
changes are good to go. Open your pull request, and it will be reviewed as soon
as possible.
If it is not a new module, but a change to an existing one, then make sure the
module you have changed is enabled in the maximal configuration by editing
`configuration.nix`, and then run it with `nix run .#maximal -Lv`. Same
procedure as adding a new module will apply here.
## Keybinds {#sec-keybinds}
As of 0.4, there exists an API for writing your own keybinds and a couple of
useful utility functions are available in the
[extended standard library](https://github.com/NotAShelf/nvf/tree/main/lib). The
following section contains a general overview to how you may utilize said
functions.
## Custom Key Mappings Support for a Plugin {#sec-custom-key-mappings}
To set a mapping, you should define it in `vim.keymaps`.
An example, simple keybinding, can look like this:
```nix
{
vim.keymaps = [
{
key = "<leader>wq";
mode = ["n"];
action = ":wq<CR>";
silent = true;
desc = "Save file and quit";
}
];
}
```
There are many settings available in the options. Please refer to the
[documentation](./options.html#option-vim-keymaps) to see a list of them.
**nvf** provides a helper function, so that you don't have to write the mapping
attribute sets every time:
- `mkKeymap`, which mimics neovim's `vim.keymap.set` function
You can read the source code of some modules to see them in action, but the
usage should look something like this:
```nix
# plugindefinition.nix
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.binds) mkMappingOption;
in {
options.vim.plugin = {
enable = mkEnableOption "Enable plugin";
# Mappings should always be inside an attrset called mappings
mappings = {
workspaceDiagnostics = mkMappingOption "Workspace diagnostics [trouble]" "<leader>lwd";
documentDiagnostics = mkMappingOption "Document diagnostics [trouble]" "<leader>ld";
lspReferences = mkMappingOption "LSP References [trouble]" "<leader>lr";
quickfix = mkMappingOption "QuickFix [trouble]" "<leader>xq";
locList = mkMappingOption "LOCList [trouble]" "<leader>xl";
symbols = mkMappingOption "Symbols [trouble]" "<leader>xs";
};
}
```
```nix
# config.nix
{
config,
lib,
options,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.binds) mkKeymap;
cfg = config.vim.plugin;
keys = cfg.mappings;
inherit (options.vim.lsp.trouble) mappings;
in {
config = mkIf cfg.enable {
vim.keymaps = [
(mkKeymap "n" keys.workspaceDiagnostics "<cmd>Trouble toggle diagnostics<CR>" {desc = mappings.workspaceDiagnostics.description;})
(mkKeymap "n" keys.documentDiagnostics "<cmd>Trouble toggle diagnostics filter.buf=0<CR>" {desc = mappings.documentDiagnostics.description;})
(mkKeymap "n" keys.lspReferences "<cmd>Trouble toggle lsp_references<CR>" {desc = mappings.lspReferences.description;})
(mkKeymap "n" keys.quickfix "<cmd>Trouble toggle quickfix<CR>" {desc = mappings.quickfix.description;})
(mkKeymap "n" keys.locList "<cmd>Trouble toggle loclist<CR>" {desc = mappings.locList.description;})
(mkKeymap "n" keys.symbols "<cmd>Trouble toggle symbols<CR>" {desc = mappings.symbols.description;})
];
};
}
```
> [!NOTE]
> If you have come across a plugin that has an API that doesn't seem to easily
> allow custom keybindings, don't be scared to implement a draft PR. We'll help
> you get it done.
## Adding Plugins {#sec-additional-plugins}
There are two methods for adding new Neovim plugins to **nvf**. npins is the
faster option that should be preferred if the plugin consists of pure Lua or
Vimscript code. In which case there is no building required, and we can easily
handle the copying of plugin files. Alternative method, which is required when
plugins try to build their own libraries (e.g., in Rust or C) that need to be
built with Nix to function correctly.
### With npins {#sec-npins-for-plugins}
npins is the standard method of adding new plugins to **nvf**. You simply need
the repository URL for the plugin, and can add it as a source to be built
automatically with one command. To add a new Neovim plugin, use `npins`. For
example:
```bash
nix-shell -p npins # or nix shell nixpkgs#npins if using flakes
```
Then run:
```bash
npins add --name <plugin name> github <owner> <repo> -b <branch>
```
::: {.note}
Be sure to replace any non-alphanumeric characters with `-` for `--name`. For
example
```bash
npins add --name lazydev-nvim github folke lazydev.nvim -b main
```
:::
Once the `npins` command is done, you can start referencing the plugin as a
**string**.
```nix
{
config.vim.startPlugins = ["lazydev-nvim"];
}
```
### Packaging Complex Plugins {#sec-pkgs-for-plugins}
[blink.cmp]: https://github.com/Saghen/blink.cmp
Some plugins require additional packages to be built and substituted to function
correctly. For example [blink.cmp] requires its own fuzzy matcher library, built
with Rust, to be installed or else defaults to a much slower Lua implementation.
In the Blink documentation, you are advised to build with `cargo` but that is
not ideal since we are leveraging the power of Nix. In this case the ideal
solution is to write a derivation for the plugin.
We use `buildRustPackage` to build the library from the repository root, and
copy everything in the `postInstall` phase.
```nix
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"
'';
```
In a similar fashion, you may utilize `stdenv.mkDerivation` and other Nixpkgs
builders to build your library from source, and copy the relevant files and Lua
plugin files in the `postInstall` phase. Do note, however, that you still need
to fetch the plugin sources somehow. npins is, once again, the recommended
option to fetch the plugin sources. Refer to the previous section on how to use
npins to add a new plugin.
Plugins built from source must go into the `flake/pkgs/by-name` overlay. It will
automatically create flake outputs for individual packages. Lastly, you must add
your package to the plugin builder (`pluginBuilders`) function manually in
`modules/wrapper/build/config.nix`. Once done, you may refer to your plugin as a
**string**.
```nix
{
config.vim.startPlugins = ["blink-cmp"];
}
```
### Modular setup options {#sec-modular-setup-options}
Most plugins is initialized with a call to `require('plugin').setup({...})`.
We use a special function that lets you easily add support for such setup
options in a modular way: `mkPluginSetupOption`.
Once you have added the source of the plugin as shown above, you can define the
setup options like this:
```nix
# in modules/.../your-plugin/your-plugin.nix
{lib, ...}:
let
inherit (lib.types) bool int;
inherit (lib.nvim.types) mkPluginSetupOption;
in {
options.vim.your-plugin = {
setupOpts = mkPluginSetupOption "plugin name" {
enable_feature_a = mkOption {
type = bool;
default = false;
# ...
};
number_option = mkOption {
type = int;
default = 3;
# ...
};
};
};
}
```
```nix
# in modules/.../your-plugin/config.nix
{lib, config, ...}:
let
cfg = config.vim.your-plugin;
in {
vim.luaConfigRC = lib.nvim.dag.entryAnywhere ''
require('plugin-name').setup(${lib.nvim.lua.toLuaObject cfg.setupOpts})
'';
}
```
This above config will result in this Lua script:
```lua
require('plugin-name').setup({
enable_feature_a = false,
number_option = 3,
})
```
Now users can set any of the pre-defined option field, and can also add their
own fields!
```nix
# in user's config
{
vim.your-plugin.setupOpts = {
enable_feature_a = true;
number_option = 4;
another_field = "hello";
size = { # nested fields work as well
top = 10;
};
};
}
```
### Details of toLuaObject {#sec-details-of-toluaobject}
As you've seen above, `toLuaObject` is used to convert our nix attrSet
`cfg.setupOpts`, into a lua table. Here are some rules of the conversion:
1. Nix `null` converts to lua `nil`
2. Number and strings convert to their lua counterparts
3. Nix attribute sets (`{}`) and lists (`[]`) convert into Lua dictionaries and
tables respectively. Here is an example of Nix -> Lua conversion.
- `{foo = "bar"}` -> `{["foo"] = "bar"}`
- `["foo" "bar"]` -> `{"foo", "bar"}`
4. You can write raw Lua code using `lib.generators.mkLuaInline`. This function
is part of nixpkgs, and is accessible without relying on **nvf**'s extended
library.
- `mkLuaInline "function add(a, b) return a + b end"` will yield the
following result:
```nix
{
_type = "lua-inline";
expr = "function add(a, b) return a + b end";
}
```
The above expression will be interpreted as a Lua expression in the final
config. Without the `mkLuaInline` function, you will only receive a string
literal. You can use it to feed plugin configuration tables Lua functions
that return specific values as expected by the plugins.
```nix
{
vim.your-plugin.setupOpts = {
on_init = lib.generators.mkLuaInline ''
function()
print('we can write lua!')
end
'';
};
}
```
### Lazy plugins {#sec-lazy-plugins}
If the plugin can be lazy-loaded, `vim.lazy.plugins` should be used to add it.
Lazy plugins are managed by `lz.n`.
```nix
# in modules/.../your-plugin/config.nix
{config, ...}: let
cfg = config.vim.your-plugin;
in {
vim.lazy.plugins.your-plugin = {
# Instead of vim.startPlugins, use this:
package = "your-plugin";
# ıf your plugin uses the `require('your-plugin').setup{...}` pattern
setupModule = "your-plugin";
inherit (cfg) setupOpts;
# Events that trigger this plugin to be loaded
event = ["DirChanged"];
cmd = ["YourPluginCommand"];
# Plugin Keymaps
keys = [
# We'll cover this in detail in the 'keybinds' section
{
key = "<leader>d";
mode = "n";
action = ":YourPluginCommand";
}
];
};
}
```
This results in the following lua code:
```lua
require('lz.n').load({
{
"name-of-your-plugin",
after = function()
require('your-plugin').setup({
--[[ your setupOpts ]]--
})
end,
event = {"DirChanged"},
cmd = {"YourPluginCommand"},
keys = {
{"<leader>d", ":YourPluginCommand", mode = {"n"}},
},
}
})
```
[`vim.lazy.plugins` spec]: ./options.html#option-vim-lazy-plugins
A full list of options can be found in the [`vim.lazy.plugins` spec] on the
rendered manual.

266
docs/manual/hacking/additional-plugins.md
View file

@ -1,266 +0,0 @@
# Adding Plugins {#sec-additional-plugins}
There are two methods for adding new Neovim plugins to **nvf**. npins is the
faster option that should be preferred if the plugin consists of pure Lua or
Vimscript code. In which case there is no building required, and we can easily
handle the copying of plugin files. Alternative method, which is required when
plugins try to build their own libraries (e.g., in Rust or C) that need to be
built with Nix to function correctly.
## With npins {#sec-npins-for-plugins}
npins is the standard method of adding new plugins to **nvf**. You simply need
the repository URL for the plugin, and can add it as a source to be built
automatically with one command. To add a new Neovim plugin, use `npins`. For
example:
```bash
nix-shell -p npins # or nix shell nixpkgs#npins if using flakes
```
Then run:
```bash
npins add --name <plugin name> github <owner> <repo> -b <branch>
```
::: {.note}
Be sure to replace any non-alphanumeric characters with `-` for `--name`. For
example
```bash
npins add --name lazydev-nvim github folke lazydev.nvim -b main
```
:::
Once the `npins` command is done, you can start referencing the plugin as a
**string**.
```nix
{
config.vim.startPlugins = ["lazydev-nvim"];
}
```
## Packaging Complex Plugins {#sec-pkgs-for-plugins}
[blink.cmp]: https://github.com/Saghen/blink.cmp
Some plugins require additional packages to be built and substituted to function
correctly. For example [blink.cmp] requires its own fuzzy matcher library, built
with Rust, to be installed or else defaults to a much slower Lua implementation.
In the Blink documentation, you are advised to build with `cargo` but that is
not ideal since we are leveraging the power of Nix. In this case the ideal
solution is to write a derivation for the plugin.
We use `buildRustPackage` to build the library from the repository root, and
copy everything in the `postInstall` phase.
```nix
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"
'';
```
In a similar fashion, you may utilize `stdenv.mkDerivation` and other Nixpkgs
builders to build your library from source, and copy the relevant files and Lua
plugin files in the `postInstall` phase. Do note, however, that you still need
to fetch the plugin sources somehow. npins is, once again, the recommended
option to fetch the plugin sources. Refer to the previous section on how to use
npins to add a new plugin.
Plugins built from source must go into the `flake/pkgs/by-name` overlay. It will
automatically create flake outputs for individual packages. Lastly, you must add
your package to the plugin builder (`pluginBuilders`) function manually in
`modules/wrapper/build/config.nix`. Once done, you may refer to your plugin as a
**string**.
```nix
{
config.vim.startPlugins = ["blink-cmp"];
}
```
## Modular setup options {#sec-modular-setup-options}
Most plugins is initialized with a call to `require('plugin').setup({...})`.
We use a special function that lets you easily add support for such setup
options in a modular way: `mkPluginSetupOption`.
Once you have added the source of the plugin as shown above, you can define the
setup options like this:
```nix
# in modules/.../your-plugin/your-plugin.nix
{lib, ...}:
let
inherit (lib.types) bool int;
inherit (lib.nvim.types) mkPluginSetupOption;
in {
options.vim.your-plugin = {
setupOpts = mkPluginSetupOption "plugin name" {
enable_feature_a = mkOption {
type = bool;
default = false;
# ...
};
number_option = mkOption {
type = int;
default = 3;
# ...
};
};
};
}
```
```nix
# in modules/.../your-plugin/config.nix
{lib, config, ...}:
let
cfg = config.vim.your-plugin;
in {
vim.luaConfigRC = lib.nvim.dag.entryAnywhere ''
require('plugin-name').setup(${lib.nvim.lua.toLuaObject cfg.setupOpts})
'';
}
```
This above config will result in this Lua script:
```lua
require('plugin-name').setup({
enable_feature_a = false,
number_option = 3,
})
```
Now users can set any of the pre-defined option field, and can also add their
own fields!
```nix
# in user's config
{
vim.your-plugin.setupOpts = {
enable_feature_a = true;
number_option = 4;
another_field = "hello";
size = { # nested fields work as well
top = 10;
};
};
}
```
## Details of toLuaObject {#sec-details-of-toluaobject}
As you've seen above, `toLuaObject` is used to convert our nix attrSet
`cfg.setupOpts`, into a lua table. Here are some rules of the conversion:
1. Nix `null` converts to lua `nil`
2. Number and strings convert to their lua counterparts
3. Nix attribute sets (`{}`) and lists (`[]`) convert into Lua dictionaries and
tables respectively. Here is an example of Nix -> Lua conversion.
- `{foo = "bar"}` -> `{["foo"] = "bar"}`
- `["foo" "bar"]` -> `{"foo", "bar"}`
4. You can write raw Lua code using `lib.generators.mkLuaInline`. This function
is part of nixpkgs, and is accessible without relying on **nvf**'s extended
library.
- `mkLuaInline "function add(a, b) return a + b end"` will yield the
following result:
```nix
{
_type = "lua-inline";
expr = "function add(a, b) return a + b end";
}
```
The above expression will be interpreted as a Lua expression in the final
config. Without the `mkLuaInline` function, you will only receive a string
literal. You can use it to feed plugin configuration tables Lua functions
that return specific values as expected by the plugins.
```nix
{
vim.your-plugin.setupOpts = {
on_init = lib.generators.mkLuaInline ''
function()
print('we can write lua!')
end
'';
};
}
```
## Lazy plugins {#sec-lazy-plugins}
If the plugin can be lazy-loaded, `vim.lazy.plugins` should be used to add it.
Lazy plugins are managed by `lz.n`.
```nix
# in modules/.../your-plugin/config.nix
{config, ...}: let
cfg = config.vim.your-plugin;
in {
vim.lazy.plugins.your-plugin = {
# Instead of vim.startPlugins, use this:
package = "your-plugin";
# ıf your plugin uses the `require('your-plugin').setup{...}` pattern
setupModule = "your-plugin";
inherit (cfg) setupOpts;
# Events that trigger this plugin to be loaded
event = ["DirChanged"];
cmd = ["YourPluginCommand"];
# Plugin Keymaps
keys = [
# We'll cover this in detail in the 'keybinds' section
{
key = "<leader>d";
mode = "n";
action = ":YourPluginCommand";
}
];
};
}
```
This results in the following lua code:
```lua
require('lz.n').load({
{
"name-of-your-plugin",
after = function()
require('your-plugin').setup({
--[[ your setupOpts ]]--
})
end,
event = {"DirChanged"},
cmd = {"YourPluginCommand"},
keys = {
{"<leader>d", ":YourPluginCommand", mode = {"n"}},
},
}
})
```
[`vim.lazy.plugins` spec]: https://notashelf.github.io/nvf/options.html#opt-vim.lazy.plugins
A full list of options can be found in the [`vim.lazy.plugins` spec] on the
rendered manual.

17
docs/manual/hacking/getting-started.md
View file

@ -1,17 +0,0 @@
# Getting Started {#sec-contrib-getting-started}
You, naturally, would like to start by forking the repository to get started. If
you are new to Git and GitHub, do have a look at GitHub's
[Fork a repo guide](https://help.github.com/articles/fork-a-repo/) for
instructions on how you can do this. Once you have a fork of **nvf**, you should
create a separate branch based on the most recent `main` branch. Give your
branch a reasonably descriptive name (e.g. `feature/debugger` or
`fix/pesky-bug`) and you are ready to work on your changes
Implement your changes and commit them to the newly created branch and when you
are happy with the result, and positive that it fulfills our
[Contributing Guidelines](#sec-guidelines), push the branch to GitHub and
[create a pull request](https://help.github.com/articles/creating-a-pull-request).
The default pull request template available on the **nvf** repository will guide
you through the rest of the process, and we'll gently nudge you in the correct
direction if there are any mistakes.

188
docs/manual/hacking/guidelines.md
View file

@ -1,188 +0,0 @@
# Guidelines {#sec-guidelines}
If your contribution tightly follows the guidelines, then there is a good chance
it will be merged without too much trouble. Some of the guidelines will be
strictly enforced, others will remain as gentle nudges towards the correct
direction. As we have no automated system enforcing those guidelines, please try
to double check your changes before making your pull request in order to avoid
"faulty" code slipping by.
If you are uncertain how these rules affect the change you would like to make
then feel free to start a discussion in the
[discussions tab](https://github.com/NotAShelf/nvf/discussions) ideally (but not
necessarily) before you start developing.
## Adding Documentation {#sec-guidelines-documentation}
[Nixpkgs Flavoured Markdown]: https://github.com/NixOS/nixpkgs/blob/master/doc/README.md#syntax
Almost all changes warrant updates to the documentation: at the very least, you
must update the changelog. Both the manual and module options use
[Nixpkgs Flavoured Markdown].
The HTML version of this manual containing both the module option descriptions
and the documentation of **nvf** (such as this page) can be generated and opened
by typing the following in a shell within a clone of the **nvf** Git repository:
```console
$ nix build .#docs-html
$ xdg-open $PWD/result/share/doc/nvf/index.html
```
## Formatting Code {#sec-guidelines-formatting}
Make sure your code is formatted as described in
[code-style section](#sec-guidelines-code-style). To maintain consistency
throughout the project you are encouraged to browse through existing code and
adopt its style also in new code.
## Formatting Commits {#sec-guidelines-commit-message-style}
Similar to [code style guidelines](#sec-guidelines-code-style) we encourage a
consistent commit message format as described in
[commit style guidelines](#sec-guidelines-commit-style).
## Commit Style {#sec-guidelines-commit-style}
The commits in your pull request should be reasonably self-contained. Which
means each and every commit in a pull request should make sense both on its own
and in general context. That is, a second commit should not resolve an issue
that is introduced in an earlier commit. In particular, you will be asked to
amend any commit that introduces syntax errors or similar problems even if they
are fixed in a later commit.
The commit messages should follow the
[seven rules](https://chris.beams.io/posts/git-commit/#seven-rule), except for
"Capitalize the subject line". We also ask you to include the affected code
component or module in the first line. A commit message ideally, but not
necessarily, follow the given template from home-manager's own documentation
```
{component}: {description}
{long description}
```
where `{component}` refers to the code component (or module) your change
affects, `{description}` is a very brief description of your change, and
`{long description}` is an optional clarifying description. As a rare exception,
if there is no clear component, or your change affects many components, then the
`{component}` part is optional. See
[example commit message](#sec-guidelines-ex-commit-message) for a commit message
that fulfills these requirements.
## Example Commit {#sec-guidelines-ex-commit-message}
The commit
[69f8e47e9e74c8d3d060ca22e18246b7f7d988ef](https://github.com/nix-community/home-manager/commit/69f8e47e9e74c8d3d060ca22e18246b7f7d988ef)
in home-manager contains the following commit message.
```
starship: allow running in Emacs if vterm is used
The vterm buffer is backed by libvterm and can handle Starship prompts
without issues.
```
Similarly, if you are contributing to **nvf**, you would include the scope of
the commit followed by the description:
```
languages/ruby: init module
Adds a language module for Ruby, adds appropriate formatters and Treesitter grammars
```
Long description can be omitted if the change is too simple to warrant it. A
minor fix in spelling or a formatting change does not warrant long description,
however, a module addition or removal does as you would like to provide the
relevant context, i.e. the reasoning behind it, for your commit.
Finally, when adding a new module, say `modules/foo.nix`, we use the fixed
commit format `foo: add module`. You can, of course, still include a long
description if you wish.
In case of nested modules, i.e `modules/languages/java.nix` you are recommended
to contain the parent as well - for example `languages/java: some major change`.
## Code Style {#sec-guidelines-code-style}
### Treewide {#sec-code-style-treewide}
Keep lines at a reasonable width, ideally 80 characters or less. This also
applies to string literals and module descriptions and documentation.
### Nix {#sec-code-style-nix}
[alejandra]: https://github.com/kamadorueda/alejandra
**nvf** is formatted by the [alejandra] tool and the formatting is checked in
the pull request and push workflows. Run the `nix fmt` command inside the
project repository before submitting your pull request.
While Alejandra is mostly opinionated on how code looks after formatting,
certain changes are done at the user's discretion based on how the original code
was structured.
Please use one line code for attribute sets that contain only one subset. For
example:
```nix
# parent modules should always be unfolded
# which means module = { value = ... } instead of module.value = { ... }
module = {
value = mkEnableOption "some description" // { default = true; }; # merges can be done inline where possible
# same as parent modules, unfold submodules
subModule = {
# this is an option that contains more than one nested value
# Note: try to be careful about the ordering of `mkOption` arguments.
# General rule of thumb is to order from least to most likely to change.
# This is, for most cases, type < default < description.
# Example, if present, would be between default and description
someOtherValue = mkOption {
type = lib.types.bool;
default = true;
description = "Some other description";
};
};
}
```
If you move a line down after the merge operator, Alejandra will automatically
unfold the whole merged attrset for you, which we **do not** want.
```nix
module = {
key = mkEnableOption "some description" // {
default = true; # we want this to be inline
}; # ...
}
```
For lists, it is mostly up to your own discretion how you want to format them,
but please try to unfold lists if they contain multiple items and especially if
they are to include comments.
```nix
# this is ok
acceptableList = [
item1 # comment
item2
item3 # some other comment
item4
];
# this is not ok
listToBeAvoided = [item1 item2 /* comment */ item3 item4];
# this is ok
acceptableList = [item1 item2];
# this is also ok if the list is expected to contain more elements
acceptableList= [
item1
item2
# more items if needed...
];
```

97
docs/manual/hacking/keybinds.md
View file

@ -1,97 +0,0 @@
# Keybinds {#sec-keybinds}
As of 0.4, there exists an API for writing your own keybinds and a couple of
useful utility functions are available in the
[extended standard library](https://github.com/NotAShelf/nvf/tree/main/lib). The
following section contains a general overview to how you may utilize said
functions.
## Custom Key Mappings Support for a Plugin {#sec-custom-key-mappings}
To set a mapping, you should define it in `vim.keymaps`.
An example, simple keybinding, can look like this:
```nix
{
vim.keymaps = [
{
key = "<leader>wq";
mode = ["n"];
action = ":wq<CR>";
silent = true;
desc = "Save file and quit";
}
];
}
```
There are many settings available in the options. Please refer to the
[documentation](https://notashelf.github.io/nvf/options.html#opt-vim.keymaps) to
see a list of them.
**nvf** provides a helper function, so that you don't have to write the mapping
attribute sets every time:
- `mkKeymap`, which mimics neovim's `vim.keymap.set` function
You can read the source code of some modules to see them in action, but the
usage should look something like this:
```nix
# plugindefinition.nix
{lib, ...}: let
inherit (lib.options) mkEnableOption;
inherit (lib.nvim.binds) mkMappingOption;
in {
options.vim.plugin = {
enable = mkEnableOption "Enable plugin";
# Mappings should always be inside an attrset called mappings
mappings = {
workspaceDiagnostics = mkMappingOption "Workspace diagnostics [trouble]" "<leader>lwd";
documentDiagnostics = mkMappingOption "Document diagnostics [trouble]" "<leader>ld";
lspReferences = mkMappingOption "LSP References [trouble]" "<leader>lr";
quickfix = mkMappingOption "QuickFix [trouble]" "<leader>xq";
locList = mkMappingOption "LOCList [trouble]" "<leader>xl";
symbols = mkMappingOption "Symbols [trouble]" "<leader>xs";
};
}
```
```nix
# config.nix
{
config,
lib,
options,
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.binds) mkKeymap;
cfg = config.vim.plugin;
keys = cfg.mappings;
inherit (options.vim.lsp.trouble) mappings;
in {
config = mkIf cfg.enable {
vim.keymaps = [
(mkKeymap "n" keys.workspaceDiagnostics "<cmd>Trouble toggle diagnostics<CR>" {desc = mappings.workspaceDiagnostics.description;})
(mkKeymap "n" keys.documentDiagnostics "<cmd>Trouble toggle diagnostics filter.buf=0<CR>" {desc = mappings.documentDiagnostics.description;})
(mkKeymap "n" keys.lspReferences "<cmd>Trouble toggle lsp_references<CR>" {desc = mappings.lspReferences.description;})
(mkKeymap "n" keys.quickfix "<cmd>Trouble toggle quickfix<CR>" {desc = mappings.quickfix.description;})
(mkKeymap "n" keys.locList "<cmd>Trouble toggle loclist<CR>" {desc = mappings.locList.description;})
(mkKeymap "n" keys.symbols "<cmd>Trouble toggle symbols<CR>" {desc = mappings.symbols.description;})
];
};
}
```
::: {.note}
If you have come across a plugin that has an API that doesn't seem to easily
allow custom keybindings, don't be scared to implement a draft PR. We'll help
you get it done.
:::

15
docs/manual/hacking/testing.md
View file

@ -1,15 +0,0 @@
# Testing Changes {#sec-testing-changes}
Once you have made your changes, you will need to test them thoroughly. If it is
a module, add your module option to `configuration.nix` (located in the root of
this project) inside `neovimConfiguration`. Enable it, and then run the maximal
configuration with `nix run .#maximal -Lv` to check for build errors. If neovim
opens in the current directory without any error messages (you can check the
output of `:messages` inside neovim to see if there are any errors), then your
changes are good to go. Open your pull request, and it will be reviewed as soon
as possible.
If it is not a new module, but a change to an existing one, then make sure the
module you have changed is enabled in the maximal configuration by editing
`configuration.nix`, and then run it with `nix run .#maximal -Lv`. Same
procedure as adding a new module will apply here.

49
docs/manual/try-it-out.md → docs/manual/index.md
View file

@ -1,4 +1,18 @@
# Try it out {#ch-try-it-out} # Introduction {#nvf-manual}
Version @NVF_VERSION@
## Preface {#ch-preface}
### What is nvf {#sec-what-is-it}
**nvf** is a highly modular, configurable, extensible and easy to use Neovim
configuration framework built and designed to be used with Nix. Boasting
flexibility, robustness and ease of use, this projecct allows you to configure a
fully featured Neovim instance with a few lines of Nix with lots of options for
advanced users as well.
## Try it out {#ch-try-it-out}
Thanks to the portability of Nix, you can try out nvf without actually Thanks to the portability of Nix, you can try out nvf without actually
installing it to your machine. Below are the commands you may run to try out installing it to your machine. Below are the commands you may run to try out
@ -29,10 +43,11 @@ $ nix run github:notashelf/nvf#maximal
### Available Configurations {#sec-available-configs} ### Available Configurations {#sec-available-configs}
::: {.info} > [!NOTE]
> The below configurations are provided for demonstration purposes, and are
The below configurations are provided for demonstration purposes, and are > **not** designed to be installed as is. You may refer to the installation
**not** designed to be installed as is. You may > steps below and the helpful tips section for details on creating your own
> configurations.
#### Nix {#sec-configs-nix} #### Nix {#sec-configs-nix}
@ -42,6 +57,7 @@ default package, you will build Neovim with this config.
```bash ```bash
$ nix run github:notashelf/nvf#nix test.nix $ nix run github:notashelf/nvf#nix test.nix
# => This will open a file called `test.nix` with Nix LSP and syntax highlighting
``` ```
This command will start Neovim with some opinionated plugin configurations, and This command will start Neovim with some opinionated plugin configurations, and
@ -57,16 +73,29 @@ mind, however, that this will pull a lot of dependencies.
```bash ```bash
$ nix run github:notashelf/nvf#maximal -- test.nix $ nix run github:notashelf/nvf#maximal -- test.nix
# => This will open a file called `test.nix` with a variety of plugins available
``` ```
It uses the same configuration template with the [Nix](#sec-configs-nix) It uses the same configuration template with the [Nix](#sec-configs-nix)
configuration, but supports many more languages, and enables more utility, configuration, but supports many more languages, and enables more utility,
companion or fun plugins. companion or fun plugins.
::: {.warning} > [!WARNING]
> Running the maximal config will download _a lot_ of packages as it is
> downloading language servers, formatters, and more. If CPU time and bandwidth
> are concerns, please use the default package instead.
Running the maximal config will download _a lot_ of packages as it is ## Installing nvf {#ch-installation}
downloading language servers, formatters, and more. If CPU time and bandwidth
are concerns, please use the default package instead.
::: [module installation section]: #ch-module-installation
There are multiple ways of installing nvf on your system. You may either choose
the standalone installation method, which does not depend on a module system and
may be done on any system that has the Nix package manager or the appropriate
modules for NixOS and home-manager as described in the
[module installation section].
```{=include=}
installation/custom-configuration.md
installation/modules.md
```

14
docs/manual/installation.md
View file

@ -1,14 +0,0 @@
# Installing nvf {#ch-installation}
[module installation section]: #ch-module-installation
There are multiple ways of installing nvf on your system. You may either choose
the standalone installation method, which does not depend on a module system and
may be done on any system that has the Nix package manager or the appropriate
modules for NixOS and home-manager as described in the
[module installation section].
```{=include=} chapters
installation/custom-configuration.md
installation/modules.md
```

30
docs/manual/manual.md
View file

@ -1,30 +0,0 @@
# nvf manual {#nvf-manual}
## Version @NVF_VERSION@
```{=include=} preface
preface.md
try-it-out.md
```
```{=include=} parts
installation.md
configuring.md
tips.md
```
```{=include=} chapters
hacking.md
```
```{=include=} appendix html:into-file=//quirks.html
quirks.md
```
```{=include=} appendix html:into-file=//options.html
options.md
```
```{=include=} appendix html:into-file=//release-notes.html
release-notes/release-notes.md
```

21
docs/manual/options.md
View file

@ -1,21 +0,0 @@
# nvf Configuration Options {#ch-options}
Below are the module options provided by nvf, in no particular order. Most
options will include useful comments, warnings or setup tips on how a module
option is meant to be used as well as examples in complex cases.
An offline version of this page is bundled with nvf as a part of the manpages
which you can access with `man 5 nvf`. Please let us know if you believe any of
the options below are missing useful examples.
<!--
In the manual, individual options may be referenced in Hyperlinks as follows:
[](#opt-vim.*) If changing the prefix here, do keep in mind the #opt- suffix will have
to be changed everywhere.
-->
```{=include=} options
id-prefix: opt-
list-id: nvf-options
source: @OPTIONS_JSON@
```

20
docs/manual/preface.md
View file

@ -1,20 +0,0 @@
# Preface {#ch-preface}
## What is nvf {#sec-what-is-it}
nvf is a highly modular, configurable, extensible and easy to use Neovim
configuration in Nix. Designed for flexibility and ease of use, nvf allows you
to easily configure your fully featured Neovim instance with a few lines of Nix.
## Bugs & Suggestions {#sec-bugs-suggestions}
[issue tracker]: https://github.com/notashelf/nvf/issues
[discussions tab]: https://github.com/notashelf/nvf/discussions
[pull requests tab]: https://github.com/notashelf/nvf/pulls
If you notice any issues with nvf, or this documentation, then please consider
reporting them over at the [issue tracker]. Issues tab, in addition to the
[discussions tab] is a good place as any to request new features.
You may also consider submitting bugfixes, feature additions and upstreamed
changes that you think are critical over at the [pull requests tab].

42
docs/manual/quirks.md
View file

@ -5,9 +5,41 @@ be it a result of generating Lua from Nix, or the state of packaging. This page,
in turn, will list any known modules or plugins that are known to misbehave, and in turn, will list any known modules or plugins that are known to misbehave, and
possible workarounds that you may apply. possible workarounds that you may apply.
<!-- If adding a new known quirk, please create a new page in quirks/ and include ## NodeJS {#ch-quirks-nodejs}
the name of the file here.-->
```{=include=} chapters ### eslint-plugin-prettier {#sec-eslint-plugin-prettier}
quirks/nodejs.md
``` When working with NodeJS, everything works as expected, but some projects have
settings that can fool nvf.
If [this plugin](https://github.com/prettier/eslint-plugin-prettier) or similar
is included, you might get a situation where your eslint configuration diagnoses
your formatting according to its own config (usually `.eslintrc.js`).
The issue there is your formatting is made via prettierd.
This results in auto-formatting relying on your prettier config, while your
eslint config diagnoses formatting
[which it's not supposed to](https://prettier.io/docs/en/comparison.html))
In the end, you get discrepancies between what your editor does and what it
wants.
Solutions are:
1. Don't add a formatting config to eslint, and separate prettier and eslint.
2. PR this repo to add an ESLint formatter and configure nvf to use it.
## Bugs & Suggestions {#ch-bugs-suggestions}
[issue tracker]: https://github.com/notashelf/nvf/issues
[discussions tab]: https://github.com/notashelf/nvf/discussions
[pull requests tab]: https://github.com/notashelf/nvf/pulls
Some quirks are not exactly quirks, but bugs in the module systeme. If you
notice any issues with nvf, or this documentation, then please consider
reporting them over at the [issue tracker]. Issues tab, in addition to the
[discussions tab] is a good place as any to request new features.
You may also consider submitting bugfixes, feature additions and upstreamed
changes that you think are critical over at the [pull requests tab].

24
docs/manual/quirks/nodejs.md
View file

@ -1,24 +0,0 @@
# NodeJS {#ch-quirks-nodejs}
## eslint-plugin-prettier {#sec-eslint-plugin-prettier}
When working with NodeJS, everything works as expected, but some projects have
settings that can fool nvf.
If [this plugin](https://github.com/prettier/eslint-plugin-prettier) or similar
is included, you might get a situation where your eslint configuration diagnoses
your formatting according to its own config (usually `.eslintrc.js`).
The issue there is your formatting is made via prettierd.
This results in auto-formatting relying on your prettier config, while your
eslint config diagnoses formatting
[which it's not supposed to](https://prettier.io/docs/en/comparison.html))
In the end, you get discrepancies between what your editor does and what it
wants.
Solutions are:
1. Don't add a formatting config to eslint, and separate prettier and eslint.
2. PR this repo to add an ESLint formatter and configure nvf to use it.

15
docs/manual/release-notes.md Normal file
View file

@ -0,0 +1,15 @@
# Release Notes {#ch-release-notes}
This section lists the release notes for tagged version of **nvf** and the
current main current main branch
```{=include=} chapters
release-notes/rl-0.1.md
release-notes/rl-0.2.md
release-notes/rl-0.3.md
release-notes/rl-0.4.md
release-notes/rl-0.5.md
release-notes/rl-0.6.md
release-notes/rl-0.7.md
release-notes/rl-0.8.md
```

15
docs/release-notes/rl-0.1.md → docs/manual/release-notes/rl-0.1.md
View file

@ -1,4 +1,4 @@
# Release 0.1 {#sec-release-0.1} # Release 0.1 {#sec-release-0-1}
This is the current master branch and information here is not final. These are This is the current master branch and information here is not final. These are
changes from the v0.1 tag. changes from the v0.1 tag.
@ -7,7 +7,7 @@ Special thanks to [home-manager](https://github.com/nix-community/home-manager/)
for this release. Docs/manual generation, the new module evaluation system, and for this release. Docs/manual generation, the new module evaluation system, and
DAG implementation are from them. DAG implementation are from them.
## Changelog {#sec-release-0.1-changelog} ## Changelog {#sec-release-0-1-changelog}
[jordanisaacs](https://github.com/jordanisaacs): [jordanisaacs](https://github.com/jordanisaacs):
@ -15,7 +15,7 @@ DAG implementation are from them.
longer defined. If you use hare and would like it added back, please file an longer defined. If you use hare and would like it added back, please file an
issue. issue.
- [](#opt-vim.startPlugins) & [](#opt-vim.optPlugins) are now an enum of - {option}`vim.startPlugins` & {option} `vim-optPlugins` are now an enum of
`string` for options sourced from the flake inputs. Users can still provide `string` for options sourced from the flake inputs. Users can still provide
vim plugin packages. vim plugin packages.
@ -28,13 +28,13 @@ DAG implementation are from them.
[relevant discourse post]: https://discourse.nixos.org/t/psa-if-you-are-on-unstable-try-out-nvim-treesitter-withallgrammars/23321?u=snowytrees [relevant discourse post]: https://discourse.nixos.org/t/psa-if-you-are-on-unstable-try-out-nvim-treesitter-withallgrammars/23321?u=snowytrees
- Treesitter grammars are now configurable with - Treesitter grammars are now configurable with
[](#opt-vim.treesitter.grammars). Utilizes the nixpkgs `nvim-treesitter` {option}`vim.treesitter.grammars`. Utilizes the nixpkgs `nvim-treesitter`
plugin rather than a custom input in order to take advantage of build support plugin rather than a custom input in order to take advantage of build support
of pinned versions. See the [relevant discourse post] for more information. of pinned versions. See the [relevant discourse post] for more information.
Packages can be found under the `vimPlugins.nvim-treesitter.builtGrammars` Packages can be found under the `vimPlugins.nvim-treesitter.builtGrammars`
namespace. namespace.
- `vim.configRC` and [](#opt-vim.luaConfigRC) are now of type DAG lines. This - `vim.configRC` and {option}`vim.luaConfigRC` are now of type DAG lines. This
allows for ordering of the config. Usage is the same is in home-manager's allows for ordering of the config. Usage is the same is in home-manager's
`home.activation` option. `home.activation` option.
@ -44,5 +44,6 @@ vim.luaConfigRC = lib.nvim.dag.entryAnywhere "config here"
[MoritzBoehme](https://github.com/MoritzBoehme): [MoritzBoehme](https://github.com/MoritzBoehme):
- `catppuccin` theme is now available as a neovim theme [](#opt-vim.theme.style) - `catppuccin` theme is now available as a neovim theme
and Lualine theme [](#opt-vim.statusline.lualine.theme). {option}`vim.theme.style` and Lualine theme
{option}`vim.statusline.lualine.theme`.

20
docs/release-notes/rl-0.2.md → docs/manual/release-notes/rl-0.2.md
View file

@ -1,8 +1,8 @@
# Release 0.2 {#sec-release-0.2} # Release 0.2 {#sec-release-0-2}
Release notes for release 0.2 Release notes for release 0.2
## Changelog {#sec-release-0.2-changelog} ## Changelog {#sec-release-0-2-changelog}
[notashelf](https://github.com/notashelf): [notashelf](https://github.com/notashelf):
@ -10,55 +10,39 @@ Release notes for release 0.2
default, while `minimap.vim` is available with its code-minimap dependency. default, while `minimap.vim` is available with its code-minimap dependency.
- A complementary plugin, `obsidian.nvim` and the Neovim alternative for Emacs' - A complementary plugin, `obsidian.nvim` and the Neovim alternative for Emacs'
orgmode with `orgmode.nvim` have been added. Both will be disabled by default. orgmode with `orgmode.nvim` have been added. Both will be disabled by default.
- Smooth scrolling for ANY movement command is now available with - Smooth scrolling for ANY movement command is now available with
`cinnamon.nvim` `cinnamon.nvim`
- You will now notice a dashboard on startup. This is provided by the - You will now notice a dashboard on startup. This is provided by the
`alpha.nvim` plugin. You can use any of the three available dashboard plugins, `alpha.nvim` plugin. You can use any of the three available dashboard plugins,
or disable them entirely. or disable them entirely.
- There is now a scrollbar on active buffers, which can highlight errors by - There is now a scrollbar on active buffers, which can highlight errors by
hooking to your LSPs. This is on by default, but can be toggled off under hooking to your LSPs. This is on by default, but can be toggled off under
`vim.visuals` if seen necessary. `vim.visuals` if seen necessary.
- Discord Rich Presence has been added through `presence.nvim` for those who - Discord Rich Presence has been added through `presence.nvim` for those who
want to flex that they are using the _superior_ text editor. want to flex that they are using the _superior_ text editor.
- An icon picker is now available with telescope integration. You can use - An icon picker is now available with telescope integration. You can use
`:IconPickerInsert` or `:IconPickerYank` to add icons to your code. `:IconPickerInsert` or `:IconPickerYank` to add icons to your code.
- A general-purpose cheatsheet has been added through `cheatsheet.nvim`. Forget - A general-purpose cheatsheet has been added through `cheatsheet.nvim`. Forget
no longer! no longer!
- `ccc.nvim` has been added to the default plugins to allow picking colors with - `ccc.nvim` has been added to the default plugins to allow picking colors with
ease. ease.
- Most UI components of Neovim have been replaced through the help of - Most UI components of Neovim have been replaced through the help of
`noice.nvim`. There are also notifications and custom UI elements available `noice.nvim`. There are also notifications and custom UI elements available
for Neovim messages and prompts. for Neovim messages and prompts.
- A (floating by default) terminal has been added through `toggleterm.nvim`. - A (floating by default) terminal has been added through `toggleterm.nvim`.
- Harness the power of ethical (`tabnine.nvim`) and not-so-ethical - Harness the power of ethical (`tabnine.nvim`) and not-so-ethical
(`copilot.lua`) AI by those new assistant plugins. Both are off by default, (`copilot.lua`) AI by those new assistant plugins. Both are off by default,
TabNine needs to be wrapped before it's working. TabNine needs to be wrapped before it's working.
- Experimental mouse gestures have been added through `gesture.nvim`. See plugin - Experimental mouse gestures have been added through `gesture.nvim`. See plugin
page and the relevant module for more details on how to use. page and the relevant module for more details on how to use.
- Re-open last visited buffers via `nvim-session-manager`. Disabled by default - Re-open last visited buffers via `nvim-session-manager`. Disabled by default
as deleting buffers seems to be problematic at the moment. as deleting buffers seems to be problematic at the moment.
- Most of NvimTree's configuration options have been changed with some options - Most of NvimTree's configuration options have been changed with some options
being toggled to off by default. being toggled to off by default.
- Lualine had its configuration simplified and style toned down. Less color, - Lualine had its configuration simplified and style toned down. Less color,
more info. more info.
- Modules where multiple plugin configurations were in the same directory have - Modules where multiple plugin configurations were in the same directory have
been simplified. Each plugin inside a single module gets its directory to be been simplified. Each plugin inside a single module gets its directory to be
imported. imported.
- Separate config options with the same parent attribute have been merged into - Separate config options with the same parent attribute have been merged into
one for simplicity. one for simplicity.

14
docs/release-notes/rl-0.3.md → docs/manual/release-notes/rl-0.3.md
View file

@ -1,4 +1,4 @@
# Release 0.3 {#sec-release-0.3} # Release 0.3 {#sec-release-0-3}
Release 0.3 had to come out before I wanted it to due to Neovim 0.9 dropping Release 0.3 had to come out before I wanted it to due to Neovim 0.9 dropping
into nixpkgs-unstable. The Treesitter changes have prompted a Treesitter rework, into nixpkgs-unstable. The Treesitter changes have prompted a Treesitter rework,
@ -7,7 +7,7 @@ those are downstreamed from the original repository. The feature requests that
was originally planned for 0.3 have been moved to 0.4, which should come out was originally planned for 0.3 have been moved to 0.4, which should come out
soon. soon.
## Changelog {#sec-release-0.3-changelog} ## Changelog {#sec-release-0-3-changelog}
- We have transitioned to flake-parts, from flake-utils to extend the - We have transitioned to flake-parts, from flake-utils to extend the
flexibility of this flake. This means the flake structure is different than flexibility of this flake. This means the flake structure is different than
@ -39,7 +39,7 @@ soon.
[discourse]: https://discourse.nixos.org/t/psa-if-you-are-on-unstable-try-out-nvim-treesitter-withallgrammars/23321?u=snowytrees [discourse]: https://discourse.nixos.org/t/psa-if-you-are-on-unstable-try-out-nvim-treesitter-withallgrammars/23321?u=snowytrees
- Treesitter grammars are now configurable with - Treesitter grammars are now configurable with
[](#opt-vim.treesitter.grammars). Utilizes the nixpkgs `nvim-treesitter` {option}`vim.treesitter.grammars`. Utilizes the nixpkgs `nvim-treesitter`
plugin rather than a custom input in order to take advantage of build support plugin rather than a custom input in order to take advantage of build support
of pinned versions. See [discourse] for more information. Packages can be of pinned versions. See [discourse] for more information. Packages can be
found under the `pkgs.vimPlugins.nvim-treesitter.builtGrammars` attribute. found under the `pkgs.vimPlugins.nvim-treesitter.builtGrammars` attribute.
@ -50,20 +50,20 @@ soon.
- A new section has been added for language support: `vim.languages.<language>`. - A new section has been added for language support: `vim.languages.<language>`.
- The options `enableLSP` [](#opt-vim.languages.enableTreesitter), etc. will - The options `enableLSP` {option}`vim.languages.enableTreesitter`, etc. will
enable the respective section for all languages that have been enabled. enable the respective section for all languages that have been enabled.
- All LSP languages have been moved here - All LSP languages have been moved here
- `plantuml` and `markdown` have been moved here - `plantuml` and `markdown` have been moved here
- A new section has been added for `html`. The old - A new section has been added for `html`. The old
`vim.treesitter.autotagHtml` can be found at `vim.treesitter.autotagHtml` can be found at
[](#opt-vim.languages.html.treesitter.autotagHtml). {option}`vim.languages.html.treesitter.autotagHtml`.
- `vim.git.gitsigns.codeActions` has been added, allowing you to turn on - `vim.git.gitsigns.codeActions` has been added, allowing you to turn on
Gitsigns' code actions. Gitsigns' code actions.
- Removed the plugins document in the docs. Was too unwieldy to keep updated. - Removed the plugins document in the docs. Was too unwieldy to keep updated.
- `vim.visual.lspkind` has been moved to [](#opt-vim.lsp.lspkind.enable) - `vim.visual.lspkind` has been moved to {option}`vim.lsp.lspkind.enable`
- Improved handling of completion formatting. When setting - Improved handling of completion formatting. When setting
`vim.autocomplete.sources`, can also include optional menu mapping. And can `vim.autocomplete.sources`, can also include optional menu mapping. And can
@ -74,7 +74,7 @@ soon.
by using `null` rather than `""` now. by using `null` rather than `""` now.
- Transparency has been made optional and has been disabled by default. - Transparency has been made optional and has been disabled by default.
[](#opt-vim.theme.transparent) option can be used to enable or disable {option}`vim.theme.transparent` option can be used to enable or disable
transparency for your configuration. transparency for your configuration.
- Fixed deprecated configuration method for Tokyonight, and added new style - Fixed deprecated configuration method for Tokyonight, and added new style

4
docs/release-notes/rl-0.4.md → docs/manual/release-notes/rl-0.4.md
View file

@ -1,4 +1,4 @@
# Release 0.4 {#sec-release-0.4} # Release 0.4 {#sec-release-0-4}
Following the release of v0.3, I have decided to release v0.4 with a massive new Following the release of v0.3, I have decided to release v0.4 with a massive new
change: customizable keybinds. As of the 0.4 release, keybinds will no longer be change: customizable keybinds. As of the 0.4 release, keybinds will no longer be
@ -12,7 +12,7 @@ as `lazygit` integration and the new experimental Lua loader of Neovim 0.9
thanks to our awesome contributors who made this update possible during my thanks to our awesome contributors who made this update possible during my
absence. absence.
## Changelog {#sec-release-0.4-changelog} ## Changelog {#sec-release-0-4-changelog}
[n3oney](https://github.com/n3oney): [n3oney](https://github.com/n3oney):

18
docs/release-notes/rl-0.5.md → docs/manual/release-notes/rl-0.5.md
View file

@ -1,8 +1,6 @@
# Release 0.5 {#sec-release-0.5} # Release 0.5 {#sec-release-0-5}
Release notes for release 0.5 ## Changelog {#sec-release-0-5-changelog}
## Changelog {#sec-release-0.5-changelog}
[vagahbond](https://github.com/vagahbond): [vagahbond](https://github.com/vagahbond):
@ -17,14 +15,14 @@ Release notes for release 0.5
- Fixed a bug where cmp's close and scrollDocs mappings wasn't working - Fixed a bug where cmp's close and scrollDocs mappings wasn't working
- Streamlined and simplified extra plugin API with the addition of - Streamlined and simplified extra plugin API with the addition of
[](#opt-vim.extraPlugins) {option}`vim.extraPlugins`
- Allow using command names in place of LSP packages to avoid automatic - Allow using command names in place of LSP packages to avoid automatic
installation installation
- Add lua LSP and Treesitter support, and neodev.nvim plugin support - Add lua LSP and Treesitter support, and neodev.nvim plugin support
- Add [](#opt-vim.lsp.mappings.toggleFormatOnSave) keybind - Add {option}`vim.lsp.mappings.toggleFormatOnSave` keybind
[amanse](https://github.com/amanse): [amanse](https://github.com/amanse):
@ -52,10 +50,10 @@ Release notes for release 0.5
- Added GitHub Copilot to nvim-cmp completion sources. - Added GitHub Copilot to nvim-cmp completion sources.
- Added [](#opt-vim.ui.borders.enable) for global and individual plugin border - Added {option}`vim.ui.borders.enable` for global and individual plugin border
configuration. configuration.
- LSP integrated breadcrumbs with [](#opt-vim.ui.breadcrumbs.enable) through - LSP integrated breadcrumbs with {option}`vim.ui.breadcrumbs.enable` through
nvim-navic nvim-navic
- LSP navigation helper with nvim-navbuddy, depends on nvim-navic (automatically - LSP navigation helper with nvim-navbuddy, depends on nvim-navic (automatically
@ -66,14 +64,14 @@ Release notes for release 0.5
- Fixed mismatching Zig language description - Fixed mismatching Zig language description
- Added support for `statix` and `deadnix` through - Added support for `statix` and `deadnix` through
[](#opt-vim.languages.nix.extraDiagnostics.types) {option}`vim.languages.nix.extraDiagnostics.types`
- Added `lsp_lines` plugin for showing diagnostic messages - Added `lsp_lines` plugin for showing diagnostic messages
- Added a configuration option for choosing the leader key - Added a configuration option for choosing the leader key
- The package used for neovim is now customizable by the user, using - The package used for neovim is now customizable by the user, using
[](#opt-vim.package). For best results, always use an unwrapped package {option}`vim.package`. For best results, always use an unwrapped package
- Added highlight-undo plugin for highlighting undo/redo targets - Added highlight-undo plugin for highlighting undo/redo targets

26
docs/release-notes/rl-0.6.md → docs/manual/release-notes/rl-0.6.md
View file

@ -1,4 +1,4 @@
# Release 0.6 {#sec-release-0.6} # Release 0.6 {#sec-release-0-6}
Release notes for release 0.6 Release notes for release 0.6
@ -41,14 +41,14 @@ end
vim.api.nvim_set_keymap('n', '<leader>a', ':lua camelToSnake()<CR>', { noremap = true, silent = true }) vim.api.nvim_set_keymap('n', '<leader>a', ':lua camelToSnake()<CR>', { noremap = true, silent = true })
``` ```
## Changelog {#sec-release-0.6-changelog} ## Changelog {#sec-release-0-6-changelog}
[ksonj](https://github.com/ksonj): [ksonj](https://github.com/ksonj):
- Added Terraform language support. - Added Terraform language support.
- Added `ChatGPT.nvim`, which can be enabled with - Added `ChatGPT.nvim`, which can be enabled with
[](#opt-vim.assistant.chatgpt.enable). Do keep in mind that this option {option}`vim.assistant.chatgpt.enable`. Do keep in mind that this option
requires `OPENAI_API_KEY` environment variable to be set. requires `OPENAI_API_KEY` environment variable to be set.
[donnerinoern](https://github.com/donnerinoern): [donnerinoern](https://github.com/donnerinoern):
@ -95,7 +95,7 @@ vim.api.nvim_set_keymap('n', '<leader>a', ':lua camelToSnake()<CR>', { noremap =
and also has been removed. and also has been removed.
- `which-key.nvim` categories can now be customized through - `which-key.nvim` categories can now be customized through
[vim.binds.whichKey.register](#opt-vim.binds.whichKey.register) [vim.binds.whichKey.register](./options.html#option-vim-binds-whichKey-register)
- Added `magick` to `vim.luaPackages` for `image.nvim`. - Added `magick` to `vim.luaPackages` for `image.nvim`.
@ -125,10 +125,10 @@ vim.api.nvim_set_keymap('n', '<leader>a', ':lua camelToSnake()<CR>', { noremap =
- Lualine module now allows customizing `always_divide_middle`, `ignore_focus` - Lualine module now allows customizing `always_divide_middle`, `ignore_focus`
and `disabled_filetypes` through the new options: and `disabled_filetypes` through the new options:
[vim.statusline.lualine.alwaysDivideMiddle](#opt-vim.statusline.lualine.alwaysDivideMiddle), [vim.statusline.lualine.alwaysDivideMiddle](./options.html#option-vim-statusline-lualine-alwaysDivideMiddle),
[vim.statusline.lualine.ignoreFocus](#opt-vim.statusline.lualine.ignoreFocus) [vim.statusline.lualine.ignoreFocus](./options.html#option-vim-statusline-lualine-ignoreFocus)
and and
[vim.statusline.lualine.disabledFiletypes](#opt-vim.statusline.lualine.disabledFiletypes). [vim.statusline.lualine.disabledFiletypes](./options.html#option-vim-statusline-lualine-disabledFiletypes).
- Updated all plugin inputs to their latest versions (**21.04.2024**) - this - Updated all plugin inputs to their latest versions (**21.04.2024**) - this
brought minor color changes to the Catppuccin theme. brought minor color changes to the Catppuccin theme.
@ -159,10 +159,10 @@ vim.api.nvim_set_keymap('n', '<leader>a', ':lua camelToSnake()<CR>', { noremap =
arguments to take `luaBefore`, `luaConfig` and `luaAfter` as strings, which arguments to take `luaBefore`, `luaConfig` and `luaAfter` as strings, which
are then concatted inside a lua block. are then concatted inside a lua block.
- Added [](#opt-vim.luaConfigPre) and [](#opt-vim.luaConfigPost) for inserting - Added {option}`vim.luaConfigPre` and {option} `vim-luaConfigPost` for
verbatim Lua configuration before and after the resolved Lua DAG respectively. inserting verbatim Lua configuration before and after the resolved Lua DAG
Both of those options take strings as the type, so you may read the contents respectively. Both of those options take strings as the type, so you may read
of a Lua file from a given path. the contents of a Lua file from a given path.
- Added `vim.spellchecking.ignoredFiletypes` and - Added `vim.spellchecking.ignoredFiletypes` and
`vim.spellChecking.programmingWordlist.enable` for ignoring certain filetypes `vim.spellChecking.programmingWordlist.enable` for ignoring certain filetypes
@ -172,12 +172,12 @@ vim.api.nvim_set_keymap('n', '<leader>a', ':lua camelToSnake()<CR>', { noremap =
- Exposed `withRuby`, `withNodeJs`, `withPython3`, and `python3Packages` from - Exposed `withRuby`, `withNodeJs`, `withPython3`, and `python3Packages` from
the `makeNeovimConfig` function under their respective options. the `makeNeovimConfig` function under their respective options.
- Added [](#opt-vim.extraPackages) for appending additional packages to the - Added {option}`vim.extraPackages` for appending additional packages to the
wrapper PATH, making said packages available while inside the Neovim session. wrapper PATH, making said packages available while inside the Neovim session.
- Made Treesitter options configurable, and moved treesitter-context to - Made Treesitter options configurable, and moved treesitter-context to
`setupOpts` while it is enabled. `setupOpts` while it is enabled.
- Added [](#opt-vim.notify.nvim-notify.setupOpts.render) which takes either a - Added {option}`vim.notify.nvim-notify.setupOpts.render` which takes either a
string of enum, or a Lua function. The default is "compact", but you may string of enum, or a Lua function. The default is "compact", but you may
change it according to nvim-notify documentation. change it according to nvim-notify documentation.

42
docs/release-notes/rl-0.7.md → docs/manual/release-notes/rl-0.7.md
View file

@ -1,4 +1,4 @@
# Release 0.7 {#sec-release-0.7} # Release 0.7 {#sec-release-0-7}
Release notes for release 0.7 Release notes for release 0.7
@ -98,7 +98,7 @@ options that were under `vim` as convenient shorthands for `vim.o.*` options.
::: {.warning} ::: {.warning}
As v0.7 features the addition of [](#opt-vim.options), those options are now As v0.7 features the addition of {option}`vim.options`, those options are now
considered as deprecated. You should migrate to the appropriate options in the considered as deprecated. You should migrate to the appropriate options in the
`vim.options` submodule. `vim.options` submodule.
@ -108,14 +108,14 @@ The changes are, in no particular order:
- `colourTerm`, `mouseSupport`, `cmdHeight`, `updateTime`, `mapTime`, - `colourTerm`, `mouseSupport`, `cmdHeight`, `updateTime`, `mapTime`,
`cursorlineOpt`, `splitBelow`, `splitRight`, `autoIndent` and `wordWrap` have `cursorlineOpt`, `splitBelow`, `splitRight`, `autoIndent` and `wordWrap` have
been mapped to their [](#opt-vim.options) equivalents. Please see the module been mapped to their {option}`vim.options` equivalents. Please see the module
definition for the updated options. definition for the updated options.
- `tabWidth` has been **removed** as it lead to confusing behaviour. You can - `tabWidth` has been **removed** as it lead to confusing behaviour. You can
replicate the same functionality by setting `shiftwidth`, `tabstop` and replicate the same functionality by setting `shiftwidth`, `tabstop` and
`softtabstop` under `vim.options` as you see fit. `softtabstop` under `vim.options` as you see fit.
## Changelog {#sec-release-0.7-changelog} ## Changelog {#sec-release-0-7-changelog}
[ItsSorae](https://github.com/ItsSorae): [ItsSorae](https://github.com/ItsSorae):
@ -125,7 +125,7 @@ The changes are, in no particular order:
[frothymarrow](https://github.com/frothymarrow): [frothymarrow](https://github.com/frothymarrow):
- Modified type for - Modified type for
[](#opt-vim.visuals.fidget-nvim.setupOpts.progress.display.overrides) from {option}`vim.visuals.fidget-nvim.setupOpts.progress.display.overrides` from
`anything` to a `submodule` for better type checking. `anything` to a `submodule` for better type checking.
- Fix null `vim.lsp.mappings` generating an error and not being filtered out. - Fix null `vim.lsp.mappings` generating an error and not being filtered out.
@ -134,7 +134,7 @@ The changes are, in no particular order:
group for `Normal`, `NormalFloat`, `LineNr`, `SignColumn` and optionally group for `Normal`, `NormalFloat`, `LineNr`, `SignColumn` and optionally
`NvimTreeNormal` to `none`. `NvimTreeNormal` to `none`.
- Fix [](#opt-vim.ui.smartcolumn.setupOpts.custom_colorcolumn) using the wrong - Fix {option}`vim.ui.smartcolumn.setupOpts.custom_colorcolumn` using the wrong
type `int` instead of the expected type `string`. type `int` instead of the expected type `string`.
[horriblename](https://github.com/horriblename): [horriblename](https://github.com/horriblename):
@ -170,7 +170,7 @@ The changes are, in no particular order:
- Add [ocaml-lsp] support - Add [ocaml-lsp] support
- Fix misspelled "Emacs" - Fix "Emac" typo
- Add [new-file-template.nvim] to automatically fill new file contents using - Add [new-file-template.nvim] to automatically fill new file contents using
templates templates
@ -216,18 +216,18 @@ The changes are, in no particular order:
- Remove `autopairs.type`, and rename `autopairs.enable` to - Remove `autopairs.type`, and rename `autopairs.enable` to
`autopairs.nvim-autopairs.enable`. The new `autopairs.nvim-autopairs.enable`. The new
[](#opt-vim.autopairs.nvim-autopairs.enable) supports `setupOpts` format by {option}`vim.autopairs.nvim-autopairs.enable` supports `setupOpts` format by
default. default.
- Refactor of `nvim-cmp` and completion related modules - Refactor of `nvim-cmp` and completion related modules
- Remove `autocomplete.type` in favor of per-plugin enable options such as - Remove `autocomplete.type` in favor of per-plugin enable options such as
[](#opt-vim.autocomplete.nvim-cmp.enable). {option}`vim.autocomplete.nvim-cmp.enable`.
- Deprecate legacy Vimsnip in favor of Luasnip, and integrate - Deprecate legacy Vimsnip in favor of Luasnip, and integrate
friendly-snippets for bundled snippets. [](#opt-vim.snippets.luasnip.enable) friendly-snippets for bundled snippets.
can be used to toggle Luasnip. {option}`vim.snippets.luasnip.enable` can be used to toggle Luasnip.
- Add sorting function options for completion sources under - Add sorting function options for completion sources under
[](#opt-vim.autocomplete.nvim-cmp.setupOpts.sorting.comparators) {option}`vim.autocomplete.nvim-cmp.setupOpts.sorting.comparators`
- Add C# support under `vim.languages.csharp`, with support for both - Add C# support under `vim.languages.csharp`, with support for both
omnisharp-roslyn and csharp-language-server. omnisharp-roslyn and csharp-language-server.
@ -297,12 +297,12 @@ The changes are, in no particular order:
Lualine. Only `vim.ui.breadcrumbs.lualine.winbar` is supported for the time Lualine. Only `vim.ui.breadcrumbs.lualine.winbar` is supported for the time
being. being.
- [](#opt-vim.ui.breadcrumbs.lualine.winbar.enable) has been added to allow - {option}`vim.ui.breadcrumbs.lualine.winbar.enable` has been added to allow
controlling the default behaviour of the `nvim-navic` component on Lualine, controlling the default behaviour of the `nvim-navic` component on Lualine,
which used to occupy `winbar.lualine_c` as long as breadcrumbs are enabled. which used to occupy `winbar.lualine_c` as long as breadcrumbs are enabled.
- `vim.ui.breadcrumbs.alwaysRender` has been renamed to - `vim.ui.breadcrumbs.alwaysRender` has been renamed to
[](#opt-vim.ui.breadcrumbs.lualine.winbar.alwaysRender) to be conform to the {option}`vim.ui.breadcrumbs.lualine.winbar.alwaysRender` to be conform to
new format. the new format.
- Add [basedpyright](https://github.com/detachhead/basedpyright) as a Python LSP - Add [basedpyright](https://github.com/detachhead/basedpyright) as a Python LSP
server and make it default. server and make it default.
@ -310,10 +310,10 @@ The changes are, in no particular order:
- Add [python-lsp-server](https://github.com/python-lsp/python-lsp-server) as an - Add [python-lsp-server](https://github.com/python-lsp/python-lsp-server) as an
additional Python LSP server. additional Python LSP server.
- Add [](#opt-vim.options) to set `vim.o` values in in your nvf configuration - Add {option}`vim.options` to set `vim.o` values in in your nvf configuration
without using additional Lua. See option documentation for more details. without using additional Lua. See option documentation for more details.
- Add [](#opt-vim.dashboard.dashboard-nvim.setupOpts) to allow user - Add {option}`vim.dashboard.dashboard-nvim.setupOpts` to allow user
configuration for [dashboard.nvim](https://github.com/nvimdev/dashboard-nvim) configuration for [dashboard.nvim](https://github.com/nvimdev/dashboard-nvim)
- Update `lualine.nvim` input and add missing themes: - Update `lualine.nvim` input and add missing themes:
@ -321,7 +321,7 @@ The changes are, in no particular order:
- Adds `ayu`, `gruvbox_dark`, `iceberg`, `moonfly`, `onedark`, - Adds `ayu`, `gruvbox_dark`, `iceberg`, `moonfly`, `onedark`,
`powerline_dark` and `solarized_light` themes. `powerline_dark` and `solarized_light` themes.
- Add [](#opt-vim.spellcheck.extraSpellWords) to allow adding arbitrary - Add {option}`vim.spellcheck.extraSpellWords` to allow adding arbitrary
spellfiles to Neovim's runtime with ease. spellfiles to Neovim's runtime with ease.
- Add combined nvf configuration (`config.vim`) into the final package's - Add combined nvf configuration (`config.vim`) into the final package's
@ -375,9 +375,9 @@ The changes are, in no particular order:
[nezia1](https://github.com/nezia1): [nezia1](https://github.com/nezia1):
- Add [biome](https://github.com/biomejs/biome) support for Typescript, CSS and - Add [biome](https://github.com/biomejs/biome) support for Typescript, CSS and
Svelte. Enable them via [](#opt-vim.languages.ts.format.type), Svelte. Enable them via {option}`vim.languages.ts.format.type`,
[](#opt-vim.languages.css.format.type) and {option}`vim.languages.css.format.type` and
[](#opt-vim.languages.svelte.format.type) respectively. {option}`vim.languages.svelte.format.type` respectively.
- Replace [nixpkgs-fmt](https://github.com/nix-community/nixpkgs-fmt) with - Replace [nixpkgs-fmt](https://github.com/nix-community/nixpkgs-fmt) with
[nixfmt](https://github.com/NixOS/nixfmt) (nixfmt-rfc-style). [nixfmt](https://github.com/NixOS/nixfmt) (nixfmt-rfc-style).

28
docs/release-notes/rl-0.8.md → docs/manual/release-notes/rl-0.8.md
View file

@ -1,4 +1,4 @@
# Release 0.8 {#sec-release-0.8} # Release 0.8 {#sec-release-0-8}
## Breaking changes ## Breaking changes
@ -21,7 +21,7 @@
- `vim.useSystemClipboard` has been deprecated as a part of removing most - `vim.useSystemClipboard` has been deprecated as a part of removing most
top-level convenience options, and should instead be configured in the new top-level convenience options, and should instead be configured in the new
module interface. You may set [](#opt-vim.clipboard.registers) appropriately module interface. You may set {option}`vim.clipboard.registers` appropriately
to configure Neovim to use the system clipboard. to configure Neovim to use the system clipboard.
- Changed which-key group used for gitsigns from `<leader>g` to `<leader>h` to - Changed which-key group used for gitsigns from `<leader>g` to `<leader>h` to
@ -32,6 +32,8 @@
autocmd event. If you were calling `default_on_attach()` in your LSP setup you autocmd event. If you were calling `default_on_attach()` in your LSP setup you
can remove them now. can remove them now.
## Changelog {#sec-release-0-8-changelog}
[NotAShelf](https://github.com/notashelf): [NotAShelf](https://github.com/notashelf):
[typst-preview.nvim]: https://github.com/chomosuke/typst-preview.nvim [typst-preview.nvim]: https://github.com/chomosuke/typst-preview.nvim
@ -52,16 +54,16 @@
- Add [render-markdown.nvim] under - Add [render-markdown.nvim] under
`languages.markdown.extensions.render-markdown-nvim`. `languages.markdown.extensions.render-markdown-nvim`.
- Implement [](#opt-vim.git.gitsigns.setupOpts) for user-specified setup table - Implement {option}`vim.git.gitsigns.setupOpts` for user-specified setup table
in gitsigns configuration. in gitsigns configuration.
- [](#opt-vim.options.mouse) no longer compares values to an enum of available - {option}`vim.options.mouse` no longer compares values to an enum of available
mouse modes. This means you can provide any string without the module system mouse modes. This means you can provide any string without the module system
warning you that it is invalid. Do keep in mind that this value is no longer warning you that it is invalid. Do keep in mind that this value is no longer
checked, so you will be responsible for ensuring its validity. checked, so you will be responsible for ensuring its validity.
- Deprecate `vim.enableEditorconfig` in favor of - Deprecate `vim.enableEditorconfig` in favor of
[](#opt-vim.globals.editorconfig). {option}`vim.globals.editorconfig`.
- Deprecate rnix-lsp as it has been abandoned and archived upstream. - Deprecate rnix-lsp as it has been abandoned and archived upstream.
@ -70,9 +72,9 @@
your Editorconfig configuration, or use an autocommand to set indentation your Editorconfig configuration, or use an autocommand to set indentation
values for buffers with the Nix filetype. values for buffers with the Nix filetype.
- Add [](#opt-vim.lsp.lightbulb.autocmd.enable) for manually managing the - Add {option}`vim.lsp.lightbulb.autocmd.enable` for manually managing the
previously managed lightbulb autocommand. previously managed lightbulb autocommand.
- A warning will occur if [](#opt-vim.lsp.lightbulb.autocmd.enable) and - A warning will occur if {option} vim-lsp-lightbulb-autocmd-enable) and
`vim.lsp.lightbulb.setupOpts.autocmd.enabled` are both set at the same time. `vim.lsp.lightbulb.setupOpts.autocmd.enabled` are both set at the same time.
Pick only one. Pick only one.
@ -83,7 +85,7 @@
- Add [yazi.nvim] as a companion plugin for Yazi, the terminal file manager. - Add [yazi.nvim] as a companion plugin for Yazi, the terminal file manager.
- Add [](#opt-vim.autocmds) and [](#opt-vim.augroups) to allow declaring - Add {option}`vim.autocmds` and {option}`vim-augroups` to allow declaring
autocommands via Nix. autocommands via Nix.
- Fix plugin `setupOpts` for yanky.nvim and assert if shada is configured as a - Fix plugin `setupOpts` for yanky.nvim and assert if shada is configured as a
@ -105,7 +107,7 @@
`vim.utility.oil-nvim`. `vim.utility.oil-nvim`.
- Add `vim.diagnostics` to interact with Neovim's diagnostics module. Available - Add `vim.diagnostics` to interact with Neovim's diagnostics module. Available
options for `vim.diagnostic.config()` can now be customized through the options for `vim.diagnostic.config()` can now be customized through the
[](#opt-vim.diagnostics.config) in nvf. {option}`vim.diagnostics.config` in nvf.
- Add `vim.clipboard` module for easily managing Neovim clipboard providers and - Add `vim.clipboard` module for easily managing Neovim clipboard providers and
relevant packages in a simple UI. relevant packages in a simple UI.
@ -207,7 +209,7 @@
- Add [fzf-lua](https://github.com/ibhagwan/fzf-lua) in `vim.fzf-lua` - Add [fzf-lua](https://github.com/ibhagwan/fzf-lua) in `vim.fzf-lua`
- Add [rainbow-delimiters](https://github.com/HiPhish/rainbow-delimiters.nvim) - Add [rainbow-delimiters](https://github.com/HiPhish/rainbow-delimiters.nvim)
in `vim.visuals.rainbow-delimiters` in `vim.visuals.rainbow-delimiters`
- Add options to define highlights under [](#opt-vim.highlight) - Add options to define highlights under {option}`vim.highlight`
[kaktu5](https://github.com/kaktu5): [kaktu5](https://github.com/kaktu5):
@ -223,8 +225,8 @@
[thamenato](https://github.com/thamenato): [thamenato](https://github.com/thamenato):
[ruff]: (https://github.com/astral-sh/ruff) [ruff]: https://github.com/astral-sh/ruff
[cue]: (https://cuelang.org/) [cue]: https://cuelang.org/
- Add [ruff] as a formatter option in `vim.languages.python.format.type`. - Add [ruff] as a formatter option in `vim.languages.python.format.type`.
- Add [cue] support under `vim.languages.cue`. - Add [cue] support under `vim.languages.cue`.
@ -551,7 +553,7 @@
[valterschutz](https://github.com/valterschutz): [valterschutz](https://github.com/valterschutz):
[ruff]: (https://github.com/astral-sh/ruff) [ruff]: https://github.com/astral-sh/ruff
- Add [ruff-fix] as a formatter option in `vim.languages.python.format.type`. - Add [ruff-fix] as a formatter option in `vim.languages.python.format.type`.

2
docs/manual/tips.md
View file

@ -6,7 +6,7 @@ documentation, configuring **nvf** with pure Lua and using custom plugin sources
in **nvf** in this section. For general configuration tips, please see previous in **nvf** in this section. For general configuration tips, please see previous
chapters. chapters.
```{=include=} chapters ```{=include=}
tips/debugging-nvf.md tips/debugging-nvf.md
tips/offline-docs.md tips/offline-docs.md
tips/pure-lua-config.md tips/pure-lua-config.md

4
docs/manual/tips/plugin-sources.md
View file

@ -26,7 +26,7 @@ startup.
} }
``` ```
[`vim.extraPlugins`]: https://notashelf.github.io/nvf/options.html#opt-vim.extraPlugins [`vim.extraPlugins`]: ./options.html#option-vim-extraPlugins
This will fetch aerial.nvim from nixpkgs, and add it to Neovim's runtime path to 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 be loaded manually. Although for plugins that require manual setup, you are
@ -43,7 +43,7 @@ encouraged to use [`vim.extraPlugins`].
} }
``` ```
[custom plugins section]: https://notashelf.github.io/nvf/index.xhtml#ch-custom-plugins [custom plugins section]: ./configuring.html#ch-custom-plugins
More details on the extraPlugins API is documented in the More details on the extraPlugins API is documented in the
[custom plugins section]. [custom plugins section].

6
docs/manual/tips/pure-lua-config.md
View file

@ -36,7 +36,7 @@ manner.
This will add the `nvim` directory, or rather, the _store path_ that will be This will add the `nvim` directory, or rather, the _store path_ that will be
realised after your flake gets copied to the Nix store, to Neovim's runtime realised after your flake gets copied to the Nix store, to Neovim's runtime
directory. You may now create a `lua/myconfig` directory within this nvim directory. You may now create a `lua/myconfig` directory within this nvim
directory, and call it with [](#opt-vim.luaConfigRC). directory, and call it with {option}`vim.luaConfigRC`.
```nix ```nix
{pkgs, ...}: { {pkgs, ...}: {
@ -90,7 +90,7 @@ vim.keymap.set("n", " ", "<Nop>", { silent = true, remap = false })
vim.g.mapleader = " " vim.g.mapleader = " "
``` ```
The following Nix configuration via [](#opt-vim.luaConfigRC) will allow loading The following Nix configuration via {option}`vim.luaConfigRC` will allow loading
this this
```nix ```nix
@ -105,7 +105,7 @@ this
} }
``` ```
[DAG system]: https://notashelf.github.io/nvf/index.xhtml#ch-using-dags [DAG system]: ./configuring.html#ch-using-dags
After you load your custom configuration, you may use an `init.lua` located in After you load your custom configuration, you may use an `init.lua` located in
your custom configuration directory to configure Neovim exactly as you would your custom configuration directory to configure Neovim exactly as you would

14
docs/release-notes/release-notes.md
View file

@ -1,14 +0,0 @@
# Release Notes {#ch-release-notes}
This section lists the release notes for tagged version of **nvf** and the
current main current main branch
```{=include=} chapters
rl-0.1.md
rl-0.2.md
rl-0.3.md
rl-0.4.md
rl-0.5.md
rl-0.6.md
rl-0.7.md
```

37
flake.lock generated
View file

@ -51,7 +51,41 @@
"type": "github" "type": "github"
} }
}, },
"ndg": {
"inputs": {
"nixpkgs": "nixpkgs"
},
"locked": {
"lastModified": 1765435293,
"narHash": "sha256-HRp4g6qBCb8vpJ17s2FacMRXRszM73uBiR56aILMELA=",
"owner": "feel-co",
"repo": "ndg",
"rev": "65bf834b332d5f8b28d95ea14c7974be7c272971",
"type": "github"
},
"original": {
"owner": "feel-co",
"repo": "ndg",
"type": "github"
}
},
"nixpkgs": { "nixpkgs": {
"locked": {
"lastModified": 1764242076,
"narHash": "sha256-sKoIWfnijJ0+9e4wRvIgm/HgE27bzwQxcEmo2J/gNpI=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "2fad6eac6077f03fe109c4d4eb171cf96791faa4",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixos-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"nixpkgs_2": {
"locked": { "locked": {
"lastModified": 1764081664, "lastModified": 1764081664,
"narHash": "sha256-sUoHmPr/EwXzRMpv1u/kH+dXuvJEyyF2Q7muE+t0EU4=", "narHash": "sha256-sUoHmPr/EwXzRMpv1u/kH+dXuvJEyyF2Q7muE+t0EU4=",
@ -72,7 +106,8 @@
"flake-compat": "flake-compat", "flake-compat": "flake-compat",
"flake-parts": "flake-parts", "flake-parts": "flake-parts",
"mnw": "mnw", "mnw": "mnw",
"nixpkgs": "nixpkgs", "ndg": "ndg",
"nixpkgs": "nixpkgs_2",
"systems": "systems" "systems": "systems"
} }
}, },

3
flake.nix
View file

@ -105,5 +105,8 @@
# Alternate neovim-wrapper # Alternate neovim-wrapper
mnw.url = "github:Gerg-L/mnw"; mnw.url = "github:Gerg-L/mnw";
# Alternative documentation generator
ndg.url = "github:feel-co/ndg";
}; };
} }

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

@ -15,7 +15,7 @@ in {
clipboard = { clipboard = {
enable = mkEnableOption '' enable = mkEnableOption ''
clipboard management for Neovim. Users may still choose to manage their clipboard management for Neovim. Users may still choose to manage their
clipboard through [](#opt-vim.options) should they wish to avoid using clipboard through {option}`vim.options` should they wish to avoid using
this module. this module.
''; '';

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

@ -29,7 +29,7 @@ in {
To add your own language files, you may place your `spell` directory in either To add your own language files, you may place your `spell` directory in either
{file}`$XDG_CONFIG_HOME/nvf` or in a path that is included in the {file}`$XDG_CONFIG_HOME/nvf` or in a path that is included in the
[additionalRuntimePaths](#opt-vim.additionalRuntimePaths) list provided by nvf. [additionalRuntimePaths](./options.html#option-vim-additionalRuntimePaths) list provided by nvf.
''; '';
}; };

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

@ -107,7 +107,7 @@ in {
option, since there is no way to provide only the LSP server. option, since there is no way to provide only the LSP server.
If you want to avoid that, you have to change If you want to avoid that, you have to change
[vim.lsp.servers.julials.cmd](#opt-vim.lsp.servers._name_.cmd) to use {option}`vim.lsp.servers.julials.cmd` to use
the Julia binary in {env}`PATH`, and add the `LanguageServer` the Julia binary in {env}`PATH`, and add the `LanguageServer`
package to Julia in your devshells. package to Julia in your devshells.

2
modules/plugins/treesitter/ts-context/context.nix
View file

@ -62,7 +62,7 @@ in {
default = "outer"; default = "outer";
description = '' description = ''
Which context lines to discard if Which context lines to discard if
[](#opt-vim.treesitter.context.setupOpts.max_lines) is exceeded. {option}`vim.treesitter.context.setupOpts.max_lines` is exceeded.
''; '';
}; };

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

@ -43,7 +43,7 @@
default = ["${pkgs.fd}/bin/fd"]; default = ["${pkgs.fd}/bin/fd"];
description = '' description = ''
Command to use for finding files. If using an executable from {env}`PATH` then you must Command to use for finding files. If using an executable from {env}`PATH` then you must
make sure that the package is available in [](#opt-vim.extraPackages). make sure that the package is available in {option}`vim.extraPackages`.
''; '';
}; };

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

@ -180,7 +180,7 @@ in {
overrides = mkOption { overrides = mkOption {
description = '' description = ''
Overrides the default configuration for a notification group defined Overrides the default configuration for a notification group defined
in [](#opt-vim.visuals.fidget-nvim.setupOpts.notification.configs). in {option}`vim.visuals.fidget-nvim.setupOpts.notification.configs`.
If any of the fields are null, the value from the default If any of the fields are null, the value from the default
configuration is used. configuration is used.

2
modules/wrapper/environment/options.nix
View file

@ -47,7 +47,7 @@ in {
internally to add plugins to Neovim's runtime. internally to add plugins to Neovim's runtime.
To add additional plugins to your configuration, consider To add additional plugins to your configuration, consider
using the [{option}`vim.extraPlugins`](#opt-vim.extraPlugins) using the {option}`vim.extraPlugins`
option. option.
''; '';
}; };

2
modules/wrapper/lazy/lazy.nix
View file

@ -121,7 +121,7 @@
description = '' description = ''
Lua code to run after plugin is loaded. This will be wrapped in a function. Lua code to run after plugin is loaded. This will be wrapped in a function.
If [](#opt-vim.lazy.plugins._name_.setupModule) is provided, the setup will be ran before `after`. If {option}`vim.lazy.plugins._name_.setupModule` is provided, the setup will be ran before `after`.
''; '';
}; };

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

@ -284,9 +284,9 @@ in {
default = ""; default = "";
defaultText = literalMD '' defaultText = literalMD ''
By default, this option will **append** paths in By default, this option will **append** paths in
[](#opt-vim.additionalRuntimePaths) {option}`vim-additionalRuntimePaths`
to the `runtimepath` and enable the experimental Lua module loader to the `runtimepath` and enable the experimental Lua module loader
if [](#opt-vim.enableLuaLoader) is set to true. if {option}`vim.enableLuaLoader` is set to true.
''; '';
example = literalExpression "\${builtins.readFile ./my-lua-config-pre.lua}"; example = literalExpression "\${builtins.readFile ./my-lua-config-pre.lua}";