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

treewide: make the entire generated config lua based (#333)

Browse source 
* modules: switch to gerg's neovim-wrapper

* modules: use initViml instead of writing the file

* treewide: make the entire generated config lua based

* docs: remove mentions of configRC

* plugins/treesitter: remove vim.cmd hack

* treewide: move resolveDag to lib

* modules/wrapper(rc): fix typo

* treewide: migrate to pluginRC for correct DAG order

The "new" DAG order is as follows:
- (luaConfigPre)
- globalsScript
- basic
- theme
- pluginConfigs
- extraPluginConfigs
- mappings
- (luaConfigPost)

* plugins/theme: fix theme DAG place

* plugins/theme: fix fixed theme DAG place

* modules/wrapper(rc): add removed option module for configRC

* docs: add dag-entries chapter, add release note entry

* fix: formatting CI

* languages/nix: add missing `local`

* docs: fix page link

* docs: add mention of breaking changes at the start of the release notes

* plugins/neo-tree: convert to pluginRC

* modules/wrapper(rc): add back entryAnywhere

* modules/wrapper(rc): expose pluginRC

* apply raf patch

---------

Co-authored-by: NotAShelf <raf@notashelf.dev>
This commit is contained in:
diniamo 2024-07-20 10:30:48 +02:00 • committed by GitHub
commit f9789432f9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
84 changed files with 389 additions and 404 deletions
Download patch file Download diff file Expand all files Collapse all files

1
docs/manual/configuring.md
View file

@ -5,4 +5,5 @@ configuring/custom-package.md
configuring/custom-plugins.md
configuring/languages.md
configuring/dags.md
configuring/dag-entries.md
```

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

@ -1,16 +1,38 @@
# Configuring {#sec-configuring-plugins}
Just making the plugin to your Neovim configuration available might not always
be enough. In that case, you can write custom vimscript or lua config, using
either `config.vim.configRC` or `config.vim.luaConfigRC` respectively. Both of
these options are attribute sets, and you need to give the configuration you're
adding some name, like this:
be enough. In that case, you can write custom lua config using either
`config.vim.extraPlugins` (which has the `setup` field) or
`config.vim.luaConfigRC`. The first option uses an attribute set, which maps DAG
section names to a custom type, which has the fields `package`, `after`,
`setup`. They allow you to set the package of the plugin, the sections its setup
code should be after (note that the `extraPlugins` option has its own DAG
scope), and the its setup code respectively. For example:
```nix
config.vim.extraPlugins = with pkgs.vimPlugins; {
aerial = {
package = aerial-nvim;
setup = "require('aerial').setup {}";
};
harpoon = {
package = harpoon;
setup = "require('harpoon').setup {}";
after = ["aerial"]; # place harpoon configuration after aerial
};
}
```
The second option also uses an attribute set, but this one is resolved as a DAG
directly. The attribute names denote the section names, and the values lua code.
For example:
```nix
{
# this will create an "aquarium" section in your init.vim with the contents of your custom config
# this will create an "aquarium" section in your init.lua with the contents of your custom config
# which will be *appended* to the rest of your configuration, inside your init.vim
config.vim.configRC.aquarium = "colorscheme aquiarum";
config.vim.luaConfigRC.aquarium = "vim.cmd('colorscheme aquiarum')";
}
```

20
docs/manual/configuring/dag-entries.md Normal file
View file

@ -0,0 +1,20 @@
# DAG entries in nvf {#ch-dag-entries}
From the previous chapter, it should be clear that DAGs are useful, because you
can add code that relies on other code. However, if you don't know what the
entries are called, it's hard to do that, so here is a list of the internal
entries in nvf:
`vim.luaConfigRC` (top-level DAG):
1. (`luaConfigPre`) - not a part of the actual DAG, instead, it's simply
inserted before the rest of the DAG
2. `globalsScript` - used to set globals defined in `vim.globals`
3. `basic` - used to set basic configuration options
4. `theme` - used to set up the theme, which has to be done before other plugins
5. `pluginConfigs` - the result of the nested `vim.pluginRC` (internal option,
see the [Custom Plugins](/index.xhtml#ch-custom-plugins) page for adding your own
plugins) DAG, used to set up internal plugins
6. `extraPluginConfigs` - the result of `vim.extraPlugins`, which is not a
direct DAG, but is converted to, and resolved as one internally
7. `mappings` - the result of `vim.maps`

2
docs/manual/configuring/dags.md
View file

@ -7,7 +7,7 @@ type which is borrowed from home-manager's extended library. This type is most
used for topologically sorting strings. The DAG type allows the attribute set
entries to express dependency relations among themselves. This can, for
example, be used to control the order of configuration sections in your
`configRC` or `luaConfigRC`.
`luaConfigRC`.
The below section, mostly taken from the [home-manager
manual](https://raw.githubusercontent.com/nix-community/home-manager/master/docs/manual/writing-modules/types.md)

70
docs/release-notes/rl-0.7.md
View file

@ -2,6 +2,28 @@
Release notes for release 0.7
## Breaking Changes and Migration Guide {#sec-breaking-changes-and-migration-guide-0-7}
In v0.7 we are removing `vim.configRC` in favor of making `vim.luaConfigRC` the
top-level DAG, and thereby making the entire configuration Lua based. This
change introduces a few breaking changes:
[DAG entries in nvf manual]: /index.xhtml#ch-dag-entries
- `vim.configRC` has been removed, which means that you have to convert all of
your custom vimscript-based configuration to Lua. As for how to do that, you
will have to consult the Neovim documentation and your search engine.
- After migrating your Vimscript-based configuration to Lua, you might not be
able to use the same entry names in `vim.luaConfigRC`, because those have also
slightly changed. See the new [DAG entries in nvf manual] for more details.
**Why?**
Neovim being an aggressive refactor of Vim, is designed to be mainly Lua based;
making good use of its extensive Lua API. Additionally, Vimscript is slow and
brings unnecessary performance overhead while working with different
configuration formats.
## Changelog {#sec-release-0.7-changelog}
[ItsSorae](https://github.com/ItsSorae):
@ -12,8 +34,8 @@ Release notes for release 0.7
[frothymarrow](https://github.com/frothymarrow):
- Modified type for
[vim.visuals.fidget-nvim.setupOpts.progress.display.overrides](#opt-vim.visuals.fidget-nvim.setupOpts.progress.display.overrides)
from `anything` to a `submodule` for better type checking.
[](#opt-vim.visuals.fidget-nvim.setupOpts.progress.display.overrides) from
`anything` to a `submodule` for better type checking.
- Fix null `vim.lsp.mappings` generating an error and not being filtered out.
@ -21,30 +43,34 @@ Release notes for release 0.7
group for `Normal`, `NormalFloat`, `LineNr`, `SignColumn` and optionally
`NvimTreeNormal` to `none`.
- Fix
[vim.ui.smartcolumn.setupOpts.custom_colorcolumn](#opt-vim.ui.smartcolumn.setupOpts.custom_colorcolumn)
using the wrong type `int` instead of the expected type `string`.
- Fix [](#opt-vim.ui.smartcolumn.setupOpts.custom_colorcolumn) using the wrong
type `int` instead of the expected type `string`.
- Fix unused src and version attributes in `buildPlug`.
[horriblename](https://github.com/horriblename):
- Fix broken treesitter-context keybinds in visual mode
- Deprecate use of `__empty` to define empty tables in lua. Empty attrset are no
- Deprecate use of `__empty` to define empty tables in Lua. Empty attrset are no
longer filtered and thus should be used instead.
- Add dap-go for better dap configurations
- Make noice.nvim customizable
- Switch from [rust-tools.nvim](https://github.com/simrat39/rust-tools.nvim)
to the more feature-packed [rustacean.nvim](https://github.com/mrcjkb/rustaceanvim.
This switch entails a whole bunch of new features and options, so you are
recommended to go through rustacean.nvim's README to take a closer look at
its features and usage.
[rust-tools.nvim]: https://github.com/simrat39/rust-tools.nvim
[rustaceanvim]: https://github.com/mrcjkb/rustaceanvim
- Switch from [rust-tools.nvim] to the more feature-packed [rustaceanvim]. This
switch entails a whole bunch of new features and options, so you are
recommended to go through rustacean.nvim's README to take a closer look at its
features and usage
[jacekpoz](https://github.com/jacekpoz):
- Add [ocaml-lsp](https://github.com/ocaml/ocaml-lsp) support.
[ocaml-lsp]: https://github.com/ocaml/ocaml-lsp
- Fix Emac typo
- Add [ocaml-lsp] support
- Fix "Emac" typo
[diniamo](https://github.com/diniamo):
@ -66,6 +92,7 @@ Release notes for release 0.7
plugin's options can now be found under `indentBlankline.setupOpts`, the
previous iteration of the module also included out of place/broken options,
which have been removed for the time being. These are:
- `listChar` - this was already unused
- `fillChar` - this had nothing to do with the plugin, please configure it
yourself by adding `vim.opt.listchars:append({ space = '<char>' })` to your
@ -74,9 +101,22 @@ Release notes for release 0.7
yourself by adding `vim.opt.listchars:append({ eol = '<char>' })` to your
lua configuration
[Neovim documentation on `vim.cmd`]: https://neovim.io/doc/user/lua.html#vim.cmd()
- Make Neovim's configuration file entirely Lua based. This comes with a few
breaking changes:
- `vim.configRC` has been removed. You will need to migrate your entries to
Neovim-compliant Lua code, and add them to `vim.luaConfigRC` instead.
Existing vimscript configurations may be preserved in `vim.cmd` functions.
Please see [Neovim documentation on `vim.cmd`]
- `vim.luaScriptRC` is now the top-level DAG, and the internal `vim.pluginRC`
has been introduced for setting up internal plugins. See the "DAG entries in
nvf" manual page for more information.
[NotAShelf](https://github.com/notashelf):
[ts-error-translator.nvim]: https://github.com/dmmulroy/ts-error-translator.nvim
[credo]: https://github.com/rrrene/credo
- Add `deno fmt` as the default Markdown formatter. This will be enabled
automatically if you have autoformatting enabled, but can be disabled manually
@ -87,8 +127,8 @@ Release notes for release 0.7
- Refactor `programs.languages.elixir` to use lspconfig and none-ls for LSP and
formatter setups respectively. Diagnostics support is considered, and may be
added once the [credo](https://github.com/rrrene/credo) linter has been added
to nixpkgs. A pull request is currently open.
added once the [credo] linter has been added to nixpkgs. A pull request is
currently open.
- Remove vim-tidal and friends.

26
lib/dag.nix
View file

@ -8,10 +8,10 @@
# - the addition of the function `entryBefore` indicating a "wanted
# by" relationship.
{lib}: let
inherit (builtins) isAttrs attrValues attrNames elem all head tail length;
inherit (builtins) isAttrs attrValues attrNames elem all head tail length toJSON isString;
inherit (lib.attrsets) filterAttrs mapAttrs;
inherit (lib.lists) toposort;
inherit (lib.nvim.dag) empty isEntry entryBetween entryAfter entriesBetween;
inherit (lib.nvim.dag) empty isEntry entryBetween entryAfter entriesBetween entryAnywhere topoSort;
in {
empty = {};
@ -147,8 +147,22 @@ in {
${section.data}
'';
mkVimrcSection = section: ''
" SECTION: ${section.name}
${section.data}
'';
resolveDag = {
name,
dag,
mapResult,
}: let
# When the value is a string, default it to dag.entryAnywhere
finalDag = mapAttrs (_: value:
if isString value
then entryAnywhere value
else value)
dag;
sortedDag = topoSort finalDag;
result =
if sortedDag ? result
then mapResult sortedDag.result
else abort ("Dependency cycle in ${name}: " + toJSON sortedDag);
in
result;
}

1
lib/default.nix
View file

@ -11,6 +11,5 @@
languages = import ./languages.nix {inherit lib;};
lists = import ./lists.nix {inherit lib;};
lua = import ./lua.nix {inherit lib;};
vim = import ./vim.nix;
neovimConfiguration = import ./configuration.nix {inherit inputs lib;};
}

10
lib/lua.nix
View file

@ -5,16 +5,6 @@
inherit (lib.strings) concatStringsSep concatMapStringsSep stringToCharacters concatLines;
inherit (lib.trivial) boolToString warn;
in rec {
wrapLuaConfig = {
luaBefore ? "",
luaConfig,
luaAfter ? "",
}: ''
lua << EOF
${concatLines [luaBefore luaConfig luaAfter]}
EOF
'';
# Convert a null value to lua's nil
nullString = value:
if value == null

26
lib/vim.nix
View file

@ -1,26 +0,0 @@
let
inherit (builtins) isInt isBool toJSON toString;
in rec {
# yes? no.
yesNo = value:
if value
then "yes"
else "no";
# convert a boolean to a vim compliant boolean string
mkVimBool = val:
if val
then "1"
else "0";
# convert a literal value to a vim compliant value
valToVim = val:
if (isInt val)
then (toString val)
else
(
if (isBool val)
then (mkVimBool val)
else (toJSON val)
);
}

3
modules/default.nix
View file

@ -98,8 +98,9 @@ inputs: {
neovim = vimOptions.package;
plugins = concatLists [builtStartPlugins builtOptPlugins];
appName = "nvf";
initViml = vimOptions.builtConfigRC;
extraBinPath = vimOptions.extraPackages;
initLua = vimOptions.builtLuaConfigRC;
luaFiles = vimOptions.extraLuaFiles;
inherit (vimOptions) viAlias vimAlias withRuby withNodeJs withPython3;
inherit extraLuaPackages extraPython3Packages;

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

@ -5,16 +5,17 @@
}: let
inherit (lib.options) mkOption literalExpression;
inherit (lib.strings) optionalString;
inherit (lib.types) enum bool str int nullOr;
inherit (lib.types) enum bool str int;
inherit (lib.nvim.dag) entryAfter;
inherit (lib.nvim.lua) toLuaObject;
cfg = config.vim;
in {
options.vim = {
leaderKey = mkOption {
type = nullOr str;
default = null;
description = "The leader key to be used internally";
type = str;
default = " ";
description = "The leader key used for `<leader>` mappings";
};
colourTerm = mkOption {
@ -53,12 +54,6 @@ in {
description = "Enable syntax highlighting";
};
mapLeaderSpace = mkOption {
type = bool;
default = true;
description = "Map the space key to leader key";
};
useSystemClipboard = mkOption {
type = bool;
default = false;
@ -165,117 +160,110 @@ in {
};
};
config.vim.configRC.basic = entryAfter ["globalsScript"] ''
" Settings that are set for everything
set encoding=utf-8
set hidden
set shortmess+=c
set expandtab
set mouse=${cfg.mouseSupport}
set tabstop=${toString cfg.tabWidth}
set shiftwidth=${toString cfg.tabWidth}
set softtabstop=${toString cfg.tabWidth}
set cmdheight=${toString cfg.cmdHeight}
set updatetime=${toString cfg.updateTime}
set tm=${toString cfg.mapTimeout}
set cursorlineopt=${toString cfg.cursorlineOpt}
set scrolloff=${toString cfg.scrollOffset}
config.vim.luaConfigRC.basic = entryAfter ["globalsScript"] ''
-- Settings that are set for everything
vim.o.encoding = "utf-8"
vim.o.hidden = true
vim.opt.shortmess:append("c")
vim.o.expandtab = true
vim.o.mouse = ${toLuaObject cfg.mouseSupport}
vim.o.tabstop = ${toLuaObject cfg.tabWidth}
vim.o.shiftwidth = ${toLuaObject cfg.tabWidth}
vim.o.softtabstop = ${toLuaObject cfg.tabWidth}
vim.o.cmdheight = ${toLuaObject cfg.cmdHeight}
vim.o.updatetime = ${toLuaObject cfg.updateTime}
vim.o.tm = ${toLuaObject cfg.mapTimeout}
vim.o.cursorlineopt = ${toLuaObject cfg.cursorlineOpt}
vim.o.scrolloff = ${toLuaObject cfg.scrollOffset}
vim.g.mapleader = ${toLuaObject cfg.leaderKey}
vim.g.maplocalleader = ${toLuaObject cfg.leaderKey}
${optionalString cfg.splitBelow ''
set splitbelow
vim.o.splitbelow = true
''}
${optionalString cfg.splitRight ''
set splitright
vim.o.splitright = true
''}
${optionalString cfg.showSignColumn ''
set signcolumn=yes
vim.o.signcolumn = "yes"
''}
${optionalString cfg.autoIndent ''
set autoindent
vim.o.autoindent = true
''}
${optionalString cfg.preventJunkFiles ''
set noswapfile
set nobackup
set nowritebackup
vim.o.swapfile = false
vim.o.backup = false
vim.o.writebackup = false
''}
${optionalString (cfg.bell == "none") ''
set noerrorbells
set novisualbell
vim.o.errorbells = false
vim.o.visualbell = false
''}
${optionalString (cfg.bell == "on") ''
set novisualbell
vim.o.visualbell = false
''}
${optionalString (cfg.bell == "visual") ''
set noerrorbells
vim.o.errorbells = false
''}
${optionalString (cfg.lineNumberMode == "relative") ''
set relativenumber
vim.o.relativenumber = true
''}
${optionalString (cfg.lineNumberMode == "number") ''
set number
vim.o.number = true
''}
${optionalString (cfg.lineNumberMode == "relNumber") ''
set number relativenumber
vim.o.number = true
vim.o.relativenumber = true
''}
${optionalString cfg.useSystemClipboard ''
set clipboard+=unnamedplus
''}
${optionalString cfg.mapLeaderSpace ''
let mapleader=" "
let maplocalleader=" "
vim.opt.clipboard:append("unnamedplus")
''}
${optionalString cfg.syntaxHighlighting ''
syntax on
vim.cmd("syntax on")
''}
${optionalString (!cfg.wordWrap) ''
set nowrap
vim.o.wrap = false
''}
${optionalString cfg.hideSearchHighlight ''
set nohlsearch
set incsearch
vim.o.hlsearch = false
vim.o.incsearch = true
''}
${optionalString cfg.colourTerm ''
set termguicolors
set t_Co=256
vim.o.termguicolors = true
''}
${optionalString (!cfg.enableEditorconfig) ''
let g:editorconfig = v:false
''}
${optionalString (cfg.leaderKey != null) ''
let mapleader = "${toString cfg.leaderKey}"
vim.g.editorconfig = false
''}
${optionalString (cfg.searchCase == "ignore") ''
set nosmartcase
set ignorecase
vim.o.smartcase = false
vim.o.ignorecase = true
''}
${optionalString (cfg.searchCase == "smart") ''
set smartcase
set ignorecase
vim.o.smartcase = true
vim.o.ignorecase = true
''}
${optionalString (cfg.searchCase == "sensitive") ''
set nosmartcase
set noignorecase
vim.o.smartcase = false
vim.o.ignorecase = false
''}
'';
}

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

@ -9,8 +9,7 @@
in {
config = {
vim.maps = {
normal =
mkIf cfg.disableArrows {
normal = mkIf cfg.disableArrows {
"<up>" = {
action = "<nop>";
@ -29,11 +28,6 @@ in {
action = "<nop>";
noremap = false;
};
}
// mkIf cfg.mapLeaderSpace {
"<space>" = {
action = "<nop>";
};
};
insert = mkIf cfg.disableArrows {

2
modules/plugins/assistant/chatgpt/config.nix
View file

@ -33,7 +33,7 @@ in {
startPlugins = [
"chatgpt"
];
luaConfigRC.chagpt = entryAnywhere ''
pluginRC.chagpt = entryAnywhere ''
require("chatgpt").setup(${toLuaObject cfg.setupOpts})
'';
maps.normal = mkMerge [

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

@ -34,7 +34,7 @@ in {
"copilot-cmp"
];
vim.luaConfigRC.copilot = entryAnywhere ''
vim.pluginRC.copilot = entryAnywhere ''
require("copilot").setup(${toLuaObject cfg.setupOpts})
${lib.optionalString cfg.cmp.enable ''

2
modules/plugins/autopairs/nvim-autopairs/config.nix
View file

@ -12,7 +12,7 @@ in {
config = mkIf cfg.enable {
vim.startPlugins = ["nvim-autopairs"];
vim.luaConfigRC.autopairs = entryAnywhere ''
vim.pluginRC.autopairs = entryAnywhere ''
require("nvim-autopairs").setup({ map_cr = ${boolToString (!config.vim.autocomplete.enable)} })
'';
};

2
modules/plugins/comments/comment-nvim/config.nix
View file

@ -41,7 +41,7 @@ in {
(mkBinding cfg.mappings.toggleSelectedBlock "<Plug>(comment_toggle_blockwise_visual)" mappings.toggleSelectedBlock.description)
];
vim.luaConfigRC.comment-nvim = entryAnywhere ''
vim.pluginRC.comment-nvim = entryAnywhere ''
require('Comment').setup({
mappings = { basic = false, extra = false, },
})

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

@ -186,7 +186,7 @@ in {
# TODO: alternative snippet engines to vsnip
# https://github.com/hrsh7th/nvim-cmp/blob/main/doc/cmp.txt#L82
vim.luaConfigRC.completion = mkIf (cfg.type == "nvim-cmp") (dagPlacement ''
vim.pluginRC.completion = mkIf (cfg.type == "nvim-cmp") (dagPlacement ''
local nvim_cmp_menu_map = function(entry, vim_item)
-- name for each source
vim_item.menu = ({

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

@ -16,7 +16,7 @@ in {
# the entire credit for this dashboard configuration to https://github.com/Rishabh672003
# honestly, excellent work
vim.luaConfigRC.alpha = entryAnywhere ''
vim.pluginRC.alpha = entryAnywhere ''
local alpha = require("alpha")
local plenary_path = require("plenary.path")
local dashboard = require("alpha.themes.dashboard")

2
modules/plugins/dashboard/dashboard-nvim/config.nix
View file

@ -13,7 +13,7 @@ in {
"dashboard-nvim"
];
vim.luaConfigRC.dashboard-nvim = entryAnywhere ''
vim.pluginRC.dashboard-nvim = entryAnywhere ''
require("dashboard").setup{}
'';
};

21
modules/plugins/dashboard/startify/config.nix
View file

@ -5,7 +5,6 @@
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.vim) mkVimBool;
cfg = config.vim.dashboard.startify;
in {
@ -23,28 +22,28 @@ in {
else cfg.customFooter;
"startify_bookmarks" = cfg.bookmarks;
"startify_lists" = cfg.lists;
"startify_change_to_dir" = mkVimBool cfg.changeToDir;
"startify_change_to_vcs_root" = mkVimBool cfg.changeToVCRoot;
"startify_change_to_dir" = cfg.changeToDir;
"startify_change_to_vcs_root" = cfg.changeToVCRoot;
"startify_change_cmd" = cfg.changeDirCmd;
"startify_skiplist" = cfg.skipList;
"startify_update_oldfiles" = mkVimBool cfg.updateOldFiles;
"startify_session_autoload" = mkVimBool cfg.sessionAutoload;
"startify_update_oldfiles" = cfg.updateOldFiles;
"startify_session_autoload" = cfg.sessionAutoload;
"startify_commands" = cfg.commands;
"startify_files_number" = cfg.filesNumber;
"startify_custom_indices" = cfg.customIndices;
"startify_disable_at_vimenter" = mkVimBool cfg.disableOnStartup;
"startify_enable_unsafe" = mkVimBool cfg.unsafe;
"startify_disable_at_vimenter" = cfg.disableOnStartup;
"startify_enable_unsafe" = cfg.unsafe;
"startify_padding_left" = cfg.paddingLeft;
"startify_use_env" = mkVimBool cfg.useEnv;
"startify_use_env" = cfg.useEnv;
"startify_session_before_save" = cfg.sessionBeforeSave;
"startify_session_persistence" = mkVimBool cfg.sessionPersistence;
"startify_session_delete_buffers" = mkVimBool cfg.sessionDeleteBuffers;
"startify_session_persistence" = cfg.sessionPersistence;
"startify_session_delete_buffers" = cfg.sessionDeleteBuffers;
"startify_session_dir" = cfg.sessionDir;
"startify_skiplist_server" = cfg.skipListServer;
"startify_session_remove_lines" = cfg.sessionRemoveLines;
"startify_session_savevars" = cfg.sessionSavevars;
"startify_session_savecmds" = cfg.sessionSavecmds;
"startify_session_sort" = mkVimBool cfg.sessionSort;
"startify_session_sort" = cfg.sessionSort;
};
};
}

4
modules/plugins/debugger/nvim-dap/config.nix
View file

@ -18,7 +18,7 @@ in {
(mkIf cfg.enable {
vim.startPlugins = ["nvim-dap"];
vim.luaConfigRC =
vim.pluginRC =
{
# TODO customizable keymaps
nvim-dap = entryAnywhere ''
@ -51,7 +51,7 @@ in {
(mkIf (cfg.enable && cfg.ui.enable) {
vim.startPlugins = ["nvim-dap-ui" "nvim-nio"];
vim.luaConfigRC.nvim-dap-ui = entryAfter ["nvim-dap"] (''
vim.pluginRC.nvim-dap-ui = entryAfter ["nvim-dap"] (''
local dapui = require("dapui")
dapui.setup()
''

2
modules/plugins/filetree/neo-tree/config.nix
View file

@ -20,7 +20,7 @@ in {
"neo-tree-nvim"
];
luaConfigRC.neo-tree = entryAnywhere ''
pluginRC.neo-tree = entryAnywhere ''
require("neo-tree").setup(${toLuaObject cfg.setupOpts})
'';
};

2
modules/plugins/filetree/nvimtree/config.nix
View file

@ -29,7 +29,7 @@ in {
"<leader>t" = "+NvimTree";
};
vim.luaConfigRC.nvimtreelua = entryAnywhere ''
vim.pluginRC.nvimtreelua = entryAnywhere ''
${
optionalString cfg.setupOpts.disable_netrw ''
-- disable netrew completely

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

@ -69,7 +69,7 @@ in {
"<leader>g" = "+Gitsigns";
};
luaConfigRC.gitsigns = entryAnywhere ''
pluginRC.gitsigns = entryAnywhere ''
require('gitsigns').setup{}
'';
};

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

@ -12,7 +12,7 @@
inherit (lib.modules) mkIf mkMerge;
inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.dag) entryAfter;
packageToCmd = package: defaultCmd:
if isList cfg.lsp.package
@ -141,7 +141,7 @@ in {
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.cHeader {
vim.configRC.c-header = entryAnywhere "let g:c_syntax_for_h = 1";
vim.pluginRC.c-header = entryAfter ["basic"] "vim.g.c_syntax_for_h = 1";
})
(mkIf cfg.treesitter.enable {

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

@ -140,7 +140,7 @@ in {
then ["flutter-tools-patched"]
else ["flutter-tools"];
vim.luaConfigRC.flutter-tools = entryAnywhere ''
vim.pluginRC.flutter-tools = entryAnywhere ''
require('flutter-tools').setup {
lsp = {
color = { -- show the derived colours for dart variables

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

@ -113,7 +113,7 @@ in {
(mkIf cfg.elixir-tools.enable {
vim.startPlugins = ["elixir-tools"];
vim.luaConfigRC.elixir-tools = entryAnywhere ''
vim.pluginRC.elixir-tools = entryAnywhere ''
local elixir-tools = require("elixir")
local elixirls = require("elixir-tools.elixirls")

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

@ -102,7 +102,7 @@ in {
(mkIf cfg.dap.enable {
vim = {
startPlugins = ["nvim-dap-go"];
luaConfigRC.nvim-dap-go = entryAfter ["nvim-dap"] ''
pluginRC.nvim-dap-go = entryAfter ["nvim-dap"] ''
require('dap-go').setup {
delve = {
path = '${getExe cfg.dap.package}',

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

@ -36,7 +36,7 @@ in {
grammars = [cfg.treesitter.package];
};
luaConfigRC.html-autotag = mkIf cfg.treesitter.autotagHtml (entryAnywhere ''
pluginRC.html-autotag = mkIf cfg.treesitter.autotagHtml (entryAnywhere ''
require('nvim-ts-autotag').setup()
'');
};

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

@ -61,7 +61,7 @@ in {
(mkIf cfg.lsp.neodev.enable {
vim.startPlugins = ["neodev-nvim"];
vim.luaConfigRC.neodev = entryBefore ["lua-lsp"] ''
vim.pluginRC.neodev = entryBefore ["lua-lsp"] ''
require("neodev").setup({})
'';
})

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

@ -11,7 +11,6 @@
inherit (lib.strings) optionalString;
inherit (lib.types) enum either listOf package str;
inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.languages) diagnosticsToLua;
@ -176,8 +175,16 @@ in {
config = mkIf cfg.enable (mkMerge [
{
vim.configRC.nix = entryAnywhere ''
autocmd filetype nix setlocal tabstop=2 shiftwidth=2 softtabstop=2
vim.pluginRC.nix = ''
vim.api.nvim_create_autocmd("FileType", {
pattern = "nix",
callback = function(opts)
local bo = vim.bo[opts.buf]
bo.tabstop = 2
bo.shiftwidth = 2
bo.softtabstop = 2
end
})
'';
}

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

@ -102,7 +102,7 @@ in {
startPlugins = ["crates-nvim"];
lsp.null-ls.enable = mkIf cfg.crates.codeActions true;
autocomplete.sources = {"crates" = "[Crates]";};
luaConfigRC.rust-crates = entryAnywhere ''
pluginRC.rust-crates = entryAnywhere ''
require('crates').setup {
null_ls = {
enabled = ${boolToString cfg.crates.codeActions},

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

@ -192,7 +192,7 @@ in {
(mkIf cfg.extensions."ts-error-translator".enable {
vim.startPlugins = ["ts-error-translator"];
vim.luaConfigRC.ts-error-translator = entryAnywhere ''
vim.pluginRC.ts-error-translator = entryAnywhere ''
require("ts-error-translator").setup(${toLuaObject cfg.extensions.ts-error-translator.setupOpts})
'';
})

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

@ -27,7 +27,7 @@ in {
autocomplete.sources = {"nvim_lsp" = "[LSP]";};
luaConfigRC.lsp-setup = ''
pluginRC.lsp-setup = ''
vim.g.formatsave = ${boolToString cfg.formatOnSave};
local attach_keymaps = function(client, bufnr)

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

@ -12,7 +12,7 @@ in {
vim = {
startPlugins = ["nvim-lightbulb"];
luaConfigRC.lightbulb = entryAnywhere ''
pluginRC.lightbulb = entryAnywhere ''
vim.api.nvim_command('autocmd CursorHold,CursorHoldI * lua require\'nvim-lightbulb\'.update_lightbulb()')
-- Enable trouble diagnostics viewer

2
modules/plugins/lsp/lsp-signature/config.nix
View file

@ -20,7 +20,7 @@ in {
handler_opts.border = config.vim.ui.borders.plugins.lsp-signature.style;
};
luaConfigRC.lsp-signature = entryAnywhere ''
pluginRC.lsp-signature = entryAnywhere ''
-- Enable lsp signature viewer
require("lsp_signature").setup(${toLuaObject cfg.lspSignature.setupOpts})
'';

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

@ -17,7 +17,7 @@ in {
startPlugins = ["nvim-lspconfig"];
luaConfigRC.lspconfig = entryAfter ["lsp-setup"] ''
pluginRC.lspconfig = entryAfter ["lsp-setup"] ''
local lspconfig = require('lspconfig')
${
@ -29,7 +29,7 @@ in {
};
}
{
vim.luaConfigRC = mapAttrs (_: v: (entryAfter ["lspconfig"] v)) cfg.lspconfig.sources;
vim.pluginRC = mapAttrs (_: v: (entryAfter ["lspconfig"] v)) cfg.lspconfig.sources;
}
]);
}

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

@ -10,7 +10,7 @@
in {
config = mkIf (cfg.enable && cfg.lspkind.enable) {
vim.startPlugins = ["lspkind"];
vim.luaConfigRC.lspkind = entryAnywhere ''
vim.pluginRC.lspkind = entryAnywhere ''
local lspkind = require'lspkind'
local lspkind_opts = {
mode = '${cfg.lspkind.mode}'

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

@ -10,7 +10,7 @@
in {
config = mkIf (cfg.enable && cfg.lsplines.enable) {
vim.startPlugins = ["lsp-lines"];
vim.luaConfigRC.lsplines = entryAfter ["lspconfig"] ''
vim.pluginRC.lsplines = entryAfter ["lspconfig"] ''
require("lsp_lines").setup()
vim.diagnostic.config({

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

@ -41,7 +41,7 @@ in {
];
};
luaConfigRC.lspsaga = entryAnywhere ''
pluginRC.lspsaga = entryAnywhere ''
require('lspsaga').init_lsp_saga({
${optionalString config.vim.ui.borders.plugins.lspsaga.enable ''
border_style = '${config.vim.ui.borders.plugins.lspsaga.style}',

4
modules/plugins/lsp/null-ls/config.nix
View file

@ -22,7 +22,7 @@ in {
# since it will hook into LSPs to receive information
lsp.enable = true;
luaConfigRC = {
pluginRC = {
# early setup for null-ls
null_ls-setup = entryAnywhere ''
local null_ls = require("null-ls")
@ -46,7 +46,7 @@ in {
};
}
{
vim.luaConfigRC = mapAttrs (_: v: (entryBetween ["null_ls"] ["null_ls-setup"] v)) cfg.null-ls.sources;
vim.pluginRC = mapAttrs (_: v: (entryBetween ["null_ls"] ["null_ls-setup"] v)) cfg.null-ls.sources;
}
]);
}

2
modules/plugins/lsp/nvim-code-action-menu/config.nix
View file

@ -23,7 +23,7 @@ in {
"<leader>c" = "+CodeAction";
};
luaConfigRC.code-action-menu = entryAnywhere ''
pluginRC.code-action-menu = entryAnywhere ''
-- border configuration
vim.g.code_action_menu_window_border = '${config.vim.ui.borders.plugins.code-action-menu.style}'

2
modules/plugins/lsp/nvim-docs-view/config.nix
View file

@ -19,7 +19,7 @@ in {
lsp.enable = true;
startPlugins = ["nvim-docs-view"];
luaConfigRC.nvim-docs-view = entryAnywhere ''
pluginRC.nvim-docs-view = entryAnywhere ''
require("docs-view").setup ${toLuaObject cfg.setupOpts}
'';

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

@ -32,7 +32,7 @@ in {
"<leader>lw" = "Workspace";
};
luaConfigRC.trouble = entryAnywhere ''
pluginRC.trouble = entryAnywhere ''
-- Enable trouble diagnostics viewer
require("trouble").setup {}
'';

2
modules/plugins/minimap/codewindow/config.nix
View file

@ -31,7 +31,7 @@ in {
"<leader>m" = "+Minimap";
};
luaConfigRC.codewindow = entryAnywhere ''
pluginRC.codewindow = entryAnywhere ''
local codewindow = require('codewindow')
codewindow.setup({
exclude_filetypes = { 'NvimTree', 'orgagenda', 'Alpha'},

2
modules/plugins/notes/mind-nvim/config.nix
View file

@ -25,7 +25,7 @@ in {
"<leader>o" = "+Notes";
};
luaConfigRC.mind-nvim = entryAnywhere ''
pluginRC.mind-nvim = entryAnywhere ''
require'mind'.setup()
'';
};

2
modules/plugins/notes/obsidian/config.nix
View file

@ -22,7 +22,7 @@ in {
"<leader>o" = "+Notes";
};
luaConfigRC.obsidian = entryAnywhere ''
pluginRC.obsidian = entryAnywhere ''
require("obsidian").setup(${toLuaObject cfg.setupOpts})
'';
};

2
modules/plugins/notes/orgmode/config.nix
View file

@ -21,7 +21,7 @@ in {
"<leader>o" = "+Notes";
};
luaConfigRC.orgmode = entryAnywhere ''
pluginRC.orgmode = entryAnywhere ''
-- Treesitter configuration
require('nvim-treesitter.configs').setup {

2
modules/plugins/notes/todo-comments/config.nix
View file

@ -24,7 +24,7 @@ in {
(mkIf config.vim.lsp.trouble.enable (mkBinding cfg.mappings.trouble ":TodoTrouble<CR>" mappings.trouble.description))
];
luaConfigRC.todo-comments = ''
pluginRC.todo-comments = ''
require('todo-comments').setup(${toLuaObject cfg.setupOpts})
'';
};

2
modules/plugins/projects/project-nvim/config.nix
View file

@ -14,7 +14,7 @@ in {
"project-nvim"
];
vim.luaConfigRC.project-nvim = entryAnywhere ''
vim.pluginRC.project-nvim = entryAnywhere ''
require('project_nvim').setup(${toLuaObject cfg.setupOpts})
'';
};

2
modules/plugins/rich-presence/neocord/config.nix
View file

@ -12,7 +12,7 @@ in {
config = mkIf cfg.enable {
vim.startPlugins = ["neocord"];
vim.luaConfigRC.neocord = entryAnywhere ''
vim.pluginRC.neocord = entryAnywhere ''
-- Description of each option can be found in https://github.com/IogaMaster/neocord#lua
require("neocord").setup(${toLuaObject cfg.setupOpts})
'';

2
modules/plugins/session/nvim-session-manager/config.nix
View file

@ -28,7 +28,7 @@ in {
# TODO: load_current_dir_session
];
luaConfigRC.nvim-session-manager = entryAnywhere ''
pluginRC.nvim-session-manager = entryAnywhere ''
local Path = require('plenary.path')
local sm = require('session_manager.config')
require('session_manager').setup(${toLuaObject cfg.setupOpts})

2
modules/plugins/spellcheck/vim-dirtytalk/config.nix
View file

@ -14,7 +14,7 @@ in {
# vim-dirtytalk doesn't have any setup
# but we would like to append programming to spelllang
# as soon as possible while the plugin is enabled
luaConfigRC.vim-dirtytalk = entryAfter ["basic"] ''
pluginRC.vim-dirtytalk = entryAfter ["basic"] ''
-- append programming to spelllang
vim.opt.spelllang:append("programming")
'';

2
modules/plugins/statusline/lualine/config.nix
View file

@ -35,7 +35,7 @@ in {
vim = {
startPlugins = ["lualine"];
luaConfigRC.lualine = entryAnywhere ''
pluginRC.lualine = entryAnywhere ''
local lualine = require('lualine')
lualine.setup ${toLuaObject cfg.setupOpts}
'';

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

@ -39,7 +39,7 @@ in {
"<leader>bsi" = "BufferLineSortById";
};
luaConfigRC.nvimBufferline = entryAnywhere ''
pluginRC.nvimBufferline = entryAnywhere ''
require("bufferline").setup(${toLuaObject cfg.setupOpts})
'';
};

4
modules/plugins/terminal/toggleterm/config.nix
View file

@ -23,7 +23,7 @@ in {
maps.normal = mkBinding cfg.mappings.open "<Cmd>execute v:count . \"ToggleTerm\"<CR>" "Toggle terminal";
luaConfigRC.toggleterm = entryAnywhere ''
pluginRC.toggleterm = entryAnywhere ''
require("toggleterm").setup(${toLuaObject cfg.setupOpts})
'';
};
@ -35,7 +35,7 @@ in {
vim.startPlugins = optionals (cfg.lazygit.package != null) [
cfg.lazygit.package
];
vim.luaConfigRC.toggleterm-lazygit = entryAfter ["toggleterm"] ''
vim.pluginRC.toggleterm-lazygit = entryAfter ["toggleterm"] ''
local terminal = require 'toggleterm.terminal'
local lazygit = terminal.Terminal:new({
cmd = '${

0
modules/plugins/theme/supported_themes.nix → modules/plugins/theme/supported-themes.nix
View file

16
modules/plugins/theme/theme.nix
View file

@ -7,10 +7,10 @@
inherit (lib.attrsets) attrNames;
inherit (lib.types) bool lines enum;
inherit (lib.modules) mkIf;
inherit (lib.nvim.dag) entryBefore;
inherit (lib.nvim.dag) entryAfter;
cfg = config.vim.theme;
supported_themes = import ./supported_themes.nix {
supportedThemes = import ./supported-themes.nix {
inherit lib config;
};
in {
@ -21,12 +21,12 @@ in {
};
name = mkOption {
type = enum (attrNames supported_themes);
description = "Supported themes can be found in `supported_themes.nix`";
type = enum (attrNames supportedThemes);
description = "Supported themes can be found in `supportedThemes.nix`";
};
style = mkOption {
type = enum supported_themes.${cfg.name}.styles;
type = enum supportedThemes.${cfg.name}.styles;
description = "Specific style for theme if it supports it";
};
@ -45,11 +45,9 @@ in {
config = mkIf cfg.enable {
vim = {
startPlugins = [cfg.name];
configRC.theme = entryBefore ["luaScript"] ''
lua << EOF
luaConfigRC.theme = entryAfter ["basic"] ''
${cfg.extraConfig}
${supported_themes.${cfg.name}.setup (with cfg; {inherit style transparent;})}
EOF
${supportedThemes.${cfg.name}.setup {inherit (cfg) style transparent;}}
'';
};
};

18
modules/plugins/treesitter/config.nix
View file

@ -37,18 +37,18 @@ in {
};
# For some reason treesitter highlighting does not work on start if this is set before syntax on
configRC.treesitter-fold = mkIf cfg.fold (entryBefore ["basic"] ''
" This is required by treesitter-context to handle folds
set foldmethod=expr
set foldexpr=nvim_treesitter#foldexpr()
pluginRC.treesitter-fold = mkIf cfg.fold (entryBefore ["basic"] ''
-- This is required by treesitter-context to handle folds
vim.o.foldmethod = "expr"
vim.o.foldexpr = "nvim_treesitter#foldexpr()"
" This is optional, but is set rather as a sane default.
" If unset, opened files will be folded by automatically as
" the files are opened
set nofoldenable
-- This is optional, but is set rather as a sane default.
-- If unset, opened files will be folded by automatically as
-- the files are opened
vim.o.foldenable = false
'');
luaConfigRC.treesitter = entryAfter ["basic"] ''
pluginRC.treesitter = entryAfter ["basic"] ''
require('nvim-treesitter.configs').setup {
-- Disable imperative treesitter options that would attempt to fetch
-- grammars into the read-only Nix store. To add additional grammars here

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

@ -16,7 +16,7 @@ in {
# set up treesitter-context after Treesitter. The ordering
# should not matter, but there is no harm in doing this
luaConfigRC.treesitter-context = entryAfter ["treesitter"] ''
pluginRC.treesitter-context = entryAfter ["treesitter"] ''
require("treesitter-context").setup(${toLuaObject cfg.setupOpts})
'';
};

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

@ -78,7 +78,7 @@ in {
};
};
vim.luaConfigRC.breadcrumbs = entryAfter ["lspconfig"] ''
vim.pluginRC.breadcrumbs = entryAfter ["lspconfig"] ''
${optionalString (cfg.source == "nvim-navic") ''
local navic = require("nvim-navic")

2
modules/plugins/ui/colorizer/config.nix
View file

@ -14,7 +14,7 @@ in {
"nvim-colorizer-lua"
];
vim.luaConfigRC.colorizer = entryAnywhere ''
vim.pluginRC.colorizer = entryAnywhere ''
require('colorizer').setup(${toLuaObject cfg.setupOpts})
'';
};

2
modules/plugins/ui/illuminate/config.nix
View file

@ -11,7 +11,7 @@ in {
config = mkIf cfg.enable {
vim.startPlugins = ["vim-illuminate"];
vim.luaConfigRC.vim-illuminate = entryAnywhere ''
vim.pluginRC.vim-illuminate = entryAnywhere ''
require('illuminate').configure({
filetypes_denylist = {
'dirvish',

2
modules/plugins/ui/modes/config.nix
View file

@ -14,7 +14,7 @@ in {
"modes-nvim"
];
vim.luaConfigRC.modes-nvim = entryAnywhere ''
vim.pluginRC.modes-nvim = entryAnywhere ''
require('modes').setup(${toLuaObject cfg.setupOpts})
'';
};

2
modules/plugins/ui/noice/config.nix
View file

@ -23,7 +23,7 @@ in {
treesitter.grammars = optionals tscfg.addDefaultGrammars defaultGrammars;
luaConfigRC.noice-nvim = entryAnywhere ''
pluginRC.noice-nvim = entryAnywhere ''
require("noice").setup(${toLuaObject cfg.setupOpts})
'';
};

2
modules/plugins/ui/notifications/nvim-notify/config.nix
View file

@ -13,7 +13,7 @@ in {
vim = {
startPlugins = ["nvim-notify"];
luaConfigRC.nvim-notify = entryAnywhere ''
pluginRC.nvim-notify = entryAnywhere ''
require('notify').setup(${toLuaObject cfg.setupOpts})
-- required to fix offset_encoding errors

2
modules/plugins/ui/smartcolumn/config.nix
View file

@ -13,7 +13,7 @@ in {
vim = {
startPlugins = ["smartcolumn"];
luaConfigRC.smartcolumn = entryAnywhere ''
pluginRC.smartcolumn = entryAnywhere ''
require("smartcolumn").setup(${toLuaObject cfg.setupOpts})
'';
};

2
modules/plugins/utility/binds/cheatsheet/config.nix
View file

@ -11,7 +11,7 @@ in {
config = mkIf cfg.enable {
vim.startPlugins = ["cheatsheet-nvim"];
vim.luaConfigRC.cheaetsheet-nvim = entryAnywhere ''
vim.pluginRC.cheaetsheet-nvim = entryAnywhere ''
require('cheatsheet').setup({})
'';
};

2
modules/plugins/utility/binds/which-key/config.nix
View file

@ -13,7 +13,7 @@ in {
config = mkIf cfg.enable {
vim.startPlugins = ["which-key"];
vim.luaConfigRC.whichkey = entryAnywhere ''
vim.pluginRC.whichkey = entryAnywhere ''
local wk = require("which-key")
wk.setup ({
key_labels = {

2
modules/plugins/utility/ccc/config.nix
View file

@ -13,7 +13,7 @@ in {
"ccc"
];
vim.luaConfigRC.ccc = entryAnywhere ''
vim.pluginRC.ccc = entryAnywhere ''
local ccc = require("ccc")
ccc.setup {
highlighter = {

2
modules/plugins/utility/gestures/gesture-nvim/config.nix
View file

@ -25,7 +25,7 @@ in {
})
];
vim.luaConfigRC.gesture-nvim = entryAnywhere ''
vim.pluginRC.gesture-nvim = entryAnywhere ''
vim.opt.mouse = "a"
local gesture = require("gesture")

2
modules/plugins/utility/icon-picker/config.nix
View file

@ -14,7 +14,7 @@ in {
"dressing-nvim"
];
vim.luaConfigRC.icon-picker = entryAnywhere ''
vim.pluginRC.icon-picker = entryAnywhere ''
require("icon-picker").setup({
disable_legacy_commands = true
})

2
modules/plugins/utility/images/image-nvim/config.nix
View file

@ -19,7 +19,7 @@ in {
"magick"
];
luaConfigRC.image-nvim = entryAnywhere ''
pluginRC.image-nvim = entryAnywhere ''
require("image").setup(
${toLuaObject cfg.setupOpts}
)

2
modules/plugins/utility/motion/hop/config.nix
View file

@ -19,7 +19,7 @@ in {
vim.maps.normal = mkSetBinding mappings.hop "<cmd> HopPattern<CR>";
vim.luaConfigRC.hop-nvim = entryAnywhere ''
vim.pluginRC.hop-nvim = entryAnywhere ''
require('hop').setup()
'';
};

2
modules/plugins/utility/motion/leap/config.nix
View file

@ -37,7 +37,7 @@ in {
(mkBinding cfg.mappings.leapFromWindow "<Plug>(leap-from-window)" "Leap from window")
];
vim.luaConfigRC.leap-nvim = entryAnywhere ''
vim.pluginRC.leap-nvim = entryAnywhere ''
require('leap').opts = {
max_phase_one_targets = nil,
highlight_unlabeled_phase_one_targets = false,

2
modules/plugins/utility/preview/glow/config.nix
View file

@ -25,7 +25,7 @@ in {
"<leader>pm" = "+Preview Markdown";
};
vim.luaConfigRC.glow = entryAnywhere ''
vim.pluginRC.glow = entryAnywhere ''
require('glow').setup({
glow_path = "${pkgs.glow}/bin/glow"
});

24
modules/plugins/utility/preview/markdown-preview/config.nix
View file

@ -4,25 +4,23 @@
lib,
...
}: let
inherit (lib.strings) optionalString stringLength concatMapStringsSep;
inherit (lib.strings) stringLength concatMapStringsSep;
inherit (lib.modules) mkIf;
inherit (lib.nvim.vim) mkVimBool;
inherit (lib.nvim.dag) entryAnywhere;
cfg = config.vim.utility.preview.markdownPreview;
in {
config = mkIf cfg.enable {
vim.startPlugins = [pkgs.vimPlugins.markdown-preview-nvim];
vim.configRC.markdown-preview = entryAnywhere ''
let g:mkdp_auto_start = ${mkVimBool cfg.autoStart}
let g:mkdp_auto_close = ${mkVimBool cfg.autoClose}
let g:mkdp_refresh_slow = ${mkVimBool cfg.lazyRefresh}
let g:mkdp_filetypes = [${concatMapStringsSep ", " (x: "'" + x + "'") cfg.filetypes}]
let g:mkdp_command_for_global = ${mkVimBool cfg.alwaysAllowPreview}
let g:mkdp_open_to_the_world = ${mkVimBool cfg.broadcastServer}
${optionalString (stringLength cfg.customIP > 0) "let g:mkdp_open_ip = '${cfg.customIP}'"}
${optionalString (stringLength cfg.customPort > 0) "let g:mkdp_port = '${cfg.customPort}'"}
'';
vim.globals = {
mkdp_auto_start = cfg.autoStart;
mkdp_auto_close = cfg.autoClose;
mkdp_refresh_slow = cfg.lazyRefresh;
mkdp_filetypes = [(concatMapStringsSep ", " (x: "'" + x + "'") cfg.filetypes)];
mkdp_command_for_global = cfg.alwaysAllowPreview;
mkdp_open_to_the_world = cfg.broadcastServer;
mkdp_open_ip = mkIf (stringLength cfg.customIP > 0) cfg.customIP;
mkdp_port = mkIf (stringLength cfg.customPort > 0) cfg.customPort;
};
};
}

2
modules/plugins/utility/surround/config.nix
View file

@ -18,7 +18,7 @@ in {
"nvim-surround"
];
luaConfigRC.surround = entryAnywhere ''
pluginRC.surround = entryAnywhere ''
require('nvim-surround').setup()
'';

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

@ -65,7 +65,7 @@ in {
"<leader>fvc" = "Commits";
};
vim.luaConfigRC.telescope = entryAnywhere ''
vim.pluginRC.telescope = entryAnywhere ''
local telescope = require('telescope')
telescope.setup(${toLuaObject cfg.setupOpts})

13
modules/plugins/utility/wakatime/config.nix
View file

@ -5,21 +5,14 @@
...
}: let
inherit (lib.modules) mkIf;
inherit (lib.nvim.dag) entryAnywhere;
cfg = config.vim.utility.vim-wakatime;
in {
config = mkIf cfg.enable {
vim.startPlugins = [
pkgs.vimPlugins.vim-wakatime
];
vim.startPlugins = [pkgs.vimPlugins.vim-wakatime];
vim.configRC.vim-wakatime = entryAnywhere ''
${
if cfg.cli-package == null
then ""
else ''let g:wakatime_CLIPath = "${cfg.cli-package}"''
}
vim.pluginRC.vim-wakatime = mkIf (cfg.cli-package != null) ''
vim.g.wakatime_CLIPath = "${cfg.cli-package}"
'';
};
}

12
modules/plugins/visuals/config.nix
View file

@ -14,14 +14,14 @@ in {
config = mkIf cfg.enable (mkMerge [
(mkIf cfg.indentBlankline.enable {
vim.startPlugins = ["indent-blankline"];
vim.luaConfigRC.indent-blankline = entryAnywhere ''
vim.pluginRC.indent-blankline = entryAnywhere ''
require("ibl").setup(${toLuaObject cfg.indentBlankline.setupOpts})
'';
})
(mkIf cfg.cursorline.enable {
vim.startPlugins = ["nvim-cursorline"];
vim.luaConfigRC.cursorline = entryAnywhere ''
vim.pluginRC.cursorline = entryAnywhere ''
require('nvim-cursorline').setup {
cursorline = {
timeout = ${toString cfg.cursorline.lineTimeout},
@ -37,7 +37,7 @@ in {
(mkIf cfg.scrollBar.enable {
vim.startPlugins = ["scrollbar-nvim"];
vim.luaConfigRC.scrollBar = entryAnywhere ''
vim.pluginRC.scrollBar = entryAnywhere ''
require('scrollbar').setup{
excluded_filetypes = {
'prompt',
@ -56,7 +56,7 @@ in {
(mkIf cfg.smoothScroll.enable {
vim.startPlugins = ["cinnamon-nvim"];
vim.luaConfigRC.smoothScroll = entryAnywhere ''
vim.pluginRC.smoothScroll = entryAnywhere ''
require('cinnamon').setup()
'';
})
@ -66,7 +66,7 @@ in {
vim.maps.normal = mkBinding cfg.cellularAutomaton.mappings.makeItRain "<cmd>CellularAutomaton make_it_rain<CR>" "Make it rain";
vim.luaConfigRC.cellularAUtomaton = entryAnywhere ''
vim.pluginRC.cellularAUtomaton = entryAnywhere ''
local config = {
fps = 50,
name = 'slide',
@ -94,7 +94,7 @@ in {
(mkIf cfg.highlight-undo.enable {
vim.startPlugins = ["highlight-undo"];
vim.luaConfigRC.highlight-undo = entryAnywhere ''
vim.pluginRC.highlight-undo = entryAnywhere ''
require('highlight-undo').setup({
duration = ${toString cfg.highlight-undo.duration},
highlight_for_count = ${boolToString cfg.highlight-undo.highlightForCount},

2
modules/plugins/visuals/fidget/config.nix
View file

@ -12,7 +12,7 @@ in {
config = mkIf cfg.enable {
vim.startPlugins = ["fidget-nvim"];
vim.luaConfigRC.fidget-nvim = entryAnywhere ''
vim.pluginRC.fidget-nvim = entryAnywhere ''
require'fidget'.setup(${toLuaObject cfg.setupOpts})
'';
};

126
modules/wrapper/rc/config.nix
View file

@ -3,17 +3,16 @@
lib,
...
}: let
inherit (builtins) map mapAttrs toJSON filter;
inherit (builtins) map mapAttrs filter;
inherit (lib.options) mkOption;
inherit (lib.attrsets) filterAttrs getAttrs attrValues attrNames;
inherit (lib.strings) isString concatLines concatMapStringsSep;
inherit (lib.strings) concatLines concatMapStringsSep;
inherit (lib.misc) mapAttrsFlatten;
inherit (lib.trivial) showWarnings;
inherit (lib.types) str nullOr;
inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.dag) entryAnywhere entryAfter topoSort mkLuarcSection mkVimrcSection;
inherit (lib.nvim.lua) toLuaObject wrapLuaConfig;
inherit (lib.nvim.vim) valToVim;
inherit (lib.nvim.dag) entryAfter mkLuarcSection resolveDag entryAnywhere;
inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.config) mkBool;
cfg = config.vim;
@ -82,11 +81,23 @@
maps);
in {
config = let
filterNonNull = mappings: filterAttrs (_name: value: value != null) mappings;
filterNonNull = attrs: filterAttrs (_: value: value != null) attrs;
globalsScript =
mapAttrsFlatten (name: value: "let g:${name}=${valToVim value}")
mapAttrsFlatten (name: value: "vim.g.${name} = ${toLuaObject value}")
(filterNonNull cfg.globals);
extraPluginConfigs = resolveDag {
name = "extra plugin configs";
dag = mapAttrs (_: value: entryAfter value.after value.setup) cfg.extraPlugins;
mapResult = result: concatLines (map mkLuarcSection result);
};
pluginConfigs = resolveDag {
name = "plugin configs";
dag = cfg.pluginRC;
mapResult = result: concatLines (map mkLuarcSection result);
};
toLuaBindings = mode: maps:
map (value: ''
vim.keymap.set(${toLuaObject mode}, ${toLuaObject value.key}, ${toLuaObject value.action}, ${toLuaObject value.config})
@ -105,77 +116,6 @@ in {
omap = toLuaBindings "o" config.vim.maps.operator;
icmap = toLuaBindings "ic" config.vim.maps.insertCommand;
resolveDag = {
name,
dag,
mapResult,
}: let
# When the value is a string, default it to dag.entryAnywhere
finalDag = mapAttrs (_: value:
if isString value
then entryAnywhere value
else value)
dag;
sortedDag = topoSort finalDag;
result =
if sortedDag ? result
then mapResult sortedDag.result
else abort ("Dependency cycle in ${name}: " + toJSON sortedDag);
in
result;
in {
vim = {
configRC = {
globalsScript = entryAnywhere (concatLines globalsScript);
# Call additional lua files with :luafile in Vimscript
# section of the configuration, only after
# the luaScript section has been evaluated
extraLuaFiles = let
callLuaFiles = map (file: "luafile ${file}") cfg.extraLuaFiles;
in
entryAfter ["globalScript"] (concatLines callLuaFiles);
# wrap the lua config in a lua block
# using the wrapLuaConfic function from the lib
luaScript = let
mapResult = result: (wrapLuaConfig {
luaBefore = "${cfg.luaConfigPre}";
luaConfig = concatLines (map mkLuarcSection result);
luaAfter = "${cfg.luaConfigPost}";
});
luaConfig = resolveDag {
name = "lua config script";
dag = cfg.luaConfigRC;
inherit mapResult;
};
in
entryAnywhere luaConfig;
extraPluginConfigs = let
mapResult = result: (wrapLuaConfig {
luaConfig = concatLines (map mkLuarcSection result);
});
extraPluginsDag = mapAttrs (_: {
after,
setup,
...
}:
entryAfter after setup)
cfg.extraPlugins;
pluginConfig = resolveDag {
name = "extra plugins config";
dag = extraPluginsDag;
inherit mapResult;
};
in
entryAfter ["luaScript"] pluginConfig;
# This is probably not the right way to set the config. I'm not sure how it should look like.
mappings = let
maps = [
nmap
imap
@ -189,12 +129,18 @@ in {
icmap
allmap
];
mapConfig = wrapLuaConfig {luaConfig = concatLines (map concatLines maps);};
in
entryAfter ["globalsScript"] mapConfig;
mappings = concatLines (map concatLines maps);
in {
vim = {
luaConfigRC = {
globalsScript = entryAnywhere (concatLines globalsScript);
# basic, theme
pluginConfigs = entryAfter ["theme"] pluginConfigs;
extraPluginConfigs = entryAfter ["pluginConfigs"] extraPluginConfigs;
mappings = entryAfter ["extraPluginConfigs"] mappings;
};
builtConfigRC = let
builtLuaConfigRC = let
# Catch assertions and warnings
# and throw for each failed assertion. If no assertions are found, show warnings.
failedAssertions = map (x: x.message) (filter (x: !x.assertion) config.assertions);
@ -203,14 +149,18 @@ in {
then throw "\nFailed assertions:\n${concatMapStringsSep "\n" (x: "- ${x}") failedAssertions}"
else showWarnings config.warnings;
mapResult = result: concatMapStringsSep "\n" mkVimrcSection result;
vimConfig = resolveDag {
name = "vim config script";
dag = cfg.configRC;
inherit mapResult;
luaConfig = resolveDag {
name = "lua config script";
dag = cfg.luaConfigRC;
mapResult = result:
concatLines [
cfg.luaConfigPre
(concatMapStringsSep "\n" mkLuarcSection result)
cfg.luaConfigPost
];
};
in
baseSystemAssertWarn vimConfig;
baseSystemAssertWarn luaConfig;
};
};
}

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

@ -3,13 +3,25 @@
lib,
...
}: let
inherit (lib.modules) mkRemovedOptionModule;
inherit (lib.options) mkOption mkEnableOption literalMD literalExpression;
inherit (lib.strings) optionalString;
inherit (lib.types) str oneOf attrs lines listOf either path bool;
inherit (lib.types) str attrs lines listOf either path bool;
inherit (lib.nvim.types) dagOf;
inherit (lib.nvim.lua) listToLuaTable;
cfg = config.vim;
in {
imports = [
(mkRemovedOptionModule ["vim" "configRC"] ''
Please migrate your configRC sections to Neovim's Lua format, and
add them to luaConfigRC.
See the v0.7 release notes for more information on how to migrate
your existing configurations.
'')
];
options.vim = {
enableLuaLoader = mkEnableOption ''
the experimental Lua module loader to speed up the start up process
@ -120,35 +132,20 @@ in {
description = ''
An attribute set containing global variable values
for storing vim variables as early as possible. If
populated, this soption will set vim variables in the
built configRC as the first item.
populated, this option will set vim variables in the
built luaConfigRC as the first item.
E.g. {foo = "bar"} will set `g:foo` to "bar" where
E.g. {foo = "bar"} will set `vim.g.foo` to "bar" where
the type of `bar` in the resulting vimscript will be
infered from the type of the value in the `{name = value}`
pair.
'';
};
configRC = mkOption {
type = oneOf [(dagOf lines) str];
pluginRC = mkOption {
type = either (dagOf lines) str;
default = {};
description = ''
Contents of vimrc, either as a string or a DAG.
If this option is passed as a DAG, it will be resolved
according to the DAG resolution rules (e.g. entryBefore
or entryAfter) as per the **nvf** extended library.
'';
example = literalMD ''
```vim
" Set the tab size to 4 spaces
set tabstop=4
set shiftwidth=4
set expandtab
```
'';
description = "The DAG used to configure plugins. If a string is passed, entryAnywhere is automatically applied.";
};
luaConfigPre = mkOption {
@ -211,7 +208,7 @@ in {
};
luaConfigRC = mkOption {
type = oneOf [(dagOf lines) str];
type = either (dagOf lines) str;
default = {};
description = ''
Lua configuration, either as a string or a DAG.
@ -245,10 +242,10 @@ in {
'';
};
builtConfigRC = mkOption {
builtLuaConfigRC = mkOption {
internal = true;
type = lines;
description = "The built config for neovim after resolving the DAG";
description = "The built lua config for neovim after resolving the DAG";
};
};
}