.github/typos.toml

@@ -9,6 +9,5 @@ default.extend-ignore-words-re = [
   "edn",
   "esy",
   "BA", # somehow "BANanaD3V" is valid, but BA is not...
-  "Emac"
 ]
 

docs/release-notes/rl-0.7.md

@@ -170,7 +170,7 @@ The changes are, in no particular order:
 
 - Add [ocaml-lsp] support
 
-- Fix misspelled "Emacs"
+- Fix "Emac" typo
 
 - Add [new-file-template.nvim] to automatically fill new file contents using
   templates

docs/release-notes/rl-0.8.md

@@ -569,7 +569,8 @@
 [typst-concealer]: https://github.com/PartyWumpus/typst-concealer
 
 - Add inline typst concealing support under `vim.languages.typst` using
-  [typst-concealer]. [simon-wg](https://github.com/simon-wg):
+  [typst-concealer].
+[simon-wg](https://github.com/simon-wg):
 
 - Update `python` language module to use correct lsp binary.
 - Fix `python` pyright and basedpyright language servers not using default on

lib/lua.nix

@@ -1,52 +1,92 @@
 # Helpers for converting values to lua
 {lib}: let
+  inherit (builtins) hasAttr head throw typeOf isList isAttrs isBool isInt isString isPath isFloat toJSON;
+  inherit (lib.attrsets) mapAttrsToList filterAttrs;
+  inherit (lib.strings) concatStringsSep concatMapStringsSep stringToCharacters;
+  inherit (lib.trivial) boolToString warn;
+in rec {
+  # Convert a null value to lua's nil
+  nullString = value:
+    if value == null
+    then "nil"
+    else "'${value}'";
+
+  # convert an expression to lua
+  expToLua = exp:
+    if isList exp
+    then listToLuaTable exp # if list, convert to lua table
+    else if isAttrs exp
+    then attrsetToLuaTable exp # if attrs, convert to table
+    else if isBool exp
+    then boolToString exp # if bool, convert to string
+    else if isInt exp
+    then toString exp # if int, convert to string
+    else if exp == null
+    then "nil"
+    else (toJSON exp); # otherwise jsonify the value and print as is
+
+  # convert list to a lua table
+  listToLuaTable = list:
+    "{ " + (concatStringsSep ", " (map expToLua list)) + " }";
+
+  # convert attrset to a lua table
+  attrsetToLuaTable = attrset:
+    "{ "
+    + (
+      concatStringsSep ", "
+      (
+        mapAttrsToList (
+          name: value:
+            name
+            + " = "
+            + (expToLua value)
+        )
+        attrset
+      )
+    )
+    + " }";
+  # Convert a list of lua expressions to a lua table. The difference to listToLuaTable is that the elements here are expected to be lua expressions already, whereas listToLuaTable converts from nix types to lua first
+  luaTable = items: ''{${concatStringsSep "," items}}'';
+
   isLuaInline = object: (object._type or null) == "lua-inline";
 
   toLuaObject = args:
-    {
+    if isAttrs args
-      int = toString args;
+    then
-      float = toString args;
+      if isLuaInline args
-
+      then args.expr
-      # escapes \ and quotes
+      else if hasAttr "__empty" args
-      string = builtins.toJSON args;
+      then
-      path = builtins.toJSON args;
+        warn ''
-
+          Using `__empty` to define an empty lua table is deprecated. Use an empty attrset instead.
-      bool = lib.boolToString args;
+        '' "{ }"
-      null = "nil";
+      else
-
+        "{"
-      list = "{${lib.concatMapStringsSep ",\n" toLuaObject args}}";
+        + (concatStringsSep ","
-
+          (mapAttrsToList
-      set =
+            (n: v:
-        if lib.isDerivation args
+              if head (stringToCharacters n) == "@"
-        then ''"${args}"''
+              then toLuaObject v
-        else if isLuaInline args
+              else "[${toLuaObject n}] = " + (toLuaObject v))
-        then args.expr
+            (filterAttrs
-        else "{${
+              (_: v: v != null)
-          lib.pipe args [
+              args)))
-            (lib.filterAttrs (_: v: v != null))
+        + "}"
-            (builtins.mapAttrs (
+    else if isList args
-              n: v:
+    then "{" + concatMapStringsSep "," toLuaObject args + "}"
-                if lib.hasPrefix "@" n
+    else if isString args
-                then toLuaObject v
+    then
-                else "[${toLuaObject n}] = ${toLuaObject v}"
+      # This should be enough!
-            ))
+      toJSON args
-            builtins.attrValues
+    else if isPath args
-            (lib.concatStringsSep ",\n")
+    then toJSON (toString args)
-          ]
+    else if isBool args
-        }}";
+    then "${boolToString args}"
-    }
+    else if isFloat args
-    .${
+    then "${toString args}"
-      builtins.typeOf args
+    else if isInt args
-    }
+    then "${toString args}"
-    or (builtins.throw "Could not convert object of type `${builtins.typeOf args}` to lua object");
+    else if (args == null)
-in
+    then "nil"
-  {
+    else throw "could not convert object of type `${typeOf args}` to lua object";
-    inherit isLuaInline toLuaObject;
+}
-    luaTable = x: (toLuaObject (map lib.mkLuaInline x));
-  }
-  // lib.genAttrs [
-    "nullString"
-    "expToLua"
-    "listToLuaTable"
-    "attrsetToLuaTable"
-  ] (name: lib.warn "${name} is deprecated use toLuaObject instead" toLuaObject)

modules/neovim/init/spellcheck.nix

@@ -9,7 +9,7 @@
   inherit (lib.strings) concatLines concatStringsSep optionalString;
   inherit (lib.attrsets) mapAttrsToList;
   inherit (lib.types) listOf str attrsOf;
-  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.lua) listToLuaTable;
   inherit (lib.nvim.dag) entryAfter;
 
   cfg = config.vim.spellcheck;
@@ -152,7 +152,7 @@ in {
         vim.api.nvim_create_augroup("nvf_autocmds", {clear = false})
         vim.api.nvim_create_autocmd({ "FileType" }, {
           group = "nvf_autocmds",
-          pattern = ${toLuaObject cfg.ignoredFiletypes},
+          pattern = ${listToLuaTable cfg.ignoredFiletypes},
           callback = function()
             vim.opt_local.spell = false
           end,

modules/plugins/assistant/copilot/copilot.nix

@@ -93,7 +93,7 @@ in {
         accept = mkOption {
           type = nullOr str;
           default = "<M-l>";
-          description = "Accept suggestion";
+          description = "Accept suggetion";
         };
 
         acceptWord = mkOption {

modules/plugins/languages/haskell.nix

@@ -11,10 +11,11 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.dag) entryAfter;
-  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.lua) expToLua;
   inherit (lib.meta) getExe';
   inherit (lib.generators) mkLuaInline;
   inherit (pkgs) haskellPackages;
+  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.languages.haskell;
 
@@ -119,7 +120,7 @@ in {
               dap = {
                 cmd = ${
                 if isList cfg.dap.package
-                then toLuaObject cfg.dap.package
+                then expToLua cfg.dap.package
                 else ''{"${cfg.dap.package}/bin/haskell-debug-adapter"}''
               },
               },

modules/plugins/languages/rust.nix

@@ -13,7 +13,7 @@
   inherit (lib.lists) isList;
   inherit (lib.types) bool package str listOf either enum;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.dag) entryAfter entryAnywhere;
 
   cfg = config.vim.languages.rust;
@@ -153,7 +153,7 @@ in {
             server = {
               cmd = ${
               if isList cfg.lsp.package
-              then toLuaObject cfg.lsp.package
+              then expToLua cfg.lsp.package
               else ''{"${cfg.lsp.package}/bin/rust-analyzer"}''
             },
               default_settings = {

modules/wrapper/build/config.nix

@@ -130,9 +130,6 @@
       # In systems where we only have a package and no module, this can be used
       # to access the built init.lua
       initLua = dummyInit;
-
-      mnwConfig = neovim-wrapped.passthru.config;
-      mnwConfigDir = neovim-wrapped.passthru.configDir;
     };
 
     meta =