nvf/docs/manual/hacking.adoc

[[ch-hacking]]
== Hacking neovim-flake

neovim-flake is designed for developers as much as it is for the end user. I would like any potential contributor
to be able to propagate their desired changes into the repository without the extra effort. As such, below are guides
(and guidelines) to streamline the contribution process and ensure that your valuable input seamlessly integrates
into neovim-flake's development without leaving question marks in your head.

:fork-a-repo: https://help.github.com/articles/fork-a-repo/
:open-issues: https://github.com/notashelf/neovim-flake/issues
:new-issue: https://github.com/notashelf/neovim-flake/issues/new
:seven-rules: https://cbea.ms/git-commit/#seven-rules
:example-commit-message: https://github.com/nix-community/home-manager/commit/69f8e47e9e74c8d3d060ca22e18246b7f7d988ef

This section is mainly directed towards those who wish to contribute code into neovim-flake. If you wish to instead
report a bug or discuss a potential feature implementation, first look among the already {open-issues}[open issues] and
if no matching issue exists you may open a {new-issue}[new issue] and describe your problem/request. While creating an
issue, please try to include as much information as you can, ideally also include relevant context in which an issue
occurs or a feature should be implemented.

[[sec-contrib-getting-started]]
=== Getting started

You naturally would like to start by forking the repository. If you are new to git, have a look at GitHub's
{fork-a-repo}[Fork a repo guide] for instructions on how you can do this. Once you have a fork of neovim-flake
you should create a branch starting at the most recent `main` branch.
Give your branch a reasonably descriptive name, suffixed by its type - i.e `feature/debugger` or `fix/pesky-bug`.

Implement your changes and commit them to the newly created branch and when you are happy with the result and positive
that it fulfills <<sec-guidelines>>. Once you are confident everything is in order, push the branch to GitHub and
{create-a-pull-request}[create a pull request], following the template that you will be prompted to fill.

[[sec-guidelines]]
=== Guidelines
:assertions: https://nixos.org/manual/nixos/stable/index.html#sec-assertions
:discussions-tab: https://github.com/NotAShelf/neovim-flake/discussions

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}[discussions tab] ideally (but not necessarily) before you start developing.

[[sec-documentation]]
==== Add adequate documentation
:nixpkgs-markdown: https://nixos.org/manual/nixpkgs/unstable/#sec-contributing-markup
:docbook: https://tdg.docbook.org/
:asciidoc: https://asciidoc.org/

Most, if not all, changes warrant changes to the documentation. Module options should be documented with
{nixpkgs-markdown}[Nixpkgs-flavoured Markdown], albeit with exceptions.
neovim-flake is itself documented using a combination of {docbook}[DocBook] and {asciidoc}[AsciiDoc] conventions.

The HTML version of this manual containing both the module option descriptions and the documentation of neovim-flake
(such as this page) can be generated and opened by typing the following in a shell within a clone of the
neovim-flake Git repository:

[source,console]
----
$ nix build .#docs-html
$ xdg-open ./result/share/doc/neovim-flake/index.html
----

[[sec-guidelines-code-style]]
==== Format your code

Make sure your code is formatted as described in <<sec-code-style>>. To maintain consistency throughout the project
you are encouraged to browse through existing code and adopt its style also in new code.

[[sec-guidelines-commit-message-style]]
==== Format your commit messages

Similar to <<sec-guidelines-code-style>> we encourage a consistent commit message format as described
in <<sec-commit-style>>.

[[sec-commit-style]]
==== Commits

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}[seven rules], 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 <<ex-commit-message>> for a commit message that fulfills these requirements.

[[ex-commit-message]]
.Compliant commit message
===============================================================================
The commit {example-commit-message}[69f8e47e9e74c8d3d060ca22e18246b7f7d988ef] contains the 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.
----
===============================================================================

Long description can be ommitted 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 for your changes.

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


[[sec-code-style]]
==== Code Style
:alejandra: https://github.com/kamadorueda/alejandra

**Treewide**
Keep lines at a reasonable width, ideally 80 characters or less. This also applies to string literals and module
descriptions and documentation.

**Nix**
neovim-flake is formatted by the {alejandra}[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:

[source,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
        someOtherValue = mkOption {
            type = lib.types.bool;
            description = "Some other description"
            default = true;
        };
    };
}
----

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.

[source,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.

[source,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
singleItemList = [item1];
----

[[sec-testing]]
=== Testing Your Changes

Once you have made your changes, you will need to test them throughly. 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 posssible.

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.

[[sec-keybinds]]
=== 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 https://github.com/NotAShelf/neovim-flake/tree/main/lib[extended standard library]. The following section contains
a general overview to how you may utilize said functions.

[[sec-custom-key-mappings]]
==== Custom Key Mappings Support for a Plugin

:maps: https://notashelf.github.io/neovim-flake/options.html#opt-vim.maps.command._name_.action

To set a mapping, you should define it in `vim.maps.<<mode>>`.
The available modes are:

* normal
* insert
* select
* visual
* terminal
* normalVisualOp
* visualOnly
* operator
* insertCommand
* lang
* command

An example, simple keybinding, can look like this:

[source,nix]
----
{
  vim.maps.normal = {
    "<leader>wq" = {
      action = ":wq<CR>";
      silent = true;
      desc = "Save file and quit";
    };
  };
}
----

There are many settings available in the options. Please refer to the {maps}[documentation] to see a list of them.

`neovim-flake` provides a list of helper commands, so that you don't have to write the mapping attribute sets every
time:

* `mkBinding = key: action: desc:` - makes a basic binding, with `silent` set to true.
* `mkExprBinding = key: action: desc:` - makes an expression binding, with `lua`, `silent`, and `expr` set to true.
* `mkLuaBinding = key: action: desc:` - makes an expression binding, with `lua`, and `silent` set to true.

Note that the Lua in these bindings is actual Lua, not pasted into a `:lua` command.
Therefore, you either pass in a function like `require('someplugin').some_function`, without actually calling it,
or you define your own function, like `function() require('someplugin').some_function() end`.

Additionally, to not have to repeat the descriptions, there's another utility function with its own set of functions:

[source,nix]
----
# Utility function that takes two attrsets:
# { someKey = "some_value" } and
# { someKey = { description = "Some Description"; }; }
# and merges them into
# { someKey = { value = "some_value"; description = "Some Description"; }; }

addDescriptionsToMappings = actualMappings: mappingDefinitions:
----

This function can be used in combination with the same `mkBinding` functions as above, except they only take two
arguments - `binding` and `action`, and have different names:

* `mkSetBinding = binding: action:` - makes a basic binding, with `silent` set to true.
* `mkSetExprBinding = binding: action:` - makes an expression binding, with `lua`, `silent`, and `expr` set to true.
* `mkSetLuaBinding = binding: action:` - makes an expression binding, with `lua`, and `silent` set to true.

You can read the source code of some modules to see them in action, but their usage should look something like this:

[source,nix]
----
# plugindefinition.nix
{lib, ...}:
with lib; {
  options.vim.plugin = {
    enable = mkEnableOption "Enable plugin";

    # Mappings should always be inside an attrset called mappings
    mappings = {
      # mkMappingOption is a helper function from lib,
      # that takes a description (which will also appear in which-key),
      # and a default mapping (which can be null)
      toggleCurrentLine = mkMappingOption "Toggle current line comment" "gcc";
      toggleCurrentBlock = mkMappingOption "Toggle current block comment" "gbc";

      toggleOpLeaderLine = mkMappingOption "Toggle line comment" "gc";
      toggleOpLeaderBlock = mkMappingOption "Toggle block comment" "gb";

      toggleSelectedLine = mkMappingOption "Toggle selected comment" "gc";
      toggleSelectedBlock = mkMappingOption "Toggle selected block" "gb";
    };
  };
}
----

[source,nix]
----
# config.nix
{
  pkgs,
  config,
  lib,
  ...
}:
with lib;
with builtins; let
  cfg = config.vim.plugin;
  self = import ./plugindefinition.nix {inherit lib;};
  mappingDefinitions = self.options.vim.plugin;

  # addDescriptionsToMappings is a helper function from lib,
  # that merges mapping values and their descriptions
  # into one nice attribute set
  mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
in {
  config = mkIf (cfg.enable) {
    # ...

    vim.maps.normal = mkMerge [
      # mkSetBinding is another helper function from lib,
      # that actually adds the mapping with a description.
      (mkSetBinding mappings.findFiles "<cmd> Telescope find_files<CR>")
      (mkSetBinding mappings.liveGrep "<cmd> Telescope live_grep<CR>")
      (mkSetBinding mappings.buffers "<cmd> Telescope buffers<CR>")
      (mkSetBinding mappings.helpTags "<cmd> Telescope help_tags<CR>")
      (mkSetBinding mappings.open "<cmd> Telescope<CR>")

      (mkSetBinding mappings.gitCommits "<cmd> Telescope git_commits<CR>")
      (mkSetBinding mappings.gitBufferCommits "<cmd> Telescope git_bcommits<CR>")
      (mkSetBinding mappings.gitBranches "<cmd> Telescope git_branches<CR>")
      (mkSetBinding mappings.gitStatus "<cmd> Telescope git_status<CR>")
      (mkSetBinding mappings.gitStash "<cmd> Telescope git_stash<CR>")

      (mkIf config.vim.lsp.enable (mkMerge [
        (mkSetBinding mappings.lspDocumentSymbols "<cmd> Telescope lsp_document_symbols<CR>")
        (mkSetBinding mappings.lspWorkspaceSymbols "<cmd> Telescope lsp_workspace_symbols<CR>")

        (mkSetBinding mappings.lspReferences "<cmd> Telescope lsp_references<CR>")
        (mkSetBinding mappings.lspImplementations "<cmd> Telescope lsp_implementations<CR>")
        (mkSetBinding mappings.lspDefinitions "<cmd> Telescope lsp_definitions<CR>")
        (mkSetBinding mappings.lspTypeDefinitions "<cmd> Telescope lsp_type_definitions<CR>")
        (mkSetBinding mappings.diagnostics "<cmd> Telescope diagnostics<CR>")
      ]))

      (
        mkIf config.vim.treesitter.enable
        (mkSetBinding mappings.treesitter "<cmd> Telescope treesitter<CR>")
      )
    ];

    # ...
  };
}
----

[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.
====

[[sec-additional-plugins]]
=== Adding Plugins

To add a new neovim plugin, first add the source url in the inputs section of `flake.nix`

[source,nix]
----
{
    inputs = {
        # ...
        neodev-nvim = {
            url = "github:folke/neodev.nvim";
            flake = false;
        };
    };
}
----

Then add the name of the plugin into the `availablePlugins` variable in `lib/types/plugins.nix`:

[source,nix]
----
# ...
availablePlugins = [
    # ...
    "neodev-nvim"
];
----

You can now reference this plugin using its string name:

[source,nix]
----
config.vim.startPlugins = ["neodev-nvim"];
----