From 9c008088630b547e35acae5e678456d5f0447c24 Mon Sep 17 00:00:00 2001 From: NotAShelf Date: Wed, 1 Feb 2023 22:11:37 +0300 Subject: [PATCH] dev: rebase on a less personalized neovim flake --- .envrc | 1 + .github/workflows/check.yml | 17 + .github/workflows/manual.yml | 34 + .gitignore | 2 + LICENSE | 21 + README.md | 30 + docs/custom-configs.adoc | 42 + docs/default-configs.adoc | 36 + docs/default.nix | 54 + docs/languages.adoc | 71 ++ docs/man-configuration.xml | 42 + docs/man-pages.xml | 13 + docs/manual.xml | 27 + docs/plugins.adoc | 111 ++ docs/release-notes/release-notes.adoc | 9 + docs/release-notes/rl-0.1.adoc | 32 + flake.lock | 1022 +++++++++++++++++ flake.nix | 421 +++++++ modules/autopairs/default.nix | 43 + modules/basic/default.nix | 225 ++++ modules/completion/default.nix | 126 ++ modules/core/default.nix | 225 ++++ modules/default.nix | 72 ++ modules/filetree/default.nix | 10 + modules/filetree/nvimtreelua.nix | 186 +++ modules/git/config.nix | 14 + modules/git/default.nix | 11 + modules/git/git.nix | 69 ++ modules/keys/default.nix | 6 + modules/keys/which-key.nix | 24 + modules/lib/booleans.nix | 9 + modules/lib/dag.nix | 105 ++ modules/lib/default.nix | 5 + modules/lib/stdlib-extended.nix | 13 + modules/lib/types-dag.nix | 68 ++ modules/lib/types-plugin.nix | 55 + modules/lib/types.nix | 7 + modules/lsp/default.nix | 15 + modules/lsp/lightbulb.nix | 29 + modules/lsp/lsp-signature.nix | 25 + modules/lsp/lsp.nix | 405 +++++++ modules/lsp/lspsaga.nix | 54 + modules/lsp/nvim-code-action-menu.nix | 24 + modules/lsp/trouble.nix | 34 + modules/markdown/config.nix | 14 + modules/markdown/default.nix | 11 + modules/markdown/glow.nix | 38 + modules/modules.nix | 35 + modules/snippets/default.nix | 10 + modules/snippets/vsnip.nix | 18 + modules/statusline/config.nix | 65 ++ modules/statusline/default.nix | 11 + modules/statusline/lualine.nix | 205 ++++ .../statusline/supported_lualine_themes.nix | 5 + modules/tabline/default.nix | 10 + modules/tabline/nvim-bufferline.nix | 100 ++ modules/telescope/default.nix | 77 ++ modules/theme/config.nix | 11 + modules/theme/default.nix | 11 + modules/theme/supported_themes.nix | 33 + modules/theme/theme.nix | 40 + modules/tidal/default.nix | 6 + modules/tidal/tidal.nix | 39 + modules/treesitter/context.nix | 31 + modules/treesitter/default.nix | 11 + modules/treesitter/treesitter.nix | 111 ++ modules/visuals/config.nix | 28 + modules/visuals/default.nix | 11 + modules/visuals/visuals.nix | 135 +++ screenshot.png | Bin 0 -> 208671 bytes 70 files changed, 4910 insertions(+) create mode 100644 .envrc create mode 100644 .github/workflows/check.yml create mode 100644 .github/workflows/manual.yml create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md create mode 100644 docs/custom-configs.adoc create mode 100644 docs/default-configs.adoc create mode 100644 docs/default.nix create mode 100644 docs/languages.adoc create mode 100644 docs/man-configuration.xml create mode 100644 docs/man-pages.xml create mode 100644 docs/manual.xml create mode 100644 docs/plugins.adoc create mode 100644 docs/release-notes/release-notes.adoc create mode 100644 docs/release-notes/rl-0.1.adoc create mode 100644 flake.lock create mode 100644 flake.nix create mode 100644 modules/autopairs/default.nix create mode 100644 modules/basic/default.nix create mode 100644 modules/completion/default.nix create mode 100644 modules/core/default.nix create mode 100644 modules/default.nix create mode 100644 modules/filetree/default.nix create mode 100644 modules/filetree/nvimtreelua.nix create mode 100644 modules/git/config.nix create mode 100644 modules/git/default.nix create mode 100644 modules/git/git.nix create mode 100644 modules/keys/default.nix create mode 100644 modules/keys/which-key.nix create mode 100644 modules/lib/booleans.nix create mode 100644 modules/lib/dag.nix create mode 100644 modules/lib/default.nix create mode 100644 modules/lib/stdlib-extended.nix create mode 100644 modules/lib/types-dag.nix create mode 100644 modules/lib/types-plugin.nix create mode 100644 modules/lib/types.nix create mode 100644 modules/lsp/default.nix create mode 100644 modules/lsp/lightbulb.nix create mode 100644 modules/lsp/lsp-signature.nix create mode 100644 modules/lsp/lsp.nix create mode 100644 modules/lsp/lspsaga.nix create mode 100644 modules/lsp/nvim-code-action-menu.nix create mode 100644 modules/lsp/trouble.nix create mode 100644 modules/markdown/config.nix create mode 100644 modules/markdown/default.nix create mode 100644 modules/markdown/glow.nix create mode 100644 modules/modules.nix create mode 100644 modules/snippets/default.nix create mode 100644 modules/snippets/vsnip.nix create mode 100644 modules/statusline/config.nix create mode 100644 modules/statusline/default.nix create mode 100644 modules/statusline/lualine.nix create mode 100644 modules/statusline/supported_lualine_themes.nix create mode 100644 modules/tabline/default.nix create mode 100644 modules/tabline/nvim-bufferline.nix create mode 100644 modules/telescope/default.nix create mode 100644 modules/theme/config.nix create mode 100644 modules/theme/default.nix create mode 100644 modules/theme/supported_themes.nix create mode 100644 modules/theme/theme.nix create mode 100644 modules/tidal/default.nix create mode 100644 modules/tidal/tidal.nix create mode 100644 modules/treesitter/context.nix create mode 100644 modules/treesitter/default.nix create mode 100644 modules/treesitter/treesitter.nix create mode 100644 modules/visuals/config.nix create mode 100644 modules/visuals/default.nix create mode 100644 modules/visuals/visuals.nix create mode 100644 screenshot.png diff --git a/.envrc b/.envrc new file mode 100644 index 0000000..3550a30 --- /dev/null +++ b/.envrc @@ -0,0 +1 @@ +use flake diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml new file mode 100644 index 0000000..4dd7870 --- /dev/null +++ b/.github/workflows/check.yml @@ -0,0 +1,17 @@ +name: "Pull request" +on: + pull_request: + push: + branches: + - main + workflow_dispatch: +jobs: + nix-flake-check: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: cachix/install-nix-action@v18 + with: + extra_nix_config: | + access-tokens = github.com=${{ secrets.GITHUB_TOKEN }} + - run: nix flake check diff --git a/.github/workflows/manual.yml b/.github/workflows/manual.yml new file mode 100644 index 0000000..ff3153c --- /dev/null +++ b/.github/workflows/manual.yml @@ -0,0 +1,34 @@ +name: Github Pages docs +on: + push: + branches: + - main + +# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages +permissions: + contents: write + pages: write + id-token: write + +# Allow one concurrent deployment +concurrency: + group: "pages" + cancel-in-progress: true + +jobs: + publish: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v3 + - name: Install Nix + uses: cachix/install-nix-action@v18 + - name: Build + run: | + nix build '.#docs-html' + cp -r result/share/doc/neovim-flake public + - name: Deploy + uses: peaceiris/actions-gh-pages@v3 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: ./public diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..121ea04 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +result +.config diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..9f3cbc3 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Jordan + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..b249b31 --- /dev/null +++ b/README.md @@ -0,0 +1,30 @@ +# neovim-flake + +A highly configurable nix flake for neovim. + +Come join the Matrix room if you have any questions or need help: [#neovim-flake:matrix.org](https://matrix.to/#/#neovim-flake:matrix.org) + +## Documentation + +See the [neovim-flake Manual](https://jordanisaacs.github.io/neovim-flake/) for documentation, available options, and release notes. + +If you want to dive right into trying neovim-flake you can get a fully featured configuration with `nix` language support by running: + +``` +nix run github:jordanisaacs/neovim-flake +``` + +## Screenshot + +![screenshot](./screenshot.png) + +## Philosophy + +The philosophy behind this flake configuration is to allow for easily configurable and reproducible neovim environments. Enter a directory and have a ready to go neovim configuration that is the same on every machine. Whether you are a developer, writer, or live coder (see tidal cycles below!), quickly craft a config that suits every project's need. Think of it like a distribution of Neovim that takes advantage of pinning vim plugins and third party dependencies (such as tree-sitter grammars, language servers, and more). + +As a result, one should never get a broken config when setting options. If setting multiple options results in a broken neovim, file an issue! Each plugin knows when another plugin which allows for smart configuration of keybindings and automatic setup of things like completion sources and languages. + + +## Credit + +Originally based on Wil Taylor's amazing [neovim-flake](https://github.com/wiltaylor/neovim-flake) diff --git a/docs/custom-configs.adoc b/docs/custom-configs.adoc new file mode 100644 index 0000000..17994f7 --- /dev/null +++ b/docs/custom-configs.adoc @@ -0,0 +1,42 @@ +[[ch-custom-configuration]] +== Custom Configuration + +Custom configuration is done with the `neovimConfiguration` function. It takes in the configuration as a module. The output of the configuration function is an attrset. + +[source,nix] +---- +{ + options = "The options that were available to configure"; + config = "The outputted configuration"; + pkgs = "The package set used to evaluate the module"; + neovim = "The built neovim package"; +} +---- + +The following is an example of a barebones vim configuration with the default theme enabled. + +[source,nix] +---- +{ + inputs.neovim-flake.url = "github:jordanisaacs/neovim-flake"; + + outputs = {nixpkgs, neovim-flake, ...}: let + system = "x86_64-linux"; + pkgs = nixpkgs.legacyPackages.${system}; + configModule = { + # Add any custom options (and feel free to upstream them!) + # options = ... + + config.vim.theme.enable = true; + }; + + customNeovim = neovim-flake.lib.neovimConfiguration { + modules = [configModule]; + inherit pkgs; + }; + in { + packages.${system}.neovim = customNeovim.neovim; + }; +} +---- + diff --git a/docs/default-configs.adoc b/docs/default-configs.adoc new file mode 100644 index 0000000..1a8f0f6 --- /dev/null +++ b/docs/default-configs.adoc @@ -0,0 +1,36 @@ +[[ch-default-configs]] +== Default Configs + +While you can configure neovim-flake yourself using the builder, here are a few default configurations you can use. + +[[sec-default-tidal]] +=== Tidal Cycles + +[source,console] +$ nix run github:jordanisaacs/neovim-flake#tidal file.tidal + +Utilizing https://github.com/tidalcycles/vim-tidal[vim-tidal] and mitchmindtree's fantastic https://github.com/mitchmindtree/tidalcycles.nix[tidalcycles.nix] start playing with tidal cycles in a single command. + +In your tidal file, type a cycle e.g. `d1 $ s "drum"` and then press _ctrl+enter_. Super collider with superdirt, and a modified GHCI with tidal will start up and begin playing. Note, you need jack enabled on your system. If you are using pipewire, its as easy as setting `services.pipewire.jack.enable = true`. + + +[[sec-default-nix]] +=== Nix + +[source,console] +$ nix run github:jordanisaacs/neovim-flake#nix test.nix + +Enables all the of neovim plugins, with language support for specifically Nix. This lets you see what a fully configured neovim setup looks like without downloading a whole bunch of language servers and associated tools. + +[[sec-default-maximal]] +=== Maximal + +[source,console] +$ nix shell github:jordanisaacs/neovim-flake#maximal test.nix + +It is the same fully configured neovim as with the <> config, but with every supported language enabled. + +[NOTE] +==== +Running the maximal config will download *a lot* of packages as it is downloading language servers, formatters, and more. +==== diff --git a/docs/default.nix b/docs/default.nix new file mode 100644 index 0000000..3b04302 --- /dev/null +++ b/docs/default.nix @@ -0,0 +1,54 @@ +{ + pkgs, + lib ? import ../modules/lib/stdlib-extended.nix pkgs.lib, + nmdSrc, +}: let + nmd = import nmdSrc {inherit lib pkgs;}; + scrubbedPkgsModule = { + imports = [ + { + _module.args = { + pkgs = lib.mkForce (nmd.scrubDerivations "pkgs" pkgs); + }; + } + ]; + }; + + nvimModuleDocs = nmd.buildModulesDocs { + modules = + import ../modules/modules.nix { + inherit pkgs lib; + check = false; + } + ++ [scrubbedPkgsModule]; + moduleRootPaths = [./..]; + mkModuleUrl = path: "https://github.com/jordanisaacs/neovim-flake/blob/main/${path}#blob-path"; + channelName = "neovim-flake"; + docBook.id = "neovim-flake-options"; + }; + + docs = nmd.buildDocBookDocs { + pathName = "neovim-flake"; + projectName = "neovim-flake"; + modulesDocs = [nvimModuleDocs]; + documentsDirectory = ./.; + documentType = "book"; + chunkToc = '' + + + + + + + + + + + + ''; + }; +in { + options.json = nvimModuleDocs.json.override {path = "share/doc/neovim-flake/options.json";}; + manPages = docs.manPages; + manual = {inherit (docs) html htmlOpenTool;}; +} diff --git a/docs/languages.adoc b/docs/languages.adoc new file mode 100644 index 0000000..a14e35f --- /dev/null +++ b/docs/languages.adoc @@ -0,0 +1,71 @@ +[[ch-languages]] +== Language Support + +Language specific support combines some combination of language specific plugins, `treesitter` support, `nvim-lspconfig` langauge servers, and `null-ls` integration. This gets you capabilities ranging from autocompletion to formatting to diagnostics. The following languages have support beyond just `treesitter` highlighting. + +[[sec-languages-rust]] +=== Rust + +*LSP Server*: https://github.com/rust-analyzer/rust-analyzer[rust-analyzer] + +*Formatting*: Built into LSP, uses https://github.com/rust-lang/rustfmt[rustfmt] + +*Plugins*: See <> + +[[sec-languages-nix]] +=== Nix + +*LSP Server*: Choice between https://github.com/oxalica/nil[nil] and https://github.com/nix-community/rnix-lsp[rnix-lsp] + +*Formatting*: Choice between https://github.com/kamadorueda/alejandra[alejandra] and https://github.com/nix-community/nixpkgs-fmt[nixpkgs-fmt] + +[[sec-languages-sql]] +=== SQL + +*LSP Server*: https://github.com/lighttiger2505/sqls[sqls] + +*Formatting*: Disabled LSP formatting, instead using https://github.com/sqlfluff/sqlfluff[sqlfluff] + +*Linting*: https://github.com/sqlfluff/sqlfluff[sqlfluff] + +*Plugins*: See <> + +[[sec-languages-clang]] +=== C/C++ + +*LSP Server*: https://github.com/MaskRay/ccls[ccls] + +*Formatting*: Built into language server + +[[sec-languages-typescript]] +=== Typescript + +*LSP Server*: https://github.com/typescript-language-server/typescript-language-server[typescript-language-server] + +*Formatting*: Disabled LSP formatting, instead using https://github.com/prettier/prettier[prettier] + +*Linting*: https://github.com/prettier/prettier[eslint] + +[[sec-languages-python]] +=== Python + +*LSP Server*: https://github.com/microsoft/pyright[pyright] + +*Formatting*: https://github.com/psf/black[black] + +[[sec-languages-zig]] +=== Zig + +*LSP Server*: https://github.com/zigtools/zls[zls] + +*Formatting*: Built into LSP, uses `zig fmt`. + +[[sec-languages-markdown]] +=== Markdown + +*Plugins*: See <> + +[[sec-languages-html]] +=== HTML + +*Plugins*: See <> diff --git a/docs/man-configuration.xml b/docs/man-configuration.xml new file mode 100644 index 0000000..498c0a0 --- /dev/null +++ b/docs/man-configuration.xml @@ -0,0 +1,42 @@ + + + neovim-flake configuration + 5 + neovim-flake + + + + neovim configuration + neovim-flake configuration specification + + + Description + + Custom configuration is done with the neovim-flake.lib.neovimConfiguration function. It takes in the configuration as a module. + + neovim-flake.lib.neovimConfiguration { + inherit pkgs; + modules = [{config = xxx;}]; + }; + + The output of the configuration function is an attrset. + + + { + options = "The options that were available to configure"; + config = "The outputted configuration"; + pkgs = "The package set used to evaluate the module"; + neovim = "The built neovim package"; + } + + + + Options + + You can use the following options in your neovim configuration. + + + + diff --git a/docs/man-pages.xml b/docs/man-pages.xml new file mode 100644 index 0000000..669652e --- /dev/null +++ b/docs/man-pages.xml @@ -0,0 +1,13 @@ + + neovim-flake Reference Pages + + neovim-flake contributors + + 2021–2022 + neovim-flake contributors + + + + diff --git a/docs/manual.xml b/docs/manual.xml new file mode 100644 index 0000000..e961e1e --- /dev/null +++ b/docs/manual.xml @@ -0,0 +1,27 @@ + + + neovim-flake Manual + + + Preface + + If you encounter problems or want to discuss neovim-flake then join the Matrix room + #neovim-flake:matrix.org. + If your problem is caused by a bug in neovim-flake then it should be reported on the + neovim-flake issue tracker. + + + + + + + + Configuration Options + + + + diff --git a/docs/plugins.adoc b/docs/plugins.adoc new file mode 100644 index 0000000..b3a4839 --- /dev/null +++ b/docs/plugins.adoc @@ -0,0 +1,111 @@ +[[ch-plugins]] +== Plugins + +The following are the neovim plugins used within neovim-flake. Some plugins are explicitly enabled by the user, while others are enabled implicitly. + +[[sec-plugins-server]] +=== Language Server + +* https://github.com/neovim/nvim-lspconfig[nvim-lspconfig] common configurations for built-in language server +* https://github.com/jose-elias-alvarez/null-ls.nvim[null-ls.nvim] neovim as a language server to inject LSP diagnostics, code actions, etc. +* https://github.com/glepnir/lspsaga.nvim[lspsaga.nvim] useful UI and tools for lsp +* https://github.com/folke/trouble.nvim[trouble.nvim] pretty list of lsp data +* https://github.com/weilbith/nvim-code-action-menu[nvim-code-action-menu] a better code action menu with diff support +* https://github.com/ray-x/lsp_signature.nvim[lsp-signature] show function signatures as you type +* https://github.com/onsails/lspkind-nvim[lspkind-nvim] for pictograms in lsp (with support for nvim-cmp) + +[[sec-plugins-buffer]] +=== Buffers + +* https://github.com/akinsho/bufferline.nvim[nvim-bufferline-lua] a buffer line with tab integration +* https://github.com/famiu/bufdelete.nvim[bufdelete-nvim] delete buffers without losing window layout + +[[sec-plugins-statuslines]] +=== Statuslines + +* https://github.com/hoob3rt/lualine.nvim[lualine.nvim] statusline written in lua. + +[[sec-plugins-filetrees]] +=== Filetrees + +* https://github.com/kyazdani42/nvim-tree.lua[nvim-tree-lua] a file explorer tree written in lua. Using + +[[sec-plugins-git]] +=== Git + +* https://github.com/lewis6991/gitsigns.nvim[gitsigns.nvim] a variety of git decorations + +[[sec-plugins-treesitter]] +=== Treesitter + +* https://github.com/romgrk/nvim-treesitter-context[nvim-treesitter-context] a context bar using tree-sitter + +[[sec-plugins-visuals]] +=== Visuals + +* https://github.com/lukas-reineke/indent-blankline.nvim[indent-blankline] for indentation guides +* https://github.com/kyazdani42/nvim-web-devicons[nvim-web-devicons] Plugins and colors for icons. Requires patched font + +[[sec-plugins-utilities]] +=== Utilities + +* https://github.com/nvim-telescope/telescope.nvim[telescope] an extendable fuzzy finder of lists. Working ripgrep and fd +* https://github.com/folke/which-key.nvim[which-key] a popup that displays possible keybindings of command being typed + +[[sec-plugins-completions]] +=== Completions + +* https://github.com/hrsh7th/nvim-cmp[nvim-cmp] a completion engine that utilizes sources +** https://github.com/hrsh7th/cmp-buffer[cmp-buffer] a source for buffer words +** https://github.com/hrsh7th/cmp-nvim-lsp[cmp-nvim-lsp] a source for builtin LSP client +** https://github.com/hrsh7th/cmp-vsnip[cmp-vsnip] a source for vim-vsnip autocomplete +** https://github.com/hrsh7th/cmp-path[cmp-path] a source for path autocomplete +** https://github.com/ray-x/cmp-treesitter[cmp-treesitter] treesitter nodes autcomplete + +[[sec-plugins-snippets]] +=== Snippets + +* https://github.com/hrsh7th/vim-vsnip[vim-vsnip] a snippet plugin that supports LSP/VSCode's snippet format + +[[sec-plugins-autopairs]] +=== Autopairs + +* https://github.com/windwp/nvim-autopairs[nvim-autopairs] an autopair plugin for neovim + +[[sec-plugins-themes]] +=== Themes + +* https://github.com/navarasu/onedark.nvim[onedark] a dark colorscheme with multiple options +* https://github.com/folke/tokyonight.nvim[tokyonight-nvim] a neovim theme with multiple color options +* https://github.com/catppuccin/nvim[catppuccin] a pastel theme with 4 color options + +[[sec-plugins-markdown]] +=== Markdown + +* https://github.com/ellisonleao/glow.nvim[glow.nvim] a markdown preview directly in neovim using glow + +[[sec-plugins-rust]] +=== Rust + +* https://github.com/simrat39/rust-tools.nvim[rust-tools] provides tools for rust +* https://github.com/Saecki/crates.nvim[crates.nvim] provides tools for working with `cargo.toml` + +[[sec-plugins-tidalcycles]] +=== Tidal Cycles + +* https://github.com/tidalcycles/vim-tidal[vim-tidal] for tidal cycles integration into vim + +[[sec-plugins-sql]] +=== SQL + +* https://github.com/nanotee/sqls.nvim[sqls.nvim] for useful actions that leverage `sqls` LSP + +[[sec-plugins-html]] +=== HTML + +* https://github.com/windwp/nvim-ts-autotag[nvim-ts-autotag] uses treesitter to autoclose/rename html tags + +[[sec-plugins-dependencies]] +=== Dependencies + +* https://github.com/nvim-lua/plenary.nvim[plenary] which is a dependency of some plugins, installed automatically if needed diff --git a/docs/release-notes/release-notes.adoc b/docs/release-notes/release-notes.adoc new file mode 100644 index 0000000..0bac3ac --- /dev/null +++ b/docs/release-notes/release-notes.adoc @@ -0,0 +1,9 @@ +[[ch-release-notes]] +[appendix] +== Release Notes + +This section lists the release notes for tagged version of neovim-flake and current main. + +:leveloffset: 1 + +include::rl-0.1.adoc[] diff --git a/docs/release-notes/rl-0.1.adoc b/docs/release-notes/rl-0.1.adoc new file mode 100644 index 0000000..0ab1a25 --- /dev/null +++ b/docs/release-notes/rl-0.1.adoc @@ -0,0 +1,32 @@ +[[sec-release-0.1]] +== Release 0.1 + +This is the current master branch and information here is not final. These are changes from the v0.01 tag. + +Special thanks to https://github.com/nix-community/home-manager/[home-manager] for this release. Docs/manual generation, the new module evaluation system, and DAG implementation are from them. + +[[sec-release-0.1-changelog]] +=== Changelog + +https://github.com/jordanisaacs[jordanisaacs]: + +* Removed hare language support (lsp/tree-sitter/etc). `vim.lsp.hare` is no longer defined. If you use hare and would like it added back, please file an issue. + +* <> & <> are now an enum of `string` for options sourced from the flake inputs. Users can still provide vim plugin packages. ++ +If you are contributing and adding a new plugin, add the plugin name to `availablePlugins` in https://github.com/jordanisaacs/neovim-flake/blob/20cec032bd74bc3d20ac17ce36cd84786a04fd3e/modules/lib/types-plugin.nix[types-plugin.nix]. + +* `neovimBuilder` has been removed for configuration. Using an overlay is no longer required. See the manual for the new way to configuration. + +* Treesitter grammars are now configurable with <>. Utilizes the nixpkgs `nvim-treesitter` plugin rather than a custom input in order to take advantage of build support of pinned versions. See https://discourse.nixos.org/t/psa-if-you-are-on-unstable-try-out-nvim-treesitter-withallgrammars/23321?u=snowytrees[discourse] for more information. Packages can be found under the `vimPlugins.nvim-treesitter.builtGrammars` namespace. + +* <> and <> are now of type DAG lines. This allows for ordering of the config. Usage is the same is in home-manager's `home.activation` option. ++ +[source,nix] +---- +vim.luaConfigRC = lib.nvim.dag.entryAnywhere "config here" +---- + +https://github.com/MoritzBoehme[MoritzBoehme]: + +* `catppuccin` theme is now available as a neovim theme <> and lualine theme <>. diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..bbe41c0 --- /dev/null +++ b/flake.lock @@ -0,0 +1,1022 @@ +{ + "nodes": { + "bufdelete-nvim": { + "flake": false, + "locked": { + "lastModified": 1649744299, + "narHash": "sha256-0Igk8iPt4UQQTJRBPzTASzNOqY4zlaMiE1PQiBc/KGc=", + "owner": "famiu", + "repo": "bufdelete.nvim", + "rev": "96454aedf95f52393a28cfcfc76482895de014ee", + "type": "github" + }, + "original": { + "owner": "famiu", + "repo": "bufdelete.nvim", + "type": "github" + } + }, + "catppuccin": { + "flake": false, + "locked": { + "lastModified": 1670687538, + "narHash": "sha256-BRQLNMYbOINJXQkKFz2SpXQoaynzcauWSwNfTChaLdc=", + "owner": "catppuccin", + "repo": "nvim", + "rev": "1d22da687d36c37133b13f2b41658c1c989e77e0", + "type": "github" + }, + "original": { + "owner": "catppuccin", + "repo": "nvim", + "type": "github" + } + }, + "cmp-buffer": { + "flake": false, + "locked": { + "lastModified": 1645413199, + "narHash": "sha256-itDEtoRvZn1mtLhT9WtqKVXoMRe5Qw0/QUf+TFzGNVk=", + "owner": "hrsh7th", + "repo": "cmp-buffer", + "rev": "d66c4c2d376e5be99db68d2362cd94d250987525", + "type": "github" + }, + "original": { + "owner": "hrsh7th", + "repo": "cmp-buffer", + "type": "github" + } + }, + "cmp-nvim-lsp": { + "flake": false, + "locked": { + "lastModified": 1665863036, + "narHash": "sha256-4pppdlVJdn75/faaP3N+o7HgEHxyR1nvkHncnFXGDFA=", + "owner": "hrsh7th", + "repo": "cmp-nvim-lsp", + "rev": "3cf38d9c957e95c397b66f91967758b31be4abe6", + "type": "github" + }, + "original": { + "owner": "hrsh7th", + "repo": "cmp-nvim-lsp", + "type": "github" + } + }, + "cmp-path": { + "flake": false, + "locked": { + "lastModified": 1643823794, + "narHash": "sha256-xYzTpqVKpBBnajqqRRzAXlHAC13VGK1D9mFr3bntepY=", + "owner": "hrsh7th", + "repo": "cmp-path", + "rev": "466b6b8270f7ba89abd59f402c73f63c7331ff6e", + "type": "github" + }, + "original": { + "owner": "hrsh7th", + "repo": "cmp-path", + "type": "github" + } + }, + "cmp-treesitter": { + "flake": false, + "locked": { + "lastModified": 1650880862, + "narHash": "sha256-ZQ2VSrXcUEcy+1lbdvK/pnz3Ppp1lDr38g/z7OvhH8o=", + "owner": "ray-x", + "repo": "cmp-treesitter", + "rev": "c5187c31abd081ecef8b41e5eb476b7340442310", + "type": "github" + }, + "original": { + "owner": "ray-x", + "repo": "cmp-treesitter", + "type": "github" + } + }, + "cmp-vsnip": { + "flake": false, + "locked": { + "lastModified": 1636543683, + "narHash": "sha256-7K3shsiGK7ISFXj9D9MPK7yRqIxeCrbj1IsggToWHO4=", + "owner": "hrsh7th", + "repo": "cmp-vsnip", + "rev": "0abfa1860f5e095a07c477da940cfcb0d273b700", + "type": "github" + }, + "original": { + "owner": "hrsh7th", + "repo": "cmp-vsnip", + "type": "github" + } + }, + "crates-nvim": { + "flake": false, + "locked": { + "lastModified": 1668709750, + "narHash": "sha256-MdmZrZu877P0l4yeJNI6muiYmwVlsvFHJCEBrrhR1Zc=", + "owner": "Saecki", + "repo": "crates.nvim", + "rev": "e11e27864428a68b25e43b833e9081e350a38d96", + "type": "github" + }, + "original": { + "owner": "Saecki", + "repo": "crates.nvim", + "type": "github" + } + }, + "dirt-samples-src": { + "flake": false, + "locked": { + "lastModified": 1588278411, + "narHash": "sha256-h8vQxRym6QzNLOTZU7A43VCHuG0H77l+BFwXnC0L1CE=", + "owner": "tidalcycles", + "repo": "dirt-samples", + "rev": "66d432418c9a7d82cf049d9246adfa62f46df2a6", + "type": "github" + }, + "original": { + "owner": "tidalcycles", + "ref": "master", + "repo": "dirt-samples", + "type": "github" + } + }, + "flake-utils": { + "locked": { + "lastModified": 1667395993, + "narHash": "sha256-nuEHfE/LcWyuSWnS8t12N1wc105Qtau+/OdUAjtQ0rA=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "5aed5285a952e0b949eb3ba02c12fa4fcfef535f", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "gitsigns-nvim": { + "flake": false, + "locked": { + "lastModified": 1666700386, + "narHash": "sha256-pSYXCENFw/z7xppenPehniX8+INkrl+l1LgKKGlfrjQ=", + "owner": "lewis6991", + "repo": "gitsigns.nvim", + "rev": "851cd32caaea84f303c4fdf51d72dfa5fcd795bb", + "type": "github" + }, + "original": { + "owner": "lewis6991", + "repo": "gitsigns.nvim", + "type": "github" + } + }, + "glow-nvim": { + "flake": false, + "locked": { + "lastModified": 1649861698, + "narHash": "sha256-c2HrVLCyekw9b8FxxVMUkBkUitGDX1AyslmM1kZQeCQ=", + "owner": "ellisonleao", + "repo": "glow.nvim", + "rev": "0c76518e440f2ea4dbadd87beec8eea4ce030f17", + "type": "github" + }, + "original": { + "owner": "ellisonleao", + "repo": "glow.nvim", + "type": "github" + } + }, + "indent-blankline": { + "flake": false, + "locked": { + "lastModified": 1649991995, + "narHash": "sha256-pMVby6w7UTR2f1Nxp0ZPlV+KrdXNJ+jEQeQe30Pfs3M=", + "owner": "lukas-reineke", + "repo": "indent-blankline.nvim", + "rev": "045d9582094b27f5ae04d8b635c6da8e97e53f1d", + "type": "github" + }, + "original": { + "owner": "lukas-reineke", + "repo": "indent-blankline.nvim", + "type": "github" + } + }, + "kommentary": { + "flake": false, + "locked": { + "lastModified": 1644888740, + "narHash": "sha256-6YNKYMxaKi02TLa+ebt97XGREnmTjdJAA3bSHFC4yX0=", + "owner": "b3nj5m1n", + "repo": "kommentary", + "rev": "12ecde4ed3ecb39964000a5fd034ae4c1d307388", + "type": "github" + }, + "original": { + "owner": "b3nj5m1n", + "repo": "kommentary", + "type": "github" + } + }, + "lsp-signature": { + "flake": false, + "locked": { + "lastModified": 1651382786, + "narHash": "sha256-owtDWZXZZH6z0m5oHfm/QUjRoWKH4LY6UUOZq8JPckI=", + "owner": "ray-x", + "repo": "lsp_signature.nvim", + "rev": "6d160406f948a810c40304224a1255c8bba5a415", + "type": "github" + }, + "original": { + "owner": "ray-x", + "repo": "lsp_signature.nvim", + "type": "github" + } + }, + "lspkind": { + "flake": false, + "locked": { + "lastModified": 1650298271, + "narHash": "sha256-0103K5lnzWCyuT/qwiBUo5PJ7lUX7fo+zNeEnQClI7A=", + "owner": "onsails", + "repo": "lspkind-nvim", + "rev": "57e5b5dfbe991151b07d272a06e365a77cc3d0e7", + "type": "github" + }, + "original": { + "owner": "onsails", + "repo": "lspkind-nvim", + "type": "github" + } + }, + "lspsaga": { + "flake": false, + "locked": { + "lastModified": 1647219889, + "narHash": "sha256-utb2Rp6RdYWZzVt4W7B7RHOk4Xq1Lli4RcHxZLa8dHc=", + "owner": "tami5", + "repo": "lspsaga.nvim", + "rev": "5309d75bd90ce5b1708331df3af1e971fa83a2b9", + "type": "github" + }, + "original": { + "owner": "tami5", + "repo": "lspsaga.nvim", + "type": "github" + } + }, + "lualine": { + "flake": false, + "locked": { + "lastModified": 1651457787, + "narHash": "sha256-TaRC7Pj9g0nD+kk7VrySulR20GolXtR/roUnA3FM144=", + "owner": "hoob3rt", + "repo": "lualine.nvim", + "rev": "45d07fc026400c211337a7ce1cb90e7b7a397e31", + "type": "github" + }, + "original": { + "owner": "hoob3rt", + "repo": "lualine.nvim", + "type": "github" + } + }, + "naersk": { + "inputs": { + "nixpkgs": [ + "rnix-lsp", + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1655042882, + "narHash": "sha256-9BX8Fuez5YJlN7cdPO63InoyBy7dm3VlJkkmTt6fS1A=", + "owner": "nix-community", + "repo": "naersk", + "rev": "cddffb5aa211f50c4b8750adbec0bbbdfb26bb9f", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "naersk", + "type": "github" + } + }, + "nil": { + "inputs": { + "flake-utils": [ + "flake-utils" + ], + "nixpkgs": [ + "nixpkgs" + ], + "rust-overlay": "rust-overlay" + }, + "locked": { + "lastModified": 1669568240, + "narHash": "sha256-xarHQnV7XCvioDxoAhOI+KsDzPNeWZ3F1OCPJVWS5S4=", + "owner": "oxalica", + "repo": "nil", + "rev": "8f8a5d2cffb1a92b1b4b5001239ca9138675c3f4", + "type": "github" + }, + "original": { + "owner": "oxalica", + "repo": "nil", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1669809720, + "narHash": "sha256-RMT77f6CPOYtLLQ2esj+EJ1BPVWxf4RDidjrSvA5OhI=", + "owner": "nixos", + "repo": "nixpkgs", + "rev": "227de2b3bbec142f912c09d5e8a1b4e778aa54fb", + "type": "github" + }, + "original": { + "owner": "nixos", + "ref": "nixpkgs-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs_2": { + "locked": { + "lastModified": 1656753965, + "narHash": "sha256-BCrB3l0qpJokOnIVc3g2lHiGhnjUi0MoXiw6t1o8H1E=", + "owner": "nixos", + "repo": "nixpkgs", + "rev": "0ea7a8f1b939d74e5df8af9a8f7342097cdf69eb", + "type": "github" + }, + "original": { + "owner": "nixos", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs_3": { + "locked": { + "lastModified": 1655400192, + "narHash": "sha256-49OBVVRgb9H/PSmNT9W61+NRdDbuSJVuDDflwXlaUKU=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "3d7435c638baffaa826b85459df0fff47f12317d", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "nmd": { + "flake": false, + "locked": { + "lastModified": 1666190571, + "narHash": "sha256-Z1hc7M9X6L+H83o9vOprijpzhTfOBjd0KmUTnpHAVjA=", + "owner": "rycee", + "repo": "nmd", + "rev": "b75d312b4f33bd3294cd8ae5c2ca8c6da2afc169", + "type": "gitlab" + }, + "original": { + "owner": "rycee", + "repo": "nmd", + "type": "gitlab" + } + }, + "null-ls": { + "flake": false, + "locked": { + "lastModified": 1669991088, + "narHash": "sha256-DZgonVEzkgayvLY9jkEH1O/Xny6LQktyi8rTNbQlkMk=", + "owner": "jose-elias-alvarez", + "repo": "null-ls.nvim", + "rev": "a67897283fdb0051ad5c72e840e1845e195b979b", + "type": "github" + }, + "original": { + "owner": "jose-elias-alvarez", + "repo": "null-ls.nvim", + "type": "github" + } + }, + "nvim-autopairs": { + "flake": false, + "locked": { + "lastModified": 1651184422, + "narHash": "sha256-voiBJw752//W5oAGQ3wFl4XOUE5PGc/ddchXpWUfgFE=", + "owner": "windwp", + "repo": "nvim-autopairs", + "rev": "63779ea99ed43ab22660ac6ae5b506a40bf41aeb", + "type": "github" + }, + "original": { + "owner": "windwp", + "repo": "nvim-autopairs", + "type": "github" + } + }, + "nvim-bufferline-lua": { + "flake": false, + "locked": { + "lastModified": 1666171880, + "narHash": "sha256-hueIGT7KOhca0kP0M1nUYzBrzMz+DpuZSOt5iyuEa40=", + "owner": "akinsho", + "repo": "nvim-bufferline.lua", + "rev": "e70be6232f632d16d2412b1faf85554285036278", + "type": "github" + }, + "original": { + "owner": "akinsho", + "ref": "v3.0.1", + "repo": "nvim-bufferline.lua", + "type": "github" + } + }, + "nvim-cmp": { + "flake": false, + "locked": { + "lastModified": 1666412792, + "narHash": "sha256-ErdM+ETpkgBtAvA/RedqN+DXvunQ4OYl58HpfZQkz/s=", + "owner": "hrsh7th", + "repo": "nvim-cmp", + "rev": "cdb77665bbf23bd2717d424ddf4bf98057c30bb3", + "type": "github" + }, + "original": { + "owner": "hrsh7th", + "repo": "nvim-cmp", + "type": "github" + } + }, + "nvim-code-action-menu": { + "flake": false, + "locked": { + "lastModified": 1647509555, + "narHash": "sha256-fD9luuZe5mVkJTTtngH0jnwtqljhSZp0OFobBa4uqZI=", + "owner": "weilbith", + "repo": "nvim-code-action-menu", + "rev": "a864a79c8e024d4f5d95915210188c9c3430b160", + "type": "github" + }, + "original": { + "owner": "weilbith", + "repo": "nvim-code-action-menu", + "type": "github" + } + }, + "nvim-compe": { + "flake": false, + "locked": { + "lastModified": 1633188506, + "narHash": "sha256-Y2oqvsuAKM3qjmmtJVD9z34682eCRF25kPL+rxhhg7I=", + "owner": "hrsh7th", + "repo": "nvim-compe", + "rev": "d186d739c54823e0b010feb205c6f97792322c08", + "type": "github" + }, + "original": { + "owner": "hrsh7th", + "repo": "nvim-compe", + "type": "github" + } + }, + "nvim-cursorline": { + "flake": false, + "locked": { + "lastModified": 1650034925, + "narHash": "sha256-Uhw65p1KBjs8KsVOmTzuiu3XKclxBob8AVdWEt30C/8=", + "owner": "yamatsum", + "repo": "nvim-cursorline", + "rev": "804f0023692653b2b2368462d67d2a87056947f9", + "type": "github" + }, + "original": { + "owner": "yamatsum", + "repo": "nvim-cursorline", + "type": "github" + } + }, + "nvim-lightbulb": { + "flake": false, + "locked": { + "lastModified": 1645713830, + "narHash": "sha256-LxGA2LX9CASodJnZYXGZfGPOeW38MW7z54gYQSDmhRE=", + "owner": "kosayoda", + "repo": "nvim-lightbulb", + "rev": "29ca81408119ba809d1f922edc941868af97ee86", + "type": "github" + }, + "original": { + "owner": "kosayoda", + "repo": "nvim-lightbulb", + "type": "github" + } + }, + "nvim-lspconfig": { + "flake": false, + "locked": { + "lastModified": 1669809489, + "narHash": "sha256-fMDR3sYmVu6cDSU8T75S/ppGYXo9+LPqseAd2n0HW6w=", + "owner": "neovim", + "repo": "nvim-lspconfig", + "rev": "d346335af862ede0cece75739d789cfdc46c4454", + "type": "github" + }, + "original": { + "owner": "neovim", + "repo": "nvim-lspconfig", + "type": "github" + } + }, + "nvim-neoclip": { + "flake": false, + "locked": { + "lastModified": 1651221055, + "narHash": "sha256-JO5tOk+Sv0YNjk1pHKfzXian7trFrEh/+iwH2ZxO0Ss=", + "owner": "AckslD", + "repo": "nvim-neoclip.lua", + "rev": "f3ff1645de5d2fd46ac8ffe86e440b7f3ae1fd11", + "type": "github" + }, + "original": { + "owner": "AckslD", + "repo": "nvim-neoclip.lua", + "type": "github" + } + }, + "nvim-tree-lua": { + "flake": false, + "locked": { + "lastModified": 1662860472, + "narHash": "sha256-3aB1xDU0cylHfZ5yzxMQKf07qrJ1pwHEl+QV42k0CpQ=", + "owner": "kyazdani42", + "repo": "nvim-tree.lua", + "rev": "fb8735e96cecf004fbefb086ce85371d003c5129", + "type": "github" + }, + "original": { + "owner": "kyazdani42", + "repo": "nvim-tree.lua", + "type": "github" + } + }, + "nvim-treesitter-context": { + "flake": false, + "locked": { + "lastModified": 1650876005, + "narHash": "sha256-qsfPqC6wpvM/fvGBtfKY7CjdgjGa6JsyOrI7ZWC7jyM=", + "owner": "lewis6991", + "repo": "nvim-treesitter-context", + "rev": "28fd8fea0d056333dcd3cd5abcb1256e3e526417", + "type": "github" + }, + "original": { + "owner": "lewis6991", + "repo": "nvim-treesitter-context", + "type": "github" + } + }, + "nvim-ts-autotag": { + "flake": false, + "locked": { + "lastModified": 1650591994, + "narHash": "sha256-YsqWrmsbp0NhCrnJQo8Df6yQr4f0shS6GdcEQaHdJDE=", + "owner": "windwp", + "repo": "nvim-ts-autotag", + "rev": "044a05c4c51051326900a53ba98fddacd15fea22", + "type": "github" + }, + "original": { + "owner": "windwp", + "repo": "nvim-ts-autotag", + "type": "github" + } + }, + "nvim-web-devicons": { + "flake": false, + "locked": { + "lastModified": 1651408174, + "narHash": "sha256-hYFDefTMcdtoQLhwUaamyGuid69kUo+95P1wjoS2dmo=", + "owner": "kyazdani42", + "repo": "nvim-web-devicons", + "rev": "bdd43421437f2ef037e0dafeaaaa62b31d35ef2f", + "type": "github" + }, + "original": { + "owner": "kyazdani42", + "repo": "nvim-web-devicons", + "type": "github" + } + }, + "onedark": { + "flake": false, + "locked": { + "lastModified": 1666430920, + "narHash": "sha256-pacwQrYPRp2ZFe5ClVYQz2yFxiBmKZdqKQ/I2FdCRYM=", + "owner": "navarasu", + "repo": "onedark.nvim", + "rev": "7aeca4713a922139b5e14c037b5faf34dc41c8d2", + "type": "github" + }, + "original": { + "owner": "navarasu", + "repo": "onedark.nvim", + "type": "github" + } + }, + "plenary-nvim": { + "flake": false, + "locked": { + "lastModified": 1650205145, + "narHash": "sha256-QKVFz95XaJrwkFaWqUHBirMFagellRn2YpNYnBeI/10=", + "owner": "nvim-lua", + "repo": "plenary.nvim", + "rev": "9069d14a120cadb4f6825f76821533f2babcab92", + "type": "github" + }, + "original": { + "owner": "nvim-lua", + "repo": "plenary.nvim", + "type": "github" + } + }, + "registers": { + "flake": false, + "locked": { + "lastModified": 1650186703, + "narHash": "sha256-kqAcuO/tPO0GHBUwpwQYz7QJCyeTE93CbXnVFK7S8qU=", + "owner": "tversteeg", + "repo": "registers.nvim", + "rev": "dfcf0962ce88b52e00dd96dfaabc9997a18f4efe", + "type": "github" + }, + "original": { + "owner": "tversteeg", + "repo": "registers.nvim", + "type": "github" + } + }, + "rnix-lsp": { + "inputs": { + "naersk": "naersk", + "nixpkgs": "nixpkgs_2", + "utils": "utils" + }, + "locked": { + "lastModified": 1669555118, + "narHash": "sha256-F0s0m62S5bHNVWNHLZD6SeHiLrsDx98VQbRjDyIu+qQ=", + "owner": "nix-community", + "repo": "rnix-lsp", + "rev": "95d40673fe43642e2e1144341e86d0036abd95d9", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "rnix-lsp", + "type": "github" + } + }, + "root": { + "inputs": { + "bufdelete-nvim": "bufdelete-nvim", + "catppuccin": "catppuccin", + "cmp-buffer": "cmp-buffer", + "cmp-nvim-lsp": "cmp-nvim-lsp", + "cmp-path": "cmp-path", + "cmp-treesitter": "cmp-treesitter", + "cmp-vsnip": "cmp-vsnip", + "crates-nvim": "crates-nvim", + "flake-utils": "flake-utils", + "gitsigns-nvim": "gitsigns-nvim", + "glow-nvim": "glow-nvim", + "indent-blankline": "indent-blankline", + "kommentary": "kommentary", + "lsp-signature": "lsp-signature", + "lspkind": "lspkind", + "lspsaga": "lspsaga", + "lualine": "lualine", + "nil": "nil", + "nixpkgs": "nixpkgs", + "nmd": "nmd", + "null-ls": "null-ls", + "nvim-autopairs": "nvim-autopairs", + "nvim-bufferline-lua": "nvim-bufferline-lua", + "nvim-cmp": "nvim-cmp", + "nvim-code-action-menu": "nvim-code-action-menu", + "nvim-compe": "nvim-compe", + "nvim-cursorline": "nvim-cursorline", + "nvim-lightbulb": "nvim-lightbulb", + "nvim-lspconfig": "nvim-lspconfig", + "nvim-neoclip": "nvim-neoclip", + "nvim-tree-lua": "nvim-tree-lua", + "nvim-treesitter-context": "nvim-treesitter-context", + "nvim-ts-autotag": "nvim-ts-autotag", + "nvim-web-devicons": "nvim-web-devicons", + "onedark": "onedark", + "plenary-nvim": "plenary-nvim", + "registers": "registers", + "rnix-lsp": "rnix-lsp", + "rust-tools": "rust-tools", + "sqls-nvim": "sqls-nvim", + "telescope": "telescope", + "tidalcycles": "tidalcycles", + "todo-comments": "todo-comments", + "tokyonight": "tokyonight", + "trouble": "trouble", + "vim-vsnip": "vim-vsnip", + "which-key": "which-key" + } + }, + "rust-overlay": { + "inputs": { + "flake-utils": [ + "nil", + "flake-utils" + ], + "nixpkgs": [ + "nil", + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1669170936, + "narHash": "sha256-TKPH4Pzkjw5gAPo9hejs3O4mWJW6V/RSiOj8UuSFRTs=", + "owner": "oxalica", + "repo": "rust-overlay", + "rev": "c90c223c4aef334356029b89c72bb65e26f7efe6", + "type": "github" + }, + "original": { + "owner": "oxalica", + "repo": "rust-overlay", + "type": "github" + } + }, + "rust-tools": { + "flake": false, + "locked": { + "lastModified": 1673136837, + "narHash": "sha256-+/kK6MU2EiSBFbfqQJwLkJICXZpf8oiShbcvsls3V8A=", + "owner": "simrat39", + "repo": "rust-tools.nvim", + "rev": "df584e84393ef255f5b8cbd709677d6a3a5bf42f", + "type": "github" + }, + "original": { + "owner": "simrat39", + "repo": "rust-tools.nvim", + "type": "github" + } + }, + "sqls-nvim": { + "flake": false, + "locked": { + "lastModified": 1651347942, + "narHash": "sha256-ewCkqU5Kj1MQAjRRzOWalLcv/uOLEbtK1jFrySvZ8Y8=", + "owner": "nanotee", + "repo": "sqls.nvim", + "rev": "c52945aacf30247a3b82c586681c414dcd2359bd", + "type": "github" + }, + "original": { + "owner": "nanotee", + "repo": "sqls.nvim", + "type": "github" + } + }, + "superdirt-src": { + "flake": false, + "locked": { + "lastModified": 1611740180, + "narHash": "sha256-GtnqZeMFqFkVhgx2Exu0wY687cHa7mNnVCgjQd6fiIA=", + "owner": "musikinformatik", + "repo": "superdirt", + "rev": "7abb62e89649daa1232b9cbd6427241868abd30e", + "type": "github" + }, + "original": { + "owner": "musikinformatik", + "ref": "master", + "repo": "superdirt", + "type": "github" + } + }, + "telescope": { + "flake": false, + "locked": { + "lastModified": 1651391210, + "narHash": "sha256-aEY/4ra7qyaXQg3H++b0JUbF7G2nI4m5Ow9daZO/duE=", + "owner": "nvim-telescope", + "repo": "telescope.nvim", + "rev": "544c5ee40752ac5552595da86a62abaa39e2dfa9", + "type": "github" + }, + "original": { + "owner": "nvim-telescope", + "repo": "telescope.nvim", + "type": "github" + } + }, + "tidal-src": { + "flake": false, + "locked": { + "lastModified": 1654350756, + "narHash": "sha256-tONM5SYYBca0orTLH1EUOilSC1FCluWrFt8AetUx+YQ=", + "owner": "tidalcycles", + "repo": "tidal", + "rev": "fda9c1ecb3722698935245e5409ef8ccdfca16c8", + "type": "github" + }, + "original": { + "owner": "tidalcycles", + "ref": "main", + "repo": "tidal", + "type": "github" + } + }, + "tidalcycles": { + "inputs": { + "dirt-samples-src": "dirt-samples-src", + "nixpkgs": "nixpkgs_3", + "superdirt-src": "superdirt-src", + "tidal-src": "tidal-src", + "utils": "utils_2", + "vim-tidal-src": "vim-tidal-src", + "vowel-src": "vowel-src" + }, + "locked": { + "lastModified": 1661670241, + "narHash": "sha256-+5C83z+Sd8ugvMshrXqpca4vv3tQ2D4tYEJ3QY6JVsg=", + "owner": "mitchmindtree", + "repo": "tidalcycles.nix", + "rev": "fefe3d586511e1cfaac79bb83ec0b278bb1b6bad", + "type": "github" + }, + "original": { + "owner": "mitchmindtree", + "repo": "tidalcycles.nix", + "type": "github" + } + }, + "todo-comments": { + "flake": false, + "locked": { + "lastModified": 1642601933, + "narHash": "sha256-8uj5TxO9XZlSCB4lVRbKRc1IlUEKcBf/4bDviwuxEgs=", + "owner": "folke", + "repo": "todo-comments.nvim", + "rev": "98b1ebf198836bdc226c0562b9f906584e6c400e", + "type": "github" + }, + "original": { + "owner": "folke", + "repo": "todo-comments.nvim", + "type": "github" + } + }, + "tokyonight": { + "flake": false, + "locked": { + "lastModified": 1666558747, + "narHash": "sha256-hZufHQkI2M0I4mEqV9qs6PkL74aqScKJ3RA5QOulX+0=", + "owner": "folke", + "repo": "tokyonight.nvim", + "rev": "16a294bea92dc8f16ad205c71ce61bf05e79deb3", + "type": "github" + }, + "original": { + "owner": "folke", + "repo": "tokyonight.nvim", + "type": "github" + } + }, + "trouble": { + "flake": false, + "locked": { + "lastModified": 1647585739, + "narHash": "sha256-oUf8YbJ9HmSLN8o2c7CXzCYPu7PwKzvVKNiM9HtHQbQ=", + "owner": "folke", + "repo": "trouble.nvim", + "rev": "691d490cc4eadc430d226fa7d77aaa84e2e0a125", + "type": "github" + }, + "original": { + "owner": "folke", + "repo": "trouble.nvim", + "type": "github" + } + }, + "utils": { + "locked": { + "lastModified": 1656928814, + "narHash": "sha256-RIFfgBuKz6Hp89yRr7+NR5tzIAbn52h8vT6vXkYjZoM=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "7e2a3b3dfd9af950a856d66b0a7d01e3c18aa249", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "utils_2": { + "locked": { + "lastModified": 1653893745, + "narHash": "sha256-0jntwV3Z8//YwuOjzhV2sgJJPt+HY6KhU7VZUL0fKZQ=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "1ed9fb1935d260de5fe1c2f7ee0ebaae17ed2fa1", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "vim-tidal-src": { + "flake": false, + "locked": { + "lastModified": 1664758630, + "narHash": "sha256-fLaBMm6jSLHytIH5IUQtUfi3kaPLdruO3cxv4UcjEO4=", + "owner": "tidalcycles", + "repo": "vim-tidal", + "rev": "f15f14b12176d8f1028d0596b031c3d6e1201c3b", + "type": "github" + }, + "original": { + "owner": "mitchmindtree", + "ref": "mitchmindtree", + "repo": "vim-tidal", + "type": "github" + } + }, + "vim-vsnip": { + "flake": false, + "locked": { + "lastModified": 1650631622, + "narHash": "sha256-USltEc6QGHwMqx7E9wo9qZmq+pm9FLj0CUcKoE7KPLU=", + "owner": "hrsh7th", + "repo": "vim-vsnip", + "rev": "8f199ef690ed26dcbb8973d9a6760d1332449ac9", + "type": "github" + }, + "original": { + "owner": "hrsh7th", + "repo": "vim-vsnip", + "type": "github" + } + }, + "vowel-src": { + "flake": false, + "locked": { + "lastModified": 1641306144, + "narHash": "sha256-zfF6cvAGDNYWYsE8dOIo38b+dIymd17Pexg0HiPFbxM=", + "owner": "supercollider-quarks", + "repo": "vowel", + "rev": "ab59caa870201ecf2604b3efdd2196e21a8b5446", + "type": "github" + }, + "original": { + "owner": "supercollider-quarks", + "ref": "master", + "repo": "vowel", + "type": "github" + } + }, + "which-key": { + "flake": false, + "locked": { + "lastModified": 1666956294, + "narHash": "sha256-IbJP6j+M+POPhX4YbewTJiSoELvDo6y+vF0RREqqm4c=", + "owner": "folke", + "repo": "which-key.nvim", + "rev": "61553aeb3d5ca8c11eea8be6eadf478062982ac9", + "type": "github" + }, + "original": { + "owner": "folke", + "repo": "which-key.nvim", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..1ed33b5 --- /dev/null +++ b/flake.nix @@ -0,0 +1,421 @@ +{ + description = "Jordan's Neovim Configuration"; + inputs = { + nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable"; + flake-utils.url = "github:numtide/flake-utils"; + # For generating documentation website + nmd = { + url = "gitlab:rycee/nmd"; + flake = false; + }; + + # LSP plugins + nvim-lspconfig = { + # url = "github:neovim/nvim-lspconfig?ref=v0.1.3"; + # Use master for nil_ls + url = "github:neovim/nvim-lspconfig"; + flake = false; + }; + lspsaga = { + url = "github:tami5/lspsaga.nvim"; + flake = false; + }; + lspkind = { + url = "github:onsails/lspkind-nvim"; + flake = false; + }; + trouble = { + url = "github:folke/trouble.nvim"; + flake = false; + }; + nvim-treesitter-context = { + url = "github:lewis6991/nvim-treesitter-context"; + flake = false; + }; + nvim-lightbulb = { + url = "github:kosayoda/nvim-lightbulb"; + flake = false; + }; + + nvim-code-action-menu = { + url = "github:weilbith/nvim-code-action-menu"; + flake = false; + }; + lsp-signature = { + url = "github:ray-x/lsp_signature.nvim"; + flake = false; + }; + null-ls = { + url = "github:jose-elias-alvarez/null-ls.nvim"; + flake = false; + }; + sqls-nvim = { + url = "github:nanotee/sqls.nvim"; + flake = false; + }; + rust-tools = { + url = "github:simrat39/rust-tools.nvim"; + flake = false; + }; + + # Copying/Registers + registers = { + url = "github:tversteeg/registers.nvim"; + flake = false; + }; + nvim-neoclip = { + url = "github:AckslD/nvim-neoclip.lua"; + flake = false; + }; + + # Telescope + telescope = { + url = "github:nvim-telescope/telescope.nvim"; + flake = false; + }; + + # Langauge server (use master instead of nixpkgs) + rnix-lsp.url = "github:nix-community/rnix-lsp"; + nil = { + url = "github:oxalica/nil"; + inputs.nixpkgs.follows = "nixpkgs"; + inputs.flake-utils.follows = "flake-utils"; + }; + + # Filetrees + nvim-tree-lua = { + url = "github:kyazdani42/nvim-tree.lua"; + flake = false; + }; + + # Tablines + nvim-bufferline-lua = { + url = "github:akinsho/nvim-bufferline.lua?ref=v3.0.1"; + flake = false; + }; + + # Statuslines + lualine = { + url = "github:hoob3rt/lualine.nvim"; + flake = false; + }; + + # Autocompletes + nvim-compe = { + url = "github:hrsh7th/nvim-compe"; + flake = false; + }; + nvim-cmp = { + url = "github:hrsh7th/nvim-cmp"; + flake = false; + }; + cmp-buffer = { + url = "github:hrsh7th/cmp-buffer"; + flake = false; + }; + cmp-nvim-lsp = { + url = "github:hrsh7th/cmp-nvim-lsp"; + flake = false; + }; + cmp-vsnip = { + url = "github:hrsh7th/cmp-vsnip"; + flake = false; + }; + cmp-path = { + url = "github:hrsh7th/cmp-path"; + flake = false; + }; + cmp-treesitter = { + url = "github:ray-x/cmp-treesitter"; + flake = false; + }; + + # snippets + vim-vsnip = { + url = "github:hrsh7th/vim-vsnip"; + flake = false; + }; + + # Autopairs + nvim-autopairs = { + url = "github:windwp/nvim-autopairs"; + flake = false; + }; + nvim-ts-autotag = { + url = "github:windwp/nvim-ts-autotag"; + flake = false; + }; + + # Commenting + kommentary = { + url = "github:b3nj5m1n/kommentary"; + flake = false; + }; + todo-comments = { + url = "github:folke/todo-comments.nvim"; + flake = false; + }; + + # Buffer tools + bufdelete-nvim = { + url = "github:famiu/bufdelete.nvim"; + flake = false; + }; + + # Themes + tokyonight = { + url = "github:folke/tokyonight.nvim"; + flake = false; + }; + + onedark = { + url = "github:navarasu/onedark.nvim"; + flake = false; + }; + + catppuccin = { + url = "github:catppuccin/nvim"; + flake = false; + }; + + # Rust crates + crates-nvim = { + url = "github:Saecki/crates.nvim"; + flake = false; + }; + + # Visuals + nvim-cursorline = { + url = "github:yamatsum/nvim-cursorline"; + flake = false; + }; + indent-blankline = { + url = "github:lukas-reineke/indent-blankline.nvim"; + flake = false; + }; + nvim-web-devicons = { + url = "github:kyazdani42/nvim-web-devicons"; + flake = false; + }; + gitsigns-nvim = { + url = "github:lewis6991/gitsigns.nvim"; + flake = false; + }; + + # Key binding help + which-key = { + url = "github:folke/which-key.nvim"; + flake = false; + }; + + # Markdown + glow-nvim = { + url = "github:ellisonleao/glow.nvim"; + flake = false; + }; + + # Tidal cycles + tidalcycles = { + url = "github:mitchmindtree/tidalcycles.nix"; + inputs.vim-tidal-src.url = "github:tidalcycles/vim-tidal"; + }; + + # Plenary (required by crates-nvim) + plenary-nvim = { + url = "github:nvim-lua/plenary.nvim"; + flake = false; + }; + }; + + outputs = { + nixpkgs, + flake-utils, + ... + } @ inputs: let + modulesWithInputs = import ./modules {inherit inputs;}; + + neovimConfiguration = { + modules ? [], + pkgs, + lib ? pkgs.lib, + check ? true, + extraSpecialArgs ? {}, + }: + modulesWithInputs { + inherit pkgs lib check extraSpecialArgs; + configuration = {...}: { + imports = modules; + }; + }; + + nvimBin = pkg: "${pkg}/bin/nvim"; + + buildPkg = pkgs: modules: + (neovimConfiguration { + inherit pkgs modules; + }) + .neovim; + + tidalConfig = { + config = { + vim.tidal.enable = true; + }; + }; + + mainConfig = isMaximal: { + config = { + vim.viAlias = false; + vim.vimAlias = true; + vim.lsp = { + enable = true; + formatOnSave = true; + lightbulb.enable = true; + lspsaga.enable = false; + nvimCodeActionMenu.enable = true; + trouble.enable = true; + lspSignature.enable = true; + nix = { + enable = true; + formatter = "alejandra"; + }; + rust.enable = isMaximal; + python = isMaximal; + clang.enable = isMaximal; + sql = isMaximal; + ts = isMaximal; + go = isMaximal; + zig.enable = isMaximal; + }; + vim.visuals = { + enable = true; + nvimWebDevicons.enable = true; + lspkind.enable = true; + indentBlankline = { + enable = true; + fillChar = ""; + eolChar = ""; + showCurrContext = true; + }; + cursorWordline = { + enable = true; + lineTimeout = 0; + }; + }; + vim.statusline.lualine = { + enable = true; + theme = "catppuccin"; + }; + vim.theme = { + enable = true; + name = "catppuccin"; + style = "mocha"; + }; + vim.autopairs.enable = true; + vim.autocomplete = { + enable = true; + type = "nvim-cmp"; + }; + vim.filetree.nvimTreeLua.enable = true; + vim.tabline.nvimBufferline.enable = true; + vim.treesitter = { + enable = true; + context.enable = true; + }; + vim.keys = { + enable = true; + whichKey.enable = true; + }; + vim.telescope = { + enable = true; + }; + vim.markdown = { + enable = true; + glow.enable = true; + }; + vim.git = { + enable = true; + gitsigns.enable = true; + }; + }; + }; + + nixConfig = mainConfig false; + maximalConfig = mainConfig true; + in + { + lib = { + nvim = (import ./modules/lib/stdlib-extended.nix nixpkgs.lib).nvim; + inherit neovimConfiguration; + }; + + overlays.default = final: prev: { + inherit neovimConfiguration; + neovim-nix = buildPkg prev [nixConfig]; + neovim-maximal = buildPkg prev [maximalConfig]; + neovim-tidal = buildPkg prev [tidalConfig]; + }; + } + // (flake-utils.lib.eachDefaultSystem (system: let + pkgs = import nixpkgs { + inherit system; + overlays = [ + inputs.tidalcycles.overlays.default + (final: prev: { + rnix-lsp = inputs.rnix-lsp.defaultPackage.${system}; + nil = inputs.nil.packages.${system}.default; + }) + ]; + }; + + docs = import ./docs { + inherit pkgs; + nmdSrc = inputs.nmd; + }; + + tidalPkg = buildPkg pkgs [tidalConfig]; + nixPkg = buildPkg pkgs [nixConfig]; + maximalPkg = buildPkg pkgs [maximalConfig]; + in { + apps = + rec { + nix = { + type = "app"; + program = nvimBin nixPkg; + }; + maximal = { + type = "app"; + program = nvimBin maximalPkg; + }; + default = nix; + } + // ( + if !(builtins.elem system ["aarch64-darwin" "x86_64-darwin"]) + then { + tidal = { + type = "app"; + program = nvimBin tidalPkg; + }; + } + else {} + ); + + devShells.default = pkgs.mkShell {nativeBuildInputs = [nixPkg];}; + + packages = + { + docs-html = docs.manual.html; + docs-manpages = docs.manPages; + docs-json = docs.options.json; + default = nixPkg; + nix = nixPkg; + maximal = maximalPkg; + } + // ( + if !(builtins.elem system ["aarch64-darwin" "x86_64-darwin"]) + then { + tidal = tidalPkg; + } + else {} + ); + })); +} diff --git a/modules/autopairs/default.nix b/modules/autopairs/default.nix new file mode 100644 index 0000000..3e85003 --- /dev/null +++ b/modules/autopairs/default.nix @@ -0,0 +1,43 @@ +{ + pkgs, + lib, + config, + ... +}: +with lib; +with builtins; let + cfg = config.vim.autopairs; +in { + options.vim = { + autopairs = { + enable = mkOption { + type = types.bool; + default = false; + description = "enable autopairs"; + }; + + type = mkOption { + type = types.enum ["nvim-autopairs"]; + default = "nvim-autopairs"; + description = "Set the autopairs type. Options: nvim-autopairs [nvim-autopairs]"; + }; + }; + }; + + config = + mkIf cfg.enable + { + vim.startPlugins = ["nvim-autopairs"]; + + vim.luaConfigRC.autopairs = nvim.dag.entryAnywhere '' + require("nvim-autopairs").setup{} + ${optionalString (config.vim.autocomplete.type == "nvim-compe") '' + require('nvim-autopairs.completion.compe').setup({ + map_cr = true, + map_complete = true, + auto_select = false, + }) + ''} + ''; + }; +} diff --git a/modules/basic/default.nix b/modules/basic/default.nix new file mode 100644 index 0000000..f020608 --- /dev/null +++ b/modules/basic/default.nix @@ -0,0 +1,225 @@ +{ + pkgs, + lib, + config, + ... +}: +with lib; +with builtins; let + cfg = config.vim; +in { + options.vim = { + colourTerm = mkOption { + type = types.bool; + default = true; + description = "Set terminal up for 256 colours"; + }; + + disableArrows = mkOption { + type = types.bool; + default = false; + description = "Set to prevent arrow keys from moving cursor"; + }; + + hideSearchHighlight = mkOption { + type = types.bool; + default = false; + description = "Hide search highlight so it doesn't stay highlighted"; + }; + + scrollOffset = mkOption { + type = types.int; + default = 8; + description = "Start scrolling this number of lines from the top or bottom of the page."; + }; + + wordWrap = mkOption { + type = types.bool; + default = true; + description = "Enable word wrapping."; + }; + + syntaxHighlighting = mkOption { + type = types.bool; + default = true; + description = "Enable syntax highlighting"; + }; + + mapLeaderSpace = mkOption { + type = types.bool; + default = true; + description = "Map the space key to leader key"; + }; + + useSystemClipboard = mkOption { + type = types.bool; + default = true; + description = "Make use of the clipboard for default yank and paste operations. Don't use * and +"; + }; + + mouseSupport = mkOption { + type = with types; enum ["a" "n" "v" "i" "c"]; + default = "a"; + description = "Set modes for mouse support. a - all, n - normal, v - visual, i - insert, c - command"; + }; + + lineNumberMode = mkOption { + type = with types; enum ["relative" "number" "relNumber" "none"]; + default = "relNumber"; + description = "How line numbers are displayed. none, relative, number, relNumber"; + }; + + preventJunkFiles = mkOption { + type = types.bool; + default = false; + description = "Prevent swapfile, backupfile from being created"; + }; + + tabWidth = mkOption { + type = types.int; + default = 4; + description = "Set the width of tabs"; + }; + + autoIndent = mkOption { + type = types.bool; + default = true; + description = "Enable auto indent"; + }; + + cmdHeight = mkOption { + type = types.int; + default = 1; + description = "Height of the command pane"; + }; + + updateTime = mkOption { + type = types.int; + default = 300; + description = "The number of milliseconds till Cursor Hold event is fired"; + }; + + showSignColumn = mkOption { + type = types.bool; + default = true; + description = "Show the sign column"; + }; + + bell = mkOption { + type = types.enum ["none" "visual" "on"]; + default = "none"; + description = "Set how bells are handled. Options: on, visual or none"; + }; + + mapTimeout = mkOption { + type = types.int; + default = 500; + description = "Timeout in ms that neovim will wait for mapped action to complete"; + }; + + splitBelow = mkOption { + type = types.bool; + default = true; + description = "New splits will open below instead of on top"; + }; + + splitRight = mkOption { + type = types.bool; + default = true; + description = "New splits will open to the right"; + }; + }; + + config = { + vim.startPlugins = ["plenary-nvim"]; + + vim.nmap = mkIf cfg.disableArrows { + "" = ""; + "" = ""; + "" = ""; + "" = ""; + }; + + vim.imap = mkIf cfg.disableArrows { + "" = ""; + "" = ""; + "" = ""; + "" = ""; + }; + + vim.nnoremap = mkIf cfg.mapLeaderSpace {"" = "";}; + + vim.configRC.basic = nvim.dag.entryAfter ["globalsScript"] '' + " Settings that are set for everything + set encoding=utf-8 + set mouse=${cfg.mouseSupport} + set tabstop=${toString cfg.tabWidth} + set shiftwidth=${toString cfg.tabWidth} + set softtabstop=${toString cfg.tabWidth} + set expandtab + set cmdheight=${toString cfg.cmdHeight} + set updatetime=${toString cfg.updateTime} + set shortmess+=c + set tm=${toString cfg.mapTimeout} + set hidden + ${optionalString cfg.splitBelow '' + set splitbelow + ''} + ${optionalString cfg.splitRight '' + set splitright + ''} + ${optionalString cfg.showSignColumn '' + set signcolumn=yes + ''} + ${optionalString cfg.autoIndent '' + set autoindent + ''} + + ${optionalString cfg.preventJunkFiles '' + set noswapfile + set nobackup + set nowritebackup + ''} + ${optionalString (cfg.bell == "none") '' + set noerrorbells + set novisualbell + ''} + ${optionalString (cfg.bell == "on") '' + set novisualbell + ''} + ${optionalString (cfg.bell == "visual") '' + set noerrorbells + ''} + ${optionalString (cfg.lineNumberMode == "relative") '' + set relativenumber + ''} + ${optionalString (cfg.lineNumberMode == "number") '' + set number + ''} + ${optionalString (cfg.lineNumberMode == "relNumber") '' + set number relativenumber + ''} + ${optionalString cfg.useSystemClipboard '' + set clipboard+=unnamedplus + ''} + ${optionalString cfg.mapLeaderSpace '' + let mapleader=" " + let maplocalleader=" " + ''} + ${optionalString cfg.syntaxHighlighting '' + syntax on + ''} + ${optionalString (!cfg.wordWrap) '' + set nowrap + ''} + ${optionalString cfg.hideSearchHighlight '' + set nohlsearch + set incsearch + ''} + ${optionalString cfg.colourTerm '' + set termguicolors + set t_Co=256 + ''} + ''; + }; +} diff --git a/modules/completion/default.nix b/modules/completion/default.nix new file mode 100644 index 0000000..bddc13b --- /dev/null +++ b/modules/completion/default.nix @@ -0,0 +1,126 @@ +{ + pkgs, + lib, + config, + ... +}: +with lib; +with builtins; let + cfg = config.vim.autocomplete; +in { + options.vim = { + autocomplete = { + enable = mkOption { + type = types.bool; + default = false; + description = "enable autocomplete"; + }; + + type = mkOption { + type = types.enum ["nvim-cmp"]; + default = "nvim-cmp"; + description = "Set the autocomplete plugin. Options: [nvim-cmp]"; + }; + }; + }; + + config = mkIf cfg.enable { + vim.startPlugins = [ + "nvim-cmp" + "cmp-buffer" + "cmp-vsnip" + "cmp-path" + "cmp-treesitter" + ]; + + vim.luaConfigRC.completion = mkIf (cfg.type == "nvim-cmp") (nvim.dag.entryAnywhere '' + local has_words_before = function() + local line, col = unpack(vim.api.nvim_win_get_cursor(0)) + return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil + end + + local feedkey = function(key, mode) + vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true) + end + + local cmp = require'cmp' + cmp.setup({ + snippet = { + expand = function(args) + vim.fn["vsnip#anonymous"](args.body) + end, + }, + sources = { + ${optionalString (config.vim.lsp.enable) "{ name = 'nvim_lsp' },"} + ${optionalString (config.vim.lsp.rust.enable) "{ name = 'crates' },"} + { name = 'vsnip' }, + { name = 'treesitter' }, + { name = 'path' }, + { name = 'buffer' }, + }, + mapping = { + [''] = cmp.mapping(cmp.mapping.scroll_docs(-4), { 'i', 'c' }), + [''] = cmp.mapping(cmp.mapping.scroll_docs(4), { 'i', 'c'}), + [''] = cmp.mapping(cmp.mapping.complete(), { 'i', 'c'}), + [''] = cmp.config.disable, + [''] = cmp.mapping({ + i = cmp.mapping.abort(), + c = cmp.mapping.close(), + }), + [''] = cmp.mapping.confirm({ + select = true, + }), + [''] = cmp.mapping(function (fallback) + if cmp.visible() then + cmp.select_next_item() + elseif vim.fn['vsnip#available'](1) == 1 then + feedkey("(vsnip-expand-or-jump)", "") + elseif has_words_before() then + cmp.complete() + else + fallback() + end + end, { 'i', 's' }), + [''] = cmp.mapping(function (fallback) + if cmp.visible() then + cmp.select_prev_item() + elseif vim.fn['vsnip#available'](-1) == 1 then + feedkeys("(vsnip-jump-prev)", "") + end + end, { 'i', 's' }) + }, + completion = { + completeopt = 'menu,menuone,noinsert', + }, + formatting = { + format = function(entry, vim_item) + -- type of kind + vim_item.kind = ${ + optionalString (config.vim.visuals.lspkind.enable) + "require('lspkind').presets.default[vim_item.kind] .. ' ' .." + } vim_item.kind + + -- name for each source + vim_item.menu = ({ + buffer = "[Buffer]", + nvim_lsp = "[LSP]", + vsnip = "[VSnip]", + crates = "[Crates]", + path = "[Path]", + })[entry.source.name] + return vim_item + end, + } + }) + ${optionalString (config.vim.autopairs.enable && config.vim.autopairs.type == "nvim-autopairs") '' + local cmp_autopairs = require('nvim-autopairs.completion.cmp') + cmp.event:on('confirm_done', cmp_autopairs.on_confirm_done({ map_char = { text = ""} })) + ''} + ''); + + vim.snippets.vsnip.enable = + if (cfg.type == "nvim-cmp") + then true + else config.vim.snippets.vsnip.enable; + }; +} diff --git a/modules/core/default.nix b/modules/core/default.nix new file mode 100644 index 0000000..0580cbe --- /dev/null +++ b/modules/core/default.nix @@ -0,0 +1,225 @@ +{ + config, + lib, + pkgs, + ... +}: +with lib; +with builtins; let + cfg = config.vim; + + wrapLuaConfig = luaConfig: '' + lua << EOF + ${luaConfig} + EOF + ''; + + mkMappingOption = it: + mkOption ({ + default = {}; + type = with types; attrsOf (nullOr str); + } + // it); +in { + options.vim = { + viAlias = mkOption { + description = "Enable vi alias"; + type = types.bool; + default = true; + }; + + vimAlias = mkOption { + description = "Enable vim alias"; + type = types.bool; + default = true; + }; + + configRC = mkOption { + description = "vimrc contents"; + type = nvim.types.dagOf types.lines; + default = {}; + }; + + luaConfigRC = mkOption { + description = "vim lua config"; + type = nvim.types.dagOf types.lines; + default = {}; + }; + + builtConfigRC = mkOption { + internal = true; + type = types.lines; + description = "The built config for neovim after resolving the DAG"; + }; + + startPlugins = nvim.types.pluginsOpt { + default = []; + description = "List of plugins to startup."; + }; + + optPlugins = nvim.types.pluginsOpt { + default = []; + description = "List of plugins to optionally load"; + }; + + globals = mkOption { + default = {}; + description = "Set containing global variable values"; + type = types.attrs; + }; + + nnoremap = + mkMappingOption {description = "Defines 'Normal mode' mappings";}; + + inoremap = mkMappingOption { + description = "Defines 'Insert and Replace mode' mappings"; + }; + + vnoremap = mkMappingOption { + description = "Defines 'Visual and Select mode' mappings"; + }; + + xnoremap = + mkMappingOption {description = "Defines 'Visual mode' mappings";}; + + snoremap = + mkMappingOption {description = "Defines 'Select mode' mappings";}; + + cnoremap = + mkMappingOption {description = "Defines 'Command-line mode' mappings";}; + + onoremap = mkMappingOption { + description = "Defines 'Operator pending mode' mappings"; + }; + + tnoremap = + mkMappingOption {description = "Defines 'Terminal mode' mappings";}; + + nmap = mkMappingOption {description = "Defines 'Normal mode' mappings";}; + + imap = mkMappingOption { + description = "Defines 'Insert and Replace mode' mappings"; + }; + + vmap = mkMappingOption { + description = "Defines 'Visual and Select mode' mappings"; + }; + + xmap = mkMappingOption {description = "Defines 'Visual mode' mappings";}; + + smap = mkMappingOption {description = "Defines 'Select mode' mappings";}; + + cmap = + mkMappingOption {description = "Defines 'Command-line mode' mappings";}; + + omap = mkMappingOption { + description = "Defines 'Operator pending mode' mappings"; + }; + + tmap = + mkMappingOption {description = "Defines 'Terminal mode' mappings";}; + }; + + config = let + mkVimBool = val: + if val + then "1" + else "0"; + valToVim = val: + if (isInt val) + then (builtins.toString val) + else + ( + if (isBool val) + then (mkVimBool val) + else (toJSON val) + ); + + filterNonNull = mappings: filterAttrs (name: value: value != null) mappings; + globalsScript = + mapAttrsFlatten (name: value: "let g:${name}=${valToVim value}") + (filterNonNull cfg.globals); + + matchCtrl = it: match "Ctrl-(.)(.*)" it; + mapKeyBinding = it: let + groups = matchCtrl it; + in + if groups == null + then it + else "${head (tail groups)}"; + mapVimBinding = prefix: mappings: + mapAttrsFlatten (name: value: "${prefix} ${mapKeyBinding name} ${value}") + (filterNonNull mappings); + + nmap = mapVimBinding "nmap" config.vim.nmap; + imap = mapVimBinding "imap" config.vim.imap; + vmap = mapVimBinding "vmap" config.vim.vmap; + xmap = mapVimBinding "xmap" config.vim.xmap; + smap = mapVimBinding "smap" config.vim.smap; + cmap = mapVimBinding "cmap" config.vim.cmap; + omap = mapVimBinding "omap" config.vim.omap; + tmap = mapVimBinding "tmap" config.vim.tmap; + + nnoremap = mapVimBinding "nnoremap" config.vim.nnoremap; + inoremap = mapVimBinding "inoremap" config.vim.inoremap; + vnoremap = mapVimBinding "vnoremap" config.vim.vnoremap; + xnoremap = mapVimBinding "xnoremap" config.vim.xnoremap; + snoremap = mapVimBinding "snoremap" config.vim.snoremap; + cnoremap = mapVimBinding "cnoremap" config.vim.cnoremap; + onoremap = mapVimBinding "onoremap" config.vim.onoremap; + tnoremap = mapVimBinding "tnoremap" config.vim.tnoremap; + + resolveDag = { + name, + dag, + mapResult, + }: let + sortedDag = nvim.dag.topoSort dag; + result = + if sortedDag ? result + then mapResult sortedDag.result + else abort ("Dependency cycle in ${name}: " + toJSON sortedConfig); + in + result; + in { + vim = { + configRC = { + globalsScript = nvim.dag.entryAnywhere (concatStringsSep "\n" globalsScript); + + luaScript = let + mkSection = r: '' + -- SECTION: ${r.name} + ${r.data} + ''; + mapResult = r: (wrapLuaConfig (concatStringsSep "\n" (map mkSection r))); + luaConfig = resolveDag { + name = "lua config script"; + dag = cfg.luaConfigRC; + inherit mapResult; + }; + in + nvim.dag.entryAfter ["globalsScript"] luaConfig; + + mappings = let + maps = [nmap imap vmap xmap smap cmap omap tmap nnoremap inoremap vnoremap xnoremap snoremap cnoremap onoremap tnoremap]; + mapConfig = concatStringsSep "\n" (map (v: concatStringsSep "\n" v) maps); + in + nvim.dag.entryAfter ["globalsScript"] mapConfig; + }; + + builtConfigRC = let + mkSection = r: '' + " SECTION: ${r.name} + ${r.data} + ''; + mapResult = r: (concatStringsSep "\n" (map mkSection r)); + vimConfig = resolveDag { + name = "vim config script"; + dag = cfg.configRC; + inherit mapResult; + }; + in + vimConfig; + }; + }; +} diff --git a/modules/default.nix b/modules/default.nix new file mode 100644 index 0000000..5c1e08c --- /dev/null +++ b/modules/default.nix @@ -0,0 +1,72 @@ +{inputs}: { + configuration, + pkgs, + lib ? pkgs.lib, + check ? true, + extraSpecialArgs ? {}, +}: let + inherit (pkgs) neovim-unwrapped wrapNeovim vimPlugins; + inherit (builtins) map filter isString toString getAttr hasAttr attrNames; + inherit (pkgs.vimUtils) buildVimPluginFrom2Nix; + + extendedLib = import ./lib/stdlib-extended.nix lib; + + nvimModules = import ./modules.nix { + inherit check pkgs; + lib = extendedLib; + }; + + module = extendedLib.evalModules { + modules = [configuration] ++ nvimModules; + specialArgs = + { + modulesPath = toString ./.; + } + // extraSpecialArgs; + }; + + buildPlug = name: + buildVimPluginFrom2Nix rec { + pname = name; + version = "master"; + src = assert lib.asserts.assertMsg (name != "nvim-treesitter") "Use buildTreesitterPlug for building nvim-treesitter."; + getAttr pname inputs; + }; + + buildTreesitterPlug = grammars: vimPlugins.nvim-treesitter.withPlugins (_: grammars); + + vimOptions = module.config.vim; + + buildConfigPlugins = plugins: + map + (plug: ( + if (isString plug) + then + ( + if (plug == "nvim-treesitter") + then (buildTreesitterPlug vimOptions.treesitter.grammars) + else (buildPlug plug) + ) + else plug + )) + (filter + (f: f != null) + plugins); + + neovim = wrapNeovim neovim-unwrapped { + viAlias = vimOptions.viAlias; + vimAlias = vimOptions.vimAlias; + configure = { + customRC = vimOptions.builtConfigRC; + + packages.myVimPackage = { + start = buildConfigPlugins vimOptions.startPlugins; + opt = buildConfigPlugins vimOptions.optPlugins; + }; + }; + }; +in { + inherit (module) options config; + inherit (module._module.args) pkgs; + inherit neovim; +} diff --git a/modules/filetree/default.nix b/modules/filetree/default.nix new file mode 100644 index 0000000..18441b5 --- /dev/null +++ b/modules/filetree/default.nix @@ -0,0 +1,10 @@ +{ + pkgs, + lib, + config, + ... +}: { + imports = [ + ./nvimtreelua.nix + ]; +} diff --git a/modules/filetree/nvimtreelua.nix b/modules/filetree/nvimtreelua.nix new file mode 100644 index 0000000..cb6f9bf --- /dev/null +++ b/modules/filetree/nvimtreelua.nix @@ -0,0 +1,186 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.filetree.nvimTreeLua; +in { + options.vim.filetree.nvimTreeLua = { + enable = mkOption { + type = types.bool; + default = false; + description = "Enable nvim-tree-lua"; + }; + + treeSide = mkOption { + default = "left"; + description = "Side the tree will appear on left or right"; + type = types.enum ["left" "right"]; + }; + + treeWidth = mkOption { + default = 25; + description = "Width of the tree in charecters"; + type = types.int; + }; + + hideFiles = mkOption { + default = [".git" "node_modules" ".cache"]; + description = "Files to hide in the file view by default."; + type = with types; listOf str; + }; + + hideIgnoredGitFiles = mkOption { + default = false; + description = "Hide files ignored by git"; + type = types.bool; + }; + + openOnSetup = mkOption { + default = true; + description = "Open when vim is started on a directory"; + type = types.bool; + }; + + closeOnLastWindow = mkOption { + default = true; + description = "Close when tree is last window open"; + type = types.bool; + }; + + ignoreFileTypes = mkOption { + default = []; + description = "Ignore file types"; + type = with types; listOf str; + }; + + closeOnFileOpen = mkOption { + default = false; + description = "Closes the tree when a file is opened."; + type = types.bool; + }; + + resizeOnFileOpen = mkOption { + default = false; + description = "Resizes the tree when opening a file."; + type = types.bool; + }; + + followBufferFile = mkOption { + default = true; + description = "Follow file that is in current buffer on tree"; + type = types.bool; + }; + + indentMarkers = mkOption { + default = true; + description = "Show indent markers"; + type = types.bool; + }; + + hideDotFiles = mkOption { + default = false; + description = "Hide dotfiles"; + type = types.bool; + }; + + openTreeOnNewTab = mkOption { + default = false; + description = "Opens the tree view when opening a new tab"; + type = types.bool; + }; + + disableNetRW = mkOption { + default = false; + description = "Disables netrw and replaces it with tree"; + type = types.bool; + }; + + hijackNetRW = mkOption { + default = true; + description = "Prevents netrw from automatically opening when opening directories"; + type = types.bool; + }; + + trailingSlash = mkOption { + default = true; + description = "Add a trailing slash to all folders"; + type = types.bool; + }; + + groupEmptyFolders = mkOption { + default = true; + description = "Compact empty folders trees into a single item"; + type = types.bool; + }; + + lspDiagnostics = mkOption { + default = true; + description = "Shows lsp diagnostics in the tree"; + type = types.bool; + }; + + systemOpenCmd = mkOption { + default = "${pkgs.xdg-utils}/bin/xdg-open"; + description = "The command used to open a file with the associated default program"; + type = types.str; + }; + }; + + config = mkIf cfg.enable { + vim.startPlugins = ["nvim-tree-lua"]; + + vim.nnoremap = { + "" = ":NvimTreeToggle"; + "tr" = ":NvimTreeRefresh"; + "tg" = ":NvimTreeFindFile"; + "tf" = ":NvimTreeFocus"; + }; + + vim.luaConfigRC.nvimtreelua = nvim.dag.entryAnywhere '' + require'nvim-tree'.setup({ + disable_netrw = ${boolToString cfg.disableNetRW}, + hijack_netrw = ${boolToString cfg.hijackNetRW}, + open_on_tab = ${boolToString cfg.openTreeOnNewTab}, + open_on_setup = ${boolToString cfg.openOnSetup}, + open_on_setup_file = ${boolToString cfg.openOnSetup}, + system_open = { + cmd = ${"'" + cfg.systemOpenCmd + "'"}, + }, + diagnostics = { + enable = ${boolToString cfg.lspDiagnostics}, + }, + view = { + width = ${toString cfg.treeWidth}, + side = ${"'" + cfg.treeSide + "'"}, + }, + renderer = { + indent_markers = { + enable = ${boolToString cfg.indentMarkers}, + }, + add_trailing = ${boolToString cfg.trailingSlash}, + group_empty = ${boolToString cfg.groupEmptyFolders}, + }, + actions = { + open_file = { + quit_on_open = ${boolToString cfg.closeOnFileOpen}, + resize_window = ${boolToString cfg.resizeOnFileOpen}, + }, + }, + git = { + enable = true, + ignore = ${boolToString cfg.hideIgnoredGitFiles}, + }, + filters = { + dotfiles = ${boolToString cfg.hideDotFiles}, + custom = { + ${builtins.concatStringsSep "\n" (builtins.map (s: "\"" + s + "\",") cfg.hideFiles)} + }, + }, + }) + ''; + }; +} diff --git a/modules/git/config.nix b/modules/git/config.nix new file mode 100644 index 0000000..7e12f2f --- /dev/null +++ b/modules/git/config.nix @@ -0,0 +1,14 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; { + config = { + vim.git = { + enable = mkDefault false; + gitsigns.enable = mkDefault false; + }; + }; +} diff --git a/modules/git/default.nix b/modules/git/default.nix new file mode 100644 index 0000000..cb09d72 --- /dev/null +++ b/modules/git/default.nix @@ -0,0 +1,11 @@ +{ + pkgs, + config, + lib, + ... +}: { + imports = [ + ./config.nix + ./git.nix + ]; +} diff --git a/modules/git/git.nix b/modules/git/git.nix new file mode 100644 index 0000000..07060bd --- /dev/null +++ b/modules/git/git.nix @@ -0,0 +1,69 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.git; +in { + options.vim.git = { + enable = mkOption { + type = types.bool; + description = "Enable git plugins"; + }; + + gitsigns.enable = mkOption { + type = types.bool; + description = "Enable git options"; + }; + }; + + config = + mkIf cfg.enable + ( + let + mkVimBool = val: + if val + then "1" + else "0"; + in { + vim.startPlugins = + if (cfg.gitsigns.enable) + then ["gitsigns-nvim"] + else []; + + vim.luaConfigRC.gitsigns = mkIf (cfg.gitsigns.enable) (nvim.dag.entryAnywhere '' + -- GitSigns setup + require('gitsigns').setup { + keymaps = { + noremap = true, + + ['n gn'] = { expr = true, "&diff ? \'\' : 'Gitsigns next_hunk'"}, + ['n gp'] = { expr = true, "&diff ? \'\' : 'Gitsigns prev_hunk'"}, + + ['n gs'] = 'Gitsigns stage_hunk', + ['v gs'] = ':Gitsigns stage_hunk', + ['n gu'] = 'Gitsigns undo_stage_hunk', + ['n gr'] = 'Gitsigns reset_hunk', + ['v gr'] = ':Gitsigns reset_hunk', + ['n gR'] = 'Gitsigns reset_buffer', + ['n gp'] = 'Gitsigns preview_hunk', + ['n gb'] = 'lua require"gitsigns".blame_line{full=true}', + ['n gS'] = 'Gitsigns stage_buffer', + ['n gU'] = 'Gitsigns reset_buffer_index', + ['n gts'] = ':Gitsigns toggle_signs', + ['n gtn'] = ':Gitsigns toggle_numhl', + ['n gtl'] = ':Gitsigns toggle_linehl', + ['n gtw'] = ':Gitsigns toggle_word_diff', + + -- Text objects + ['o ih'] = ':Gitsigns select_hunk', + ['x ih'] = ':Gitsigns select_hunk' + }, + } + ''); + } + ); +} diff --git a/modules/keys/default.nix b/modules/keys/default.nix new file mode 100644 index 0000000..5f5b71a --- /dev/null +++ b/modules/keys/default.nix @@ -0,0 +1,6 @@ +{ + config, + lib, + pkgs, + ... +}: {imports = [./which-key.nix];} diff --git a/modules/keys/which-key.nix b/modules/keys/which-key.nix new file mode 100644 index 0000000..0a8d145 --- /dev/null +++ b/modules/keys/which-key.nix @@ -0,0 +1,24 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.keys; +in { + options.vim.keys = { + enable = mkEnableOption "key binding plugins"; + + whichKey = { + enable = mkEnableOption "which-key menu"; + }; + }; + + config = mkIf (cfg.enable && cfg.whichKey.enable) { + vim.startPlugins = ["which-key"]; + + vim.luaConfigRC.whichkey = nvim.dag.entryAnywhere ''local wk = require("which-key").setup {}''; + }; +} diff --git a/modules/lib/booleans.nix b/modules/lib/booleans.nix new file mode 100644 index 0000000..277dd18 --- /dev/null +++ b/modules/lib/booleans.nix @@ -0,0 +1,9 @@ +# From home-manager: https://github.com/nix-community/home-manager/blob/master/modules/lib/booleans.nix +{lib}: { + # Converts a boolean to a yes/no string. This is used in lots of + # configuration formats. + yesNo = value: + if value + then "yes" + else "no"; +} diff --git a/modules/lib/dag.nix b/modules/lib/dag.nix new file mode 100644 index 0000000..d6cc871 --- /dev/null +++ b/modules/lib/dag.nix @@ -0,0 +1,105 @@ +# From home-manager: https://github.com/nix-community/home-manager/blob/master/modules/lib/dag.nix +# A generalization of Nixpkgs's `strings-with-deps.nix`. +# +# The main differences from the Nixpkgs version are +# +# - not specific to strings, i.e., any payload is OK, +# +# - the addition of the function `entryBefore` indicating a "wanted +# by" relationship. +{lib}: let + inherit (lib) all filterAttrs nvim mapAttrs toposort; +in { + empty = {}; + + isEntry = e: e ? data && e ? after && e ? before; + isDag = dag: + builtins.isAttrs dag && all nvim.dag.isEntry (builtins.attrValues dag); + + # Takes an attribute set containing entries built by entryAnywhere, + # entryAfter, and entryBefore to a topologically sorted list of + # entries. + # + # Internally this function uses the `toposort` function in + # `` and its value is accordingly. + # + # Specifically, the result on success is + # + # { result = [ { name = ?; data = ?; } … ] } + # + # For example + # + # nix-repl> topoSort { + # a = entryAnywhere "1"; + # b = entryAfter [ "a" "c" ] "2"; + # c = entryBefore [ "d" ] "3"; + # d = entryBefore [ "e" ] "4"; + # e = entryAnywhere "5"; + # } == { + # result = [ + # { data = "1"; name = "a"; } + # { data = "3"; name = "c"; } + # { data = "2"; name = "b"; } + # { data = "4"; name = "d"; } + # { data = "5"; name = "e"; } + # ]; + # } + # true + # + # And the result on error is + # + # { + # cycle = [ { after = ?; name = ?; data = ? } … ]; + # loops = [ { after = ?; name = ?; data = ? } … ]; + # } + # + # For example + # + # nix-repl> topoSort { + # a = entryAnywhere "1"; + # b = entryAfter [ "a" "c" ] "2"; + # c = entryAfter [ "d" ] "3"; + # d = entryAfter [ "b" ] "4"; + # e = entryAnywhere "5"; + # } == { + # cycle = [ + # { after = [ "a" "c" ]; data = "2"; name = "b"; } + # { after = [ "d" ]; data = "3"; name = "c"; } + # { after = [ "b" ]; data = "4"; name = "d"; } + # ]; + # loops = [ + # { after = [ "a" "c" ]; data = "2"; name = "b"; } + # ]; + # } + # true + topoSort = dag: let + dagBefore = dag: name: + builtins.attrNames + (filterAttrs (n: v: builtins.elem name v.before) dag); + normalizedDag = + mapAttrs (n: v: { + name = n; + data = v.data; + after = v.after ++ dagBefore dag n; + }) + dag; + before = a: b: builtins.elem a.name b.after; + sorted = toposort before (builtins.attrValues normalizedDag); + in + if sorted ? result + then { + result = map (v: {inherit (v) name data;}) sorted.result; + } + else sorted; + + # Applies a function to each element of the given DAG. + map = f: mapAttrs (n: v: v // {data = f n v.data;}); + + entryBetween = before: after: data: {inherit data before after;}; + + # Create a DAG entry with no particular dependency information. + entryAnywhere = nvim.dag.entryBetween [] []; + + entryAfter = nvim.dag.entryBetween []; + entryBefore = before: nvim.dag.entryBetween before []; +} diff --git a/modules/lib/default.nix b/modules/lib/default.nix new file mode 100644 index 0000000..bb4a271 --- /dev/null +++ b/modules/lib/default.nix @@ -0,0 +1,5 @@ +{lib}: { + dag = import ./dag.nix {inherit lib;}; + booleans = import ./booleans.nix {inherit lib;}; + types = import ./types.nix {inherit lib;}; +} diff --git a/modules/lib/stdlib-extended.nix b/modules/lib/stdlib-extended.nix new file mode 100644 index 0000000..f43bc15 --- /dev/null +++ b/modules/lib/stdlib-extended.nix @@ -0,0 +1,13 @@ +# From home-manager: https://github.com/nix-community/home-manager/blob/master/modules/lib/stdlib-extended.nix +# Just a convenience function that returns the given Nixpkgs standard +# library extended with the HM library. +nixpkgsLib: let + mkNvimLib = import ./.; +in + nixpkgsLib.extend (self: super: { + nvim = mkNvimLib {lib = self;}; + + # For forward compatibility. + literalExpression = super.literalExpression or super.literalExample; + literalDocBook = super.literalDocBook or super.literalExample; + }) diff --git a/modules/lib/types-dag.nix b/modules/lib/types-dag.nix new file mode 100644 index 0000000..439c09d --- /dev/null +++ b/modules/lib/types-dag.nix @@ -0,0 +1,68 @@ +# From home-manager: https://github.com/nix-community/home-manager/blob/master/modules/lib/types-dag.nix +# Used for ordering config text. +{lib}: let + inherit + (lib) + defaultFunctor + nvim + mkIf + mkOrder + mkOption + mkOptionType + types + ; + + dagEntryOf = elemType: let + submoduleType = types.submodule ({name, ...}: { + options = { + data = mkOption {type = elemType;}; + after = mkOption {type = with types; listOf str;}; + before = mkOption {type = with types; listOf str;}; + }; + config = mkIf (elemType.name == "submodule") { + data._module.args.dagName = name; + }; + }); + maybeConvert = def: + if nvim.dag.isEntry def.value + then def.value + else + nvim.dag.entryAnywhere ( + if def ? priority + then mkOrder def.priority def.value + else def.value + ); + in + mkOptionType { + name = "dagEntryOf"; + description = "DAG entry of ${elemType.description}"; + # leave the checking to the submodule type + merge = loc: defs: + submoduleType.merge loc (map (def: { + inherit (def) file; + value = maybeConvert def; + }) + defs); + }; +in rec { + # A directed acyclic graph of some inner type. + # + # Note, if the element type is a submodule then the `name` argument + # will always be set to the string "data" since it picks up the + # internal structure of the DAG values. To give access to the + # "actual" attribute name a new submodule argument is provided with + # the name `dagName`. + dagOf = elemType: let + attrEquivalent = types.attrsOf (dagEntryOf elemType); + in + mkOptionType rec { + name = "dagOf"; + description = "DAG of ${elemType.description}"; + inherit (attrEquivalent) check merge emptyValue; + getSubOptions = prefix: elemType.getSubOptions (prefix ++ [""]); + getSubModules = elemType.getSubModules; + substSubModules = m: dagOf (elemType.substSubModules m); + functor = (defaultFunctor name) // {wrapped = elemType;}; + nestedTypes.elemType = elemType; + }; +} diff --git a/modules/lib/types-plugin.nix b/modules/lib/types-plugin.nix new file mode 100644 index 0000000..3cdca58 --- /dev/null +++ b/modules/lib/types-plugin.nix @@ -0,0 +1,55 @@ +{lib}: +with lib; let + # Plugin must be same as input name + availablePlugins = [ + "nvim-treesitter-context" + "gitsigns-nvim" + "plenary-nvim" + "nvim-lspconfig" + "nvim-treesitter" + "lspsaga" + "lspkind" + "nvim-lightbulb" + "lsp-signature" + "nvim-tree-lua" + "nvim-bufferline-lua" + "lualine" + "nvim-compe" + "nvim-autopairs" + "nvim-ts-autotag" + "nvim-web-devicons" + "tokyonight" + "bufdelete-nvim" + "nvim-cmp" + "cmp-nvim-lsp" + "cmp-buffer" + "cmp-vsnip" + "cmp-path" + "cmp-treesitter" + "crates-nvim" + "vim-vsnip" + "nvim-code-action-menu" + "trouble" + "null-ls" + "which-key" + "indent-blankline" + "nvim-cursorline" + "sqls-nvim" + "glow-nvim" + "telescope" + "rust-tools" + "onedark" + "catppuccin" + ]; + + pluginsType = with types; listOf (nullOr (either (enum availablePlugins) package)); +in { + pluginsOpt = { + description, + default ? [], + }: + mkOption { + inherit description default; + type = pluginsType; + }; +} diff --git a/modules/lib/types.nix b/modules/lib/types.nix new file mode 100644 index 0000000..8625f18 --- /dev/null +++ b/modules/lib/types.nix @@ -0,0 +1,7 @@ +{lib}: let + typesDag = import ./types-dag.nix {inherit lib;}; + typesPlugin = import ./types-plugin.nix {inherit lib;}; +in { + inherit (typesDag) dagOf; + inherit (typesPlugin) pluginsOpt; +} diff --git a/modules/lsp/default.nix b/modules/lsp/default.nix new file mode 100644 index 0000000..00c751d --- /dev/null +++ b/modules/lsp/default.nix @@ -0,0 +1,15 @@ +{ + config, + lib, + pkgs, + ... +}: { + imports = [ + ./lsp.nix + ./lspsaga.nix + ./nvim-code-action-menu.nix + ./trouble.nix + ./lsp-signature.nix + ./lightbulb.nix + ]; +} diff --git a/modules/lsp/lightbulb.nix b/modules/lsp/lightbulb.nix new file mode 100644 index 0000000..cbd7622 --- /dev/null +++ b/modules/lsp/lightbulb.nix @@ -0,0 +1,29 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.lsp; +in { + options.vim.lsp = { + lightbulb = { + enable = mkEnableOption "lightbulb for code actions. Requires emoji font"; + }; + }; + + config = mkIf (cfg.enable && cfg.lightbulb.enable) { + vim.startPlugins = ["nvim-lightbulb"]; + + vim.configRC.lightbulb = nvim.dag.entryAnywhere '' + autocmd CursorHold,CursorHoldI * lua require'nvim-lightbulb'.update_lightbulb() + ''; + + vim.luaConfigRC.lightbulb = nvim.dag.entryAnywhere '' + -- Enable trouble diagnostics viewer + require'nvim-lightbulb'.setup() + ''; + }; +} diff --git a/modules/lsp/lsp-signature.nix b/modules/lsp/lsp-signature.nix new file mode 100644 index 0000000..1d77040 --- /dev/null +++ b/modules/lsp/lsp-signature.nix @@ -0,0 +1,25 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.lsp; +in { + options.vim.lsp = { + lspSignature = { + enable = mkEnableOption "lsp signature viewer"; + }; + }; + + config = mkIf (cfg.enable && cfg.lspSignature.enable) { + vim.startPlugins = ["lsp-signature"]; + + vim.luaConfigRC.lsp-signature = nvim.dag.entryAnywhere '' + -- Enable lsp signature viewer + require("lsp_signature").setup() + ''; + }; +} diff --git a/modules/lsp/lsp.nix b/modules/lsp/lsp.nix new file mode 100644 index 0000000..5435cc5 --- /dev/null +++ b/modules/lsp/lsp.nix @@ -0,0 +1,405 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.lsp; +in { + options.vim.lsp = { + enable = mkEnableOption "neovim lsp support"; + formatOnSave = mkEnableOption "Format on save"; + nix = { + enable = mkEnableOption "Nix LSP"; + server = mkOption { + type = with types; enum ["rnix" "nil"]; + default = "nil"; + description = "Which LSP to use"; + }; + + pkg = mkOption { + type = types.package; + default = + if (cfg.nix.server == "rnix") + then pkgs.rnix-lsp + else pkgs.nil; + description = "The LSP package to use"; + }; + + formatter = mkOption { + type = with types; enum ["nixpkgs-fmt" "alejandra"]; + default = "alejandra"; + description = "Which nix formatter to use"; + }; + }; + rust = { + enable = mkEnableOption "Rust LSP"; + rustAnalyzerOpts = mkOption { + type = types.str; + default = '' + ["rust-analyzer"] = { + experimental = { + procAttrMacros = true, + }, + }, + ''; + description = "options to pass to rust analyzer"; + }; + }; + python = mkEnableOption "Python LSP"; + clang = { + enable = mkEnableOption "C language LSP"; + c_header = mkEnableOption "C syntax header files"; + cclsOpts = mkOption { + type = types.str; + default = ""; + }; + }; + sql = mkEnableOption "SQL Language LSP"; + go = mkEnableOption "Go language LSP"; + ts = mkEnableOption "TS language LSP"; + zig.enable = mkEnableOption "Zig language LSP"; + }; + + config = mkIf cfg.enable ( + let + writeIf = cond: msg: + if cond + then msg + else ""; + in { + vim.startPlugins = + [ + "nvim-lspconfig" + "null-ls" + ( + if (config.vim.autocomplete.enable && (config.vim.autocomplete.type == "nvim-cmp")) + then "cmp-nvim-lsp" + else null + ) + ( + if cfg.sql + then "sqls-nvim" + else null + ) + ] + ++ ( + if cfg.rust.enable + then [ + "crates-nvim" + "rust-tools" + ] + else [] + ); + + vim.configRC.lsp = nvim.dag.entryAnywhere '' + ${ + if cfg.nix.enable + then '' + autocmd filetype nix setlocal tabstop=2 shiftwidth=2 softtabstop=2 + '' + else "" + } + + ${ + if cfg.clang.c_header + then '' + " c syntax for header (otherwise breaks treesitter highlighting) + " https://www.reddit.com/r/neovim/comments/orfpcd/question_does_the_c_parser_from_nvimtreesitter/ + let g:c_syntax_for_h = 1 + '' + else "" + } + ''; + vim.luaConfigRC.lsp = nvim.dag.entryAnywhere '' + + local attach_keymaps = function(client, bufnr) + local opts = { noremap=true, silent=true } + + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'lgD', 'lua vim.lsp.buf.declaration()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'lgd', 'lua vim.lsp.buf.definition()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'lgt', 'lua vim.lsp.buf.type_definition()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'lgn', 'lua vim.diagnostic.goto_next()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'lgp', 'lua vim.diagnostic.goto_prev()', opts) + + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'lwa', 'lua vim.lsp.buf.add_workspace_folder()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'lwr', 'lua vim.lsp.buf.remove_workspace_folder()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'lwl', 'lua print(vim.inspect(vim.lsp.buf.list_workspace_folders()))', opts) + + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'lh', 'lua vim.lsp.buf.hover()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'ls', 'lua vim.lsp.buf.signature_help()', opts) + vim.api.nvim_buf_set_keymap(bufnr, 'n', 'ln', 'lua vim.lsp.buf.rename()', opts) + end + + local null_ls = require("null-ls") + local null_helpers = require("null-ls.helpers") + local null_methods = require("null-ls.methods") + + local ls_sources = { + ${writeIf cfg.python + '' + null_ls.builtins.formatting.black.with({ + command = "${pkgs.black}/bin/black", + }), + ''} + + -- Commented out for now + --${writeIf (config.vim.git.enable && config.vim.git.gitsigns.enable) '' + -- null_ls.builtins.code_actions.gitsigns, + --''} + + ${writeIf cfg.sql + '' + null_helpers.make_builtin({ + method = null_methods.internal.FORMATTING, + filetypes = { "sql" }, + generator_opts = { + to_stdin = true, + ignore_stderr = true, + suppress_errors = true, + command = "${pkgs.sqlfluff}/bin/sqlfluff", + args = { + "fix", + "-", + }, + }, + factory = null_helpers.formatter_factory, + }), + + null_ls.builtins.diagnostics.sqlfluff.with({ + command = "${pkgs.sqlfluff}/bin/sqlfluff", + extra_args = {"--dialect", "postgres"} + }), + ''} + + ${writeIf + (cfg.nix.enable + && cfg.nix.server == "rnix" + && cfg.nix.formatter == "alejandra") + '' + null_ls.builtins.formatting.alejandra.with({ + command = "${pkgs.alejandra}/bin/alejandra" + }), + ''} + + ${writeIf cfg.ts + '' + null_ls.builtins.diagnostics.eslint, + null_ls.builtins.formatting.prettier, + ''} + } + + vim.g.formatsave = ${ + if cfg.formatOnSave + then "true" + else "false" + }; + + -- Enable formatting + format_callback = function(client, bufnr) + vim.api.nvim_create_autocmd("BufWritePre", { + group = augroup, + buffer = bufnr, + callback = function() + if vim.g.formatsave then + local params = require'vim.lsp.util'.make_formatting_params({}) + client.request('textDocument/formatting', params, nil, bufnr) + end + end + }) + end + + default_on_attach = function(client, bufnr) + attach_keymaps(client, bufnr) + format_callback(client, bufnr) + end + + -- Enable null-ls + require('null-ls').setup({ + diagnostics_format = "[#{m}] #{s} (#{c})", + debounce = 250, + default_timeout = 5000, + sources = ls_sources, + on_attach=default_on_attach + }) + + -- Enable lspconfig + local lspconfig = require('lspconfig') + + local capabilities = vim.lsp.protocol.make_client_capabilities() + ${ + let + cfg = config.vim.autocomplete; + in + writeIf cfg.enable ( + if cfg.type == "nvim-cmp" + then '' + capabilities = require('cmp_nvim_lsp').default_capabilities() + '' + else "" + ) + } + + ${writeIf cfg.rust.enable '' + -- Rust config + local rt = require('rust-tools') + + rust_on_attach = function(client, bufnr) + default_on_attach(client, bufnr) + local opts = { noremap=true, silent=true, buffer = bufnr } + vim.keymap.set("n", "ris", rt.inlay_hints.set, opts) + vim.keymap.set("n", "riu", rt.inlay_hints.unset, opts) + vim.keymap.set("n", "rr", rt.runnables.runnables, opts) + vim.keymap.set("n", "rp", rt.parent_module.parent_module, opts) + vim.keymap.set("n", "rm", rt.expand_macro.expand_macro, opts) + vim.keymap.set("n", "rc", rt.open_cargo_toml.open_cargo_toml, opts) + vim.keymap.set("n", "rg", function() rt.crate_graph.view_crate_graph("x11", nil) end, opts) + end + + local rustopts = { + tools = { + autoSetHints = true, + hover_with_actions = false, + inlay_hints = { + only_current_line = false, + } + }, + server = { + capabilities = capabilities, + on_attach = rust_on_attach, + cmd = {"${pkgs.rust-analyzer}/bin/rust-analyzer"}, + settings = { + ${cfg.rust.rustAnalyzerOpts} + } + } + } + + require('crates').setup { + null_ls = { + enabled = true, + name = "crates.nvim", + } + } + rt.setup(rustopts) + ''} + + ${optionalString cfg.zig.enable '' + -- Zig config + lspconfig.zls.setup { + capabilities = capabilities, + on_attach=default_on_attach, + cmd = {"${pkgs.zls}/bin/zls"}, + settings = { + ["zls"] = { + zig_exe_path = "${pkgs.zig}/bin/zig", + zig_lib_path = "${pkgs.zig}/lib/zig", + } + } + } + ''} + + ${writeIf cfg.python '' + -- Python config + lspconfig.pyright.setup{ + capabilities = capabilities; + on_attach=default_on_attach; + cmd = {"${pkgs.nodePackages.pyright}/bin/pyright-langserver", "--stdio"} + } + ''} + + ${writeIf cfg.nix.enable ( + (writeIf (cfg.nix.server == "rnix") '' + -- Nix (rnix) config + lspconfig.rnix.setup{ + capabilities = capabilities, + ${writeIf (cfg.nix.formatter == "alejandra") + '' + on_attach = function(client, bufnr) + attach_keymaps(client, bufnr) + end, + ''} + ${writeIf (cfg.nix.formatter == "nixpkgs-fmt") + '' + on_attach = default_on_attach, + ''} + cmd = {"${cfg.nix.pkg}/bin/rnix-lsp"}, + } + '') + + (writeIf (cfg.nix.server == "nil") '' + -- Nix (nil) config + lspconfig.nil_ls.setup{ + capabilities = capabilities, + on_attach=default_on_attach, + cmd = {"${cfg.nix.pkg}/bin/nil"}, + settings = { + ["nil"] = { + ${writeIf (cfg.nix.formatter == "alejandra") + '' + formatting = { + command = {"${pkgs.alejandra}/bin/alejandra", "--quiet"}, + }, + ''} + ${writeIf (cfg.nix.formatter == "nixpkgs-fmt") + '' + formatting = { + command = {"${pkgs.nixpkgs-fmt}/bin/nixpkgs-fmt"}, + }, + ''} + }, + }; + } + '') + )} + + + ${writeIf cfg.clang.enable '' + -- CCLS (clang) config + lspconfig.ccls.setup{ + capabilities = capabilities; + on_attach=default_on_attach; + cmd = {"${pkgs.ccls}/bin/ccls"}; + ${ + if cfg.clang.cclsOpts == "" + then "" + else "init_options = ${cfg.clang.cclsOpts}" + } + } + ''} + + ${writeIf cfg.sql '' + -- SQLS config + lspconfig.sqls.setup { + on_attach = function(client) + client.server_capabilities.execute_command = true + on_attach_keymaps(client, bufnr) + require'sqls'.setup{} + end, + cmd = {"${pkgs.sqls}/bin/sqls", "-config", string.format("%s/config.yml", vim.fn.getcwd()) } + } + ''} + + ${writeIf cfg.go '' + -- Go config + lspconfig.gopls.setup { + capabilities = capabilities; + on_attach = default_on_attach; + cmd = {"${pkgs.gopls}/bin/gopls", "serve"}, + } + ''} + + ${writeIf cfg.ts '' + -- TS config + lspconfig.tsserver.setup { + capabilities = capabilities; + on_attach = function(client, bufnr) + attach_keymaps(client, bufnr) + end, + cmd = { "${pkgs.nodePackages.typescript-language-server}/bin/typescript-language-server", "--stdio" } + } + ''} + ''; + } + ); +} diff --git a/modules/lsp/lspsaga.nix b/modules/lsp/lspsaga.nix new file mode 100644 index 0000000..d244594 --- /dev/null +++ b/modules/lsp/lspsaga.nix @@ -0,0 +1,54 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.lsp; +in { + options.vim.lsp = {lspsaga = {enable = mkEnableOption "LSP Saga";};}; + + config = mkIf (cfg.enable && cfg.lspsaga.enable) { + vim.startPlugins = ["lspsaga"]; + + vim.vnoremap = { + "ca" = ":lua require('lspsaga.codeaction').range_code_action()"; + }; + + vim.nnoremap = + { + "lf" = "lua require'lspsaga.provider'.lsp_finder()"; + "lh" = "lua require('lspsaga.hover').render_hover_doc()"; + "" = "lua require('lspsaga.action').smart_scroll_with_saga(1)"; + "" = "lua require('lspsaga.action').smart_scroll_with_saga(-1)"; + "lr" = "lua require'lspsaga.rename'.rename()"; + "ld" = "lua require'lspsaga.provider'.preview_definition()"; + "ll" = "lua require'lspsaga.diagnostic'.show_line_diagnostics()"; + "lc" = "lua require'lspsaga.diagnostic'.show_cursor_diagnostics()"; + "lp" = "lua require'lspsaga.diagnostic'.lsp_jump_diagnostic_prev()"; + "ln" = "lua require'lspsaga.diagnostic'.lsp_jump_diagnostic_next()"; + } + // ( + if (!cfg.nvimCodeActionMenu.enable) + then { + "ca" = "lua require('lspsaga.codeaction').code_action()"; + } + else {} + ) + // ( + if (!cfg.lspSignature.enable) + then { + "ls" = "lua require('lspsaga.signaturehelp').signature_help()"; + } + else {} + ); + + vim.luaConfigRC.lspsage = nvim.dag.entryAnywhere '' + -- Enable lspsaga + local saga = require 'lspsaga' + saga.init_lsp_saga() + ''; + }; +} diff --git a/modules/lsp/nvim-code-action-menu.nix b/modules/lsp/nvim-code-action-menu.nix new file mode 100644 index 0000000..ac8b8d6 --- /dev/null +++ b/modules/lsp/nvim-code-action-menu.nix @@ -0,0 +1,24 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.lsp; +in { + options.vim.lsp = { + nvimCodeActionMenu = { + enable = mkEnableOption "nvim code action menu"; + }; + }; + + config = mkIf (cfg.enable && cfg.nvimCodeActionMenu.enable) { + vim.startPlugins = ["nvim-code-action-menu"]; + + vim.nnoremap = { + "ca" = ":CodeActionMenu"; + }; + }; +} diff --git a/modules/lsp/trouble.nix b/modules/lsp/trouble.nix new file mode 100644 index 0000000..a96ce5d --- /dev/null +++ b/modules/lsp/trouble.nix @@ -0,0 +1,34 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.lsp; +in { + options.vim.lsp = { + trouble = { + enable = mkEnableOption "trouble diagnostics viewer"; + }; + }; + + config = mkIf (cfg.enable && cfg.trouble.enable) { + vim.startPlugins = ["trouble"]; + + vim.nnoremap = { + "xx" = "TroubleToggle"; + "lwd" = "TroubleToggle workspace_diagnostics"; + "ld" = "TroubleToggle document_diagnostics"; + "lr" = "TroubleToggle lsp_references"; + "xq" = "TroubleToggle quickfix"; + "xl" = "TroubleToggle loclist"; + }; + + vim.luaConfigRC.trouble = nvim.dag.entryAnywhere '' + -- Enable trouble diagnostics viewer + require("trouble").setup {} + ''; + }; +} diff --git a/modules/markdown/config.nix b/modules/markdown/config.nix new file mode 100644 index 0000000..72b0007 --- /dev/null +++ b/modules/markdown/config.nix @@ -0,0 +1,14 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; { + config = { + vim.markdown = { + enable = mkDefault false; + glow.enable = mkDefault false; + }; + }; +} diff --git a/modules/markdown/default.nix b/modules/markdown/default.nix new file mode 100644 index 0000000..b039f6e --- /dev/null +++ b/modules/markdown/default.nix @@ -0,0 +1,11 @@ +{ + config, + lib, + pkgs, + ... +}: { + imports = [ + ./config.nix + ./glow.nix + ]; +} diff --git a/modules/markdown/glow.nix b/modules/markdown/glow.nix new file mode 100644 index 0000000..e658446 --- /dev/null +++ b/modules/markdown/glow.nix @@ -0,0 +1,38 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.markdown; +in { + options.vim.markdown = { + enable = mkEnableOption "markdown tools and plugins"; + + glow.enable = mkOption { + type = types.bool; + default = true; + description = "Enable markdown preview in neovim with glow"; + }; + }; + + config = mkIf (cfg.enable) { + vim.startPlugins = [ + ( + if cfg.glow.enable + then "glow-nvim" + else null + ) + ]; + + vim.globals = mkIf (cfg.glow.enable) { + "glow_binary_path" = "${pkgs.glow}/bin"; + }; + + vim.configRC.glow = mkIf (cfg.glow.enable) (nvim.dag.entryAnywhere '' + autocmd FileType markdown noremap p :Glow + ''); + }; +} diff --git a/modules/modules.nix b/modules/modules.nix new file mode 100644 index 0000000..ab682b6 --- /dev/null +++ b/modules/modules.nix @@ -0,0 +1,35 @@ +{ + pkgs, + lib, + check ? true, +}: let + modules = [ + ./completion + ./theme + ./core + ./basic + ./statusline + ./tabline + ./filetree + ./visuals + ./lsp + ./treesitter + ./tidal + ./autopairs + ./snippets + ./keys + ./markdown + ./telescope + ./git + ]; + + pkgsModule = {config, ...}: { + config = { + _module.args.baseModules = modules; + _module.args.pkgsPath = lib.mkDefault pkgs.path; + _module.args.pkgs = lib.mkDefault pkgs; + _module.check = check; + }; + }; +in + modules ++ [pkgsModule] diff --git a/modules/snippets/default.nix b/modules/snippets/default.nix new file mode 100644 index 0000000..dd88e3c --- /dev/null +++ b/modules/snippets/default.nix @@ -0,0 +1,10 @@ +{ + pkgs, + lib, + config, + ... +}: { + imports = [ + ./vsnip.nix + ]; +} diff --git a/modules/snippets/vsnip.nix b/modules/snippets/vsnip.nix new file mode 100644 index 0000000..671671c --- /dev/null +++ b/modules/snippets/vsnip.nix @@ -0,0 +1,18 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.snippets.vsnip; +in { + options.vim.snippets.vsnip = { + enable = mkEnableOption "Enable vim-vsnip"; + }; + + config = mkIf cfg.enable { + vim.startPlugins = ["vim-vsnip"]; + }; +} diff --git a/modules/statusline/config.nix b/modules/statusline/config.nix new file mode 100644 index 0000000..6503543 --- /dev/null +++ b/modules/statusline/config.nix @@ -0,0 +1,65 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; { + config = { + vim.statusline.lualine = { + enable = mkDefault false; + + icons = mkDefault true; + theme = mkDefault "auto"; + sectionSeparator = { + left = mkDefault ""; + right = mkDefault ""; + }; + + componentSeparator = { + left = mkDefault "⏽"; + right = mkDefault "⏽"; + }; + + activeSection = { + a = mkDefault "{'mode'}"; + b = '' + { + { + "branch", + separator = '', + }, + "diff", + } + ''; + c = mkDefault "{'filename'}"; + x = mkDefault '' + { + { + "diagnostics", + sources = {'nvim_lsp'}, + separator = '', + symbols = {error = '', warn = '', info = '', hint = ''}, + }, + { + "filetype", + }, + "fileformat", + "encoding", + } + ''; + y = mkDefault "{'progress'}"; + z = mkDefault "{'location'}"; + }; + + inactiveSection = { + a = mkDefault "{}"; + b = mkDefault "{}"; + c = mkDefault "{'filename'}"; + x = mkDefault "{'location'}"; + y = mkDefault "{}"; + z = mkDefault "{}"; + }; + }; + }; +} diff --git a/modules/statusline/default.nix b/modules/statusline/default.nix new file mode 100644 index 0000000..5d638c9 --- /dev/null +++ b/modules/statusline/default.nix @@ -0,0 +1,11 @@ +{ + pkgs, + config, + lib, + ... +}: { + imports = [ + ./lualine.nix + ./config.nix + ]; +} diff --git a/modules/statusline/lualine.nix b/modules/statusline/lualine.nix new file mode 100644 index 0000000..aba8466 --- /dev/null +++ b/modules/statusline/lualine.nix @@ -0,0 +1,205 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.statusline.lualine; + supported_themes = import ./supported_lualine_themes.nix; +in { + options.vim.statusline.lualine = { + enable = mkOption { + type = types.bool; + description = "Enable lualine"; + }; + + icons = mkOption { + type = types.bool; + description = "Enable icons for lualine"; + }; + + theme = mkOption { + type = types.enum ( + [ + "auto" + "16color" + "gruvbox" + "ayu_dark" + "ayu_light" + "ayu_mirage" + "codedark" + "dracula" + "everforest" + "gruvbox" + "gruvbox_light" + "gruvbox_material" + "horizon" + "iceberg_dark" + "iceberg_light" + "jellybeans" + "material" + "modus_vivendi" + "molokai" + "nightfly" + "nord" + "oceanicnext" + "onelight" + "palenight" + "papercolor_dark" + "papercolor_light" + "powerline" + "seoul256" + "solarized_dark" + "tomorrow" + "wombat" + ] + ++ ( + if elem config.vim.theme.name supported_themes + then [config.vim.theme.name] + else [] + ) + ); + description = "Theme for lualine"; + }; + + sectionSeparator = { + left = mkOption { + type = types.str; + description = "Section separator for left side"; + }; + + right = mkOption { + type = types.str; + description = "Section separator for right side"; + }; + }; + + componentSeparator = { + left = mkOption { + type = types.str; + description = "Component separator for left side"; + }; + + right = mkOption { + type = types.str; + description = "Component separator for right side"; + }; + }; + + activeSection = { + a = mkOption { + type = types.str; + description = "active config for: | (A) | B | C X | Y | Z |"; + }; + + b = mkOption { + type = types.str; + description = "active config for: | A | (B) | C X | Y | Z |"; + }; + + c = mkOption { + type = types.str; + description = "active config for: | A | B | (C) X | Y | Z |"; + }; + + x = mkOption { + type = types.str; + description = "active config for: | A | B | C (X) | Y | Z |"; + }; + + y = mkOption { + type = types.str; + description = "active config for: | A | B | C X | (Y) | Z |"; + }; + + z = mkOption { + type = types.str; + description = "active config for: | A | B | C X | Y | (Z) |"; + }; + }; + + inactiveSection = { + a = mkOption { + type = types.str; + description = "inactive config for: | (A) | B | C X | Y | Z |"; + }; + + b = mkOption { + type = types.str; + description = "inactive config for: | A | (B) | C X | Y | Z |"; + }; + + c = mkOption { + type = types.str; + description = "inactive config for: | A | B | (C) X | Y | Z |"; + }; + + x = mkOption { + type = types.str; + description = "inactive config for: | A | B | C (X) | Y | Z |"; + }; + + y = mkOption { + type = types.str; + description = "inactive config for: | A | B | C X | (Y) | Z |"; + }; + + z = mkOption { + type = types.str; + description = "inactive config for: | A | B | C X | Y | (Z) |"; + }; + }; + }; + + config = + mkIf cfg.enable + { + #assertions = [ + # ({ + # assertion = if cfg.icons then (config.vim.visuals.enable && config.vim.visuals.nvimWebDevicons.enable) else true; + # message = "Must enable config.vim.visual.nvimWebDevicons if using config.vim.visuals.lualine.icons"; + # }) + #]; + + vim.startPlugins = ["lualine"]; + vim.luaConfigRC.lualine = nvim.dag.entryAnywhere '' + require'lualine'.setup { + options = { + icons_enabled = ${ + if cfg.icons + then "true" + else "false" + }, + theme = "${cfg.theme}", + component_separators = {"${cfg.componentSeparator.left}","${cfg.componentSeparator.right}"}, + section_separators = {"${cfg.sectionSeparator.left}","${cfg.sectionSeparator.right}"}, + disabled_filetypes = {}, + }, + sections = { + lualine_a = ${cfg.activeSection.a}, + lualine_b = ${cfg.activeSection.b}, + lualine_c = ${cfg.activeSection.c}, + lualine_x = ${cfg.activeSection.x}, + lualine_y = ${cfg.activeSection.y}, + lualine_z = ${cfg.activeSection.z}, + }, + inactive_sections = { + lualine_a = ${cfg.inactiveSection.a}, + lualine_b = ${cfg.inactiveSection.b}, + lualine_c = ${cfg.inactiveSection.c}, + lualine_x = ${cfg.inactiveSection.x}, + lualine_y = ${cfg.inactiveSection.y}, + lualine_z = ${cfg.inactiveSection.z}, + }, + tabline = {}, + extensions = {${ + if config.vim.filetree.nvimTreeLua.enable + then "\"nvim-tree\"" + else "" + }}, + } + ''; + }; +} diff --git a/modules/statusline/supported_lualine_themes.nix b/modules/statusline/supported_lualine_themes.nix new file mode 100644 index 0000000..e5de3f6 --- /dev/null +++ b/modules/statusline/supported_lualine_themes.nix @@ -0,0 +1,5 @@ +[ + "tokyonight" + "onedark" + "catppuccin" +] diff --git a/modules/tabline/default.nix b/modules/tabline/default.nix new file mode 100644 index 0000000..4d16dfb --- /dev/null +++ b/modules/tabline/default.nix @@ -0,0 +1,10 @@ +{ + pkgs, + lib, + config, + ... +}: { + imports = [ + ./nvim-bufferline.nix + ]; +} diff --git a/modules/tabline/nvim-bufferline.nix b/modules/tabline/nvim-bufferline.nix new file mode 100644 index 0000000..fca433f --- /dev/null +++ b/modules/tabline/nvim-bufferline.nix @@ -0,0 +1,100 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.tabline.nvimBufferline; +in { + options.vim.tabline.nvimBufferline = { + enable = mkEnableOption "nvim-bufferline-lua"; + }; + + config = mkIf cfg.enable ( + let + mouse = { + right = "'vertical sbuffer %d'"; + close = '' + function(bufnum) + require("bufdelete").bufdelete(bufnum, false) + end + ''; + }; + in { + vim.startPlugins = [ + (assert config.vim.visuals.nvimWebDevicons.enable == true; "nvim-bufferline-lua") + "bufdelete-nvim" + ]; + + vim.nnoremap = { + "bn" = ":BufferLineCycleNext"; + "bp" = ":BufferLineCyclePrev"; + "bc" = ":BufferLinePick"; + "bse" = ":BufferLineSortByExtension"; + "bsd" = ":BufferLineSortByDirectory"; + "bsi" = ":lua require'bufferline'.sort_buffers_by(function (buf_a, buf_b) return buf_a.id < buf_b.id end)"; + "bmn" = ":BufferLineMoveNext"; + "bmp" = ":BufferLineMovePrev"; + "b1" = "BufferLineGoToBuffer 1"; + "b2" = "BufferLineGoToBuffer 2"; + "b3" = "BufferLineGoToBuffer 3"; + "b4" = "BufferLineGoToBuffer 4"; + "b5" = "BufferLineGoToBuffer 5"; + "b6" = "BufferLineGoToBuffer 6"; + "b7" = "BufferLineGoToBuffer 7"; + "b8" = "BufferLineGoToBuffer 8"; + "b9" = "BufferLineGoToBuffer 9"; + }; + + vim.luaConfigRC.nvimBufferline = nvim.dag.entryAnywhere '' + require("bufferline").setup{ + options = { + numbers = "both", + close_command = ${mouse.close}, + right_mouse_command = ${mouse.right}, + indicator = { + indicator_icon = '▎', + style = 'icon', + }, + buffer_close_icon = '', + modified_icon = '●', + close_icon = '', + left_trunc_marker = '', + right_trunc_marker = '', + separator_style = "thin", + max_name_length = 18, + max_prefix_length = 15, + tab_size = 18, + show_buffer_icons = true, + show_buffer_close_icons = true, + show_close_icon = true, + show_tab_indicators = true, + persist_buffer_sort = true, + enforce_regular_tabs = false, + always_show_bufferline = true, + offsets = {{filetype = "NvimTree", text = "File Explorer", text_align = "left"}}, + sort_by = 'extension', + diagnostics = "nvim_lsp", + diagnostics_update_in_insert = true, + diagnostics_indicator = function(count, level, diagnostics_dict, context) + local s = "" + for e, n in pairs(diagnostics_dict) do + local sym = e == "error" and "" + or (e == "warning" and "" or "" ) + if(sym ~= "") then + s = s .. " " .. n .. sym + end + end + return s + end, + numbers = function(opts) + return string.format('%s·%s', opts.raise(opts.id), opts.lower(opts.ordinal)) + end, + } + } + ''; + } + ); +} diff --git a/modules/telescope/default.nix b/modules/telescope/default.nix new file mode 100644 index 0000000..67bde16 --- /dev/null +++ b/modules/telescope/default.nix @@ -0,0 +1,77 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.telescope; +in { + options.vim.telescope = { + enable = mkEnableOption "enable telescope"; + }; + + config = mkIf (cfg.enable) { + vim.startPlugins = [ + "telescope" + ]; + + vim.nnoremap = + { + "ff" = " Telescope find_files"; + "fg" = " Telescope live_grep"; + "fb" = " Telescope buffers"; + "fh" = " Telescope help_tags"; + "ft" = " Telescope"; + + "fvcw" = " Telescope git_commits"; + "fvcb" = " Telescope git_bcommits"; + "fvb" = " Telescope git_branches"; + "fvs" = " Telescope git_status"; + "fvx" = " Telescope git_stash"; + } + // ( + if config.vim.lsp.enable + then { + "flsb" = " Telescope lsp_document_symbols"; + "flsw" = " Telescope lsp_workspace_symbols"; + + "flr" = " Telescope lsp_references"; + "fli" = " Telescope lsp_implementations"; + "flD" = " Telescope lsp_definitions"; + "flt" = " Telescope lsp_type_definitions"; + "fld" = " Telescope diagnostics"; + } + else {} + ) + // ( + if config.vim.treesitter.enable + then { + "fs" = " Telescope treesitter"; + } + else {} + ); + + vim.luaConfigRC.telescope = nvim.dag.entryAnywhere '' + require("telescope").setup { + defaults = { + vimgrep_arguments = { + "${pkgs.ripgrep}/bin/rg", + "--color=never", + "--no-heading", + "--with-filename", + "--line-number", + "--column", + "--smart-case" + }, + pickers = { + find_command = { + "${pkgs.fd}/bin/fd", + }, + }, + } + } + ''; + }; +} diff --git a/modules/theme/config.nix b/modules/theme/config.nix new file mode 100644 index 0000000..bbe6d28 --- /dev/null +++ b/modules/theme/config.nix @@ -0,0 +1,11 @@ +{ pkgs, config, lib, ... }: +with lib; { + config = { + vim.theme = { + enable = mkDefault false; + name = mkDefault "onedark"; + style = mkDefault "darker"; + extraConfig = mkDefault ""; + }; + }; +} diff --git a/modules/theme/default.nix b/modules/theme/default.nix new file mode 100644 index 0000000..d511fc4 --- /dev/null +++ b/modules/theme/default.nix @@ -0,0 +1,11 @@ +{ + pkgs, + config, + lib, + ... +}: { + imports = [ + ./theme.nix + ./config.nix + ]; +} diff --git a/modules/theme/supported_themes.nix b/modules/theme/supported_themes.nix new file mode 100644 index 0000000..31fc86f --- /dev/null +++ b/modules/theme/supported_themes.nix @@ -0,0 +1,33 @@ +{ + onedark = { + setup = { style ? "dark" }: '' + -- OneDark theme + require('onedark').setup { + style = "${style}" + } + require('onedark').load() + ''; + styles = [ "dark" "darker" "cool" "deep" "warm" "warmer" ]; + }; + + tokyonight = { + setup = { style ? "night" }: '' + -- need to set style before colorscheme to apply + vim.g.tokyonight_style = '${style}' + vim.cmd[[colorscheme tokyonight]] + ''; + styles = [ "day" "night" "storm" ]; + }; + + catppuccin = { + setup = { style ? "mocha" }: '' + -- Catppuccin theme + require('catppuccin').setup { + flavour = "${style}" + } + -- setup must be called before loading + vim.cmd.colorscheme "catppuccin" + ''; + styles = [ "latte" "frappe" "macchiato" "mocha" ]; + }; +} diff --git a/modules/theme/theme.nix b/modules/theme/theme.nix new file mode 100644 index 0000000..1246b90 --- /dev/null +++ b/modules/theme/theme.nix @@ -0,0 +1,40 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with lib.attrsets; +with builtins; let + cfg = config.vim.theme; + supported_themes = import ./supported_themes.nix; +in { + options.vim.theme = { + enable = mkOption { + type = types.bool; + description = "Enable Theme"; + }; + + name = mkOption { + type = types.enum (attrNames supported_themes); + description = "Supported themes can be found in `supported_themes.nix`"; + }; + + style = mkOption { + type = with types; enum supported_themes.${cfg.name}.styles; + description = "Specific style for theme if it supports it"; + }; + + extraConfig = mkOption { + type = with types; lines; + description = "Additional lua configuration to add before setup"; + }; + }; + + config = mkIf cfg.enable { + vim.startPlugins = [cfg.name]; + vim.luaConfigRC.themeSetup = nvim.dag.entryBefore ["theme"] cfg.extraConfig; + vim.luaConfigRC.theme = supported_themes.${cfg.name}.setup {style = cfg.style;}; + }; +} diff --git a/modules/tidal/default.nix b/modules/tidal/default.nix new file mode 100644 index 0000000..bb19046 --- /dev/null +++ b/modules/tidal/default.nix @@ -0,0 +1,6 @@ +{ + config, + lib, + pkgs, + ... +}: {imports = [./tidal.nix];} diff --git a/modules/tidal/tidal.nix b/modules/tidal/tidal.nix new file mode 100644 index 0000000..6b6c27e --- /dev/null +++ b/modules/tidal/tidal.nix @@ -0,0 +1,39 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.tidal; +in { + options.vim.tidal = { + enable = mkEnableOption "tidal tools and plugins"; + + flash = mkOption { + description = ''When sending a paragraph or a single line, vim-tidal will "flash" the selection for some milliseconds''; + type = types.int; + default = 150; + }; + + openSC = mkOption { + description = "Automatically run the supercollider CLI, sclang, alongside the Tidal GHCI terminal."; + type = types.bool; + default = true; + }; + }; + + config = mkIf (cfg.enable) { + vim.startPlugins = [ + # From tidalcycles flake + pkgs.vimPlugins.vim-tidal + ]; + + vim.globals = { + "tidal_target" = "terminal"; + "tidal_flash_duration" = 150; + "tidal_sc_enable" = cfg.openSC; + }; + }; +} diff --git a/modules/treesitter/context.nix b/modules/treesitter/context.nix new file mode 100644 index 0000000..64e421e --- /dev/null +++ b/modules/treesitter/context.nix @@ -0,0 +1,31 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.treesitter; +in { + options.vim.treesitter.context.enable = mkOption { + type = types.bool; + default = false; + description = "enable function context [nvim-treesitter-context]"; + }; + + config = mkIf (cfg.enable && cfg.context.enable) { + vim.startPlugins = [ + "nvim-treesitter-context" + ]; + + vim.luaConfigRC.treesitter-context = nvim.dag.entryAnywhere '' + -- Treesitter Context config + require'treesitter-context'.setup { + enable = true, + throttle = true, + max_lines = 0 + } + ''; + }; +} diff --git a/modules/treesitter/default.nix b/modules/treesitter/default.nix new file mode 100644 index 0000000..5f52900 --- /dev/null +++ b/modules/treesitter/default.nix @@ -0,0 +1,11 @@ +{ + config, + lib, + pkgs, + ... +}: { + imports = [ + ./treesitter.nix + ./context.nix + ]; +} diff --git a/modules/treesitter/treesitter.nix b/modules/treesitter/treesitter.nix new file mode 100644 index 0000000..8ed5154 --- /dev/null +++ b/modules/treesitter/treesitter.nix @@ -0,0 +1,111 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.treesitter; +in { + options.vim.treesitter = { + enable = mkOption { + default = false; + type = types.bool; + description = "enable tree-sitter [nvim-treesitter]"; + }; + + fold = mkOption { + default = false; + type = types.bool; + description = "enable fold with tree-sitter"; + }; + + autotagHtml = mkOption { + default = false; + type = types.bool; + description = "enable autoclose and rename html tag [nvim-ts-autotag]"; + }; + + grammars = mkOption { + type = with types; listOf package; + default = with (pkgs.vimPlugins.nvim-treesitter.builtGrammars); [ + c + cpp + nix + python + rust + markdown + comment + toml + make + tsx + html + javascript + css + graphql + json + zig + ]; + description = '' + List of treesitter grammars to install. + When enabling a language, its treesitter grammar is added for you. + ''; + }; + }; + + config = mkIf cfg.enable ( + let + writeIf = cond: msg: + if cond + then msg + else ""; + in { + vim.startPlugins = [ + "nvim-treesitter" + ( + if cfg.autotagHtml + then "nvim-ts-autotag" + else null + ) + ]; + + # For some reason treesitter highlighting does not work on start if this is set before syntax on + vim.configRC.treesitter = writeIf cfg.fold (nvim.dag.entryBefore ["basic"] '' + " Tree-sitter based folding + set foldmethod=expr + set foldexpr=nvim_treesitter#foldexpr() + set nofoldenable + ''); + + vim.luaConfigRC.treesitter = nvim.dag.entryAnywhere '' + -- Treesitter config + require'nvim-treesitter.configs'.setup { + highlight = { + enable = true, + disable = {}, + }, + + auto_install = false, + ensure_installed = {}, + + incremental_selection = { + enable = true, + keymaps = { + init_selection = "gnn", + node_incremental = "grn", + scope_incremental = "grc", + node_decremental = "grm", + }, + }, + + ${writeIf cfg.autotagHtml '' + autotag = { + enable = true, + }, + ''} + } + ''; + } + ); +} diff --git a/modules/visuals/config.nix b/modules/visuals/config.nix new file mode 100644 index 0000000..11d580d --- /dev/null +++ b/modules/visuals/config.nix @@ -0,0 +1,28 @@ +{ pkgs +, config +, lib +, ... +}: +with lib; { + config = { + vim.visuals = { + enable = mkDefault false; + + nvimWebDevicons.enable = mkDefault false; + lspkind.enable = mkDefault false; + + cursorWordline = { + enable = mkDefault false; + lineTimeout = mkDefault 500; + }; + + indentBlankline = { + enable = mkDefault false; + listChar = mkDefault "│"; + fillChar = mkDefault "⋅"; + eolChar = mkDefault "↴"; + showCurrContext = mkDefault true; + }; + }; + }; +} diff --git a/modules/visuals/default.nix b/modules/visuals/default.nix new file mode 100644 index 0000000..59a3e54 --- /dev/null +++ b/modules/visuals/default.nix @@ -0,0 +1,11 @@ +{ + pkgs, + config, + lib, + ... +}: { + imports = [ + ./config.nix + ./visuals.nix + ]; +} diff --git a/modules/visuals/visuals.nix b/modules/visuals/visuals.nix new file mode 100644 index 0000000..7008c68 --- /dev/null +++ b/modules/visuals/visuals.nix @@ -0,0 +1,135 @@ +{ + pkgs, + config, + lib, + ... +}: +with lib; +with builtins; let + cfg = config.vim.visuals; +in { + options.vim.visuals = { + enable = mkOption { + type = types.bool; + description = "visual enhancements"; + }; + + nvimWebDevicons.enable = mkOption { + type = types.bool; + description = "enable dev icons. required for certain plugins [nvim-web-devicons]"; + }; + + lspkind.enable = mkOption { + type = types.bool; + description = "enable vscode-like pictograms for lsp [lspkind]"; + }; + + cursorWordline = { + enable = mkOption { + type = types.bool; + description = "enable word and delayed line highlight [nvim-cursorline]"; + }; + + lineTimeout = mkOption { + type = types.int; + description = "time in milliseconds for cursorline to appear"; + }; + }; + + indentBlankline = { + enable = mkOption { + type = types.bool; + description = "enable indentation guides [indent-blankline]"; + }; + + listChar = mkOption { + type = types.str; + description = "Character for indentation line"; + }; + + fillChar = mkOption { + type = types.str; + description = "Character to fill indents"; + }; + + eolChar = mkOption { + type = types.str; + description = "Character at end of line"; + }; + + showCurrContext = mkOption { + type = types.bool; + description = "Highlight current context from treesitter"; + }; + }; + }; + + config = + mkIf cfg.enable + { + vim.startPlugins = [ + ( + if cfg.nvimWebDevicons.enable + then "nvim-web-devicons" + else null + ) + ( + if cfg.lspkind.enable + then "lspkind" + else null + ) + ( + if cfg.cursorWordline.enable + then "nvim-cursorline" + else null + ) + ( + if cfg.indentBlankline.enable + then "indent-blankline" + else null + ) + ]; + + vim.luaConfigRC.visuals = nvim.dag.entryAnywhere '' + ${ + if cfg.lspkind.enable + then "require'lspkind'.init()" + else "" + } + ${ + if cfg.indentBlankline.enable + then '' + -- highlight error: https://github.com/lukas-reineke/indent-blankline.nvim/issues/59 + vim.wo.colorcolumn = "99999" + vim.opt.list = true + + + ${ + if cfg.indentBlankline.eolChar == "" + then "" + else ''vim.opt.listchars:append({ eol = "${cfg.indentBlankline.eolChar}" })'' + } + + ${ + if cfg.indentBlankline.fillChar == "" + then "" + else ''vim.opt.listchars:append({ space = "${cfg.indentBlankline.fillChar}"})'' + } + + require("indent_blankline").setup { + char = "${cfg.indentBlankline.listChar}", + show_current_context = ${boolToString cfg.indentBlankline.showCurrContext}, + show_end_of_line = true, + } + '' + else "" + } + + ${ + if cfg.cursorWordline.enable + then "vim.g.cursorline_timeout = ${toString cfg.cursorWordline.lineTimeout}" + else "" + } + ''; + }; +} diff --git a/screenshot.png b/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..48ca7d2f7c34834925378ec41d94b73243b34901 GIT binary patch literal 208671 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 D1(82% literal 0 HcmV?d00001