Merge 4c3d2839a7 into bce45d4eeb

* wrapper/rc: add `vim.options`

Translates an attribute set of values into `vim.o` values in a key-value format.

* docs: document addition of optionsScript

* wrapper/rc: don't filter null values in {options,global}Script

* wrapper/rc: add examples to vim.options & vim.globals; wording

docs/manual/configuring/dag-entries.md

@@ -5,16 +5,19 @@ 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):
+## `vim.luaConfigRC` (top-level DAG) {#ch-vim-luaconfigrc}
 
 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` (this is simply placed before `pluginConfigs`, meaning that surrounding entries don't depend on it) - used to set up the theme, which has to be done before other plugins
+4. `optionsScript` - used to set options defined in `vim.o`
-5. `pluginConfigs` - the result of the nested `vim.pluginRC` (internal option,
+5. `theme` (this is simply placed before `pluginConfigs`, meaning that
-   see the [Custom Plugins](/index.xhtml#ch-custom-plugins) page for adding your own
+   surrounding entries don't depend on it) - used to set up the theme, which has
-   plugins) DAG, used to set up internal plugins
+   to be done before other plugins
-6. `extraPluginConfigs` - the result of `vim.extraPlugins`, which is not a
+6. `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
+7. `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`
+8. `mappings` - the result of `vim.maps`

docs/release-notes/rl-0.7.md

@@ -187,6 +187,12 @@ everyone.
 - Add [python-lsp-server](https://github.com/python-lsp/python-lsp-server) as an
   additional Python LSP server.
 
+- Add [](#opt-vim.options) to set `vim.o` values in in your nvf configuration
+  without using additional Lua. See option documentation for more details.
+
+- Add [](#opt-vim.dashboard.dashboard-nvim.setupOpts) to allow user
+  configuration for [dashboard.nvim](https://github.com/nvimdev/dashboard-nvim)
+
 [ppenguin](https://github.com/ppenguin):
 
 - Telescope:

modules/plugins/dashboard/dashboard-nvim/config.nix

@@ -5,16 +5,17 @@
 }: let
   inherit (lib.modules) mkIf;
   inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.dashboard.dashboard-nvim;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = [
+    vim = {
-      "dashboard-nvim"
+      startPlugins = ["dashboard-nvim"];
-    ];
 
-    vim.pluginRC.dashboard-nvim = entryAnywhere ''
+      pluginRC.dashboard-nvim = entryAnywhere ''
-      require("dashboard").setup{}
+        require("dashboard").setup(${toLuaObject cfg.setupOpts})
       '';
     };
+  };
 }

modules/plugins/dashboard/dashboard-nvim/dashboard-nvim.nix

@@ -1,7 +1,9 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption;
+  inherit (lib.nvim.types) mkPluginSetupOption;
 in {
   options.vim.dashboard.dashboard-nvim = {
     enable = mkEnableOption "Fancy and Blazing Fast start screen plugin of neovim [dashboard.nvim]";
+    setupOpts = mkPluginSetupOption "dashboard.nvim" {};
   };
 }

modules/wrapper/rc/config.nix

@@ -80,10 +80,11 @@
       maps);
 in {
   config = let
-    filterNonNull = attrs: filterAttrs (_: value: value != null) attrs;
     globalsScript =
-      mapAttrsToList (name: value: "vim.g.${name} = ${toLuaObject value}")
+      mapAttrsToList (name: value: "vim.g.${name} = ${toLuaObject value}") cfg.globals;
-      (filterNonNull cfg.globals);
+
+    optionsScript =
+      mapAttrsToList (name: value: "vim.o.${name} = ${toLuaObject value}") cfg.options;
 
     extraPluginConfigs = resolveDag {
       name = "extra plugin configs";
@@ -132,9 +133,12 @@ in {
   in {
     vim = {
       luaConfigRC = {
+        # `vim.g` and `vim.o`
         globalsScript = entryAnywhere (concatLines globalsScript);
-        # basic
+        optionsScript = entryAfter ["basic"] (concatLines optionsScript);
-        pluginConfigs = entryAfter ["basic"] pluginConfigs;
+
+        # Basic
+        pluginConfigs = entryAfter ["optionsScript"] pluginConfigs;
         extraPluginConfigs = entryAfter ["pluginConfigs"] extraPluginConfigs;
         mappings = entryAfter ["extraPluginConfigs"] mappings;
       };

modules/wrapper/rc/options.nix

@@ -129,16 +129,38 @@ in {
     globals = mkOption {
       type = attrs;
       default = {};
+      example = {"some_variable" = 42;};
       description = ''
         An attribute set containing global variable values
         for storing vim variables as early as possible. If
         populated, this option will set vim variables in the
         built luaConfigRC as the first item.
 
-        E.g. {foo = "bar"} will set `vim.g.foo` to "bar" where
+        ::: {.note}
-        the type of `bar` in the resulting vimscript will be
+        `{foo = "bar";}` will set `vim.g.foo` to "bar", where
-        infered from the type of the value in the `{name = value}`
+        the type of `bar` in the resulting Lua value will be
-        pair.
+        inferred from the type of the value in the `{name = value;}`
+        pair passed to the option.
+        :::
+      '';
+    };
+
+    options = mkOption {
+      type = attrs;
+      default = {};
+      example = {visualbell = true;};
+      description = ''
+        An attribute set containing vim options to be set
+        as early as possible. If populated, this option will
+        set vim options in the built luaConfigRC after `basic`
+        and before `pluginConfigs` DAG entries.
+
+        ::: {.note}
+        `{foo = "bar";}` will set `vim.o.foo` to "bar", where
+        the type of `bar` in the resulting Lua value will be
+        inferred from the type of the value in the`{name = value;}`
+        pair passed to the option.
+        :::
       '';
     };