languages: convert language modules M-Z

modules/plugins/languages/markdown.nix

@@ -4,14 +4,14 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) attrNames isList;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.lists) isList;
   inherit (lib.types) bool enum either package listOf str;
-  inherit (lib.nvim.lua) expToLua toLuaObject;
+  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.types) diagnostics mkGrammarOption mkPluginSetupOption;
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.languages.markdown;
@@ -19,33 +19,23 @@
   servers = {
     marksman = {
       package = pkgs.marksman;
-      lspConfig = ''
+      options = {
-        lspconfig.marksman.setup{
+        cmd =
-          capabilities = capabilities;
-          on_attach = default_on_attach;
-          cmd = ${
           if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
+          then toLuaObject cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/marksman", "server"}''
+          else ''{"${cfg.lsp.package}/bin/marksman", "server"}'';
-        },
+      };
-        }
-      '';
     };
   };
 
   defaultFormat = "deno_fmt";
   formats = {
     # for backwards compatibility
-    denofmt = {
+    denofmt.package = pkgs.deno;
-      package = pkgs.deno;
+    deno_fmt.package = pkgs.deno;
-    };
+    prettierd.package = pkgs.prettierd;
-    deno_fmt = {
-      package = pkgs.deno;
-    };
-    prettierd = {
-      package = pkgs.prettierd;
-    };
   };
+
   defaultDiagnosticsProvider = ["markdownlint-cli2"];
   diagnosticsProviders = {
     markdownlint-cli2 = {
@@ -57,35 +47,29 @@ in {
     enable = mkEnableOption "Markdown markup language support";
 
     treesitter = {
-      enable = mkOption {
+      enable = mkEnableOption "Markdown treesitter" // {default = config.vim.languages.enableTreesitter;};
-        type = bool;
-        default = config.vim.languages.enableTreesitter;
-        description = "Enable Markdown treesitter";
-      };
       mdPackage = mkGrammarOption pkgs "markdown";
       mdInlinePackage = mkGrammarOption pkgs "markdown-inline";
     };
 
     lsp = {
-      enable = mkEnableOption "Enable Markdown LSP support" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Markdown LSP support" // {default = config.vim.languages.enableLSP;};
-
       server = mkOption {
-        type = enum (attrNames servers);
+        type = listOf (enum (attrNames servers));
-        default = defaultServer;
+        default = [defaultServer];
         description = "Markdown LSP server to use";
       };
 
       package = mkOption {
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
-        example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
+        example = ''["marksman"]'';
         description = "Markdown LSP server package, or the command to run as a list of strings";
       };
     };
 
     format = {
       enable = mkEnableOption "Markdown formatting" // {default = config.vim.languages.enableFormat;};
-
       type = mkOption {
         type = enum (attrNames formats);
         default = defaultFormat;

modules/plugins/languages/nim.nix

@@ -12,6 +12,7 @@
   inherit (lib.types) enum either listOf package str;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.languages) lspOptions;
 
   cfg = config.vim.languages.nim;
 
@@ -19,19 +20,14 @@
   servers = {
     nimlsp = {
       package = pkgs.nimlsp;
-      lspConfig = ''
+      options = {
-        lspconfig.nimls.setup{
+        cmd =
-          capabilities = capabilities;
-          on_attach = default_on_attach;
-          cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
           else ''
             {"${cfg.lsp.package}/bin/nimlsp"}
-          ''
+          '';
-        };
+      };
-        }
-      '';
     };
   };
 
@@ -56,31 +52,31 @@ in {
     lsp = {
       enable = mkEnableOption "Nim LSP support" // {default = config.vim.languages.enableLSP;};
       server = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = [defaultServer];
         description = "Nim LSP server to use";
-        type = str;
-        default = defaultServer;
       };
 
       package = mkOption {
-        description = "Nim LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.nimlsp]'';
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
+        example = ''[lib.getExe pkgs.nimlsp]'';
+        description = "Nim LSP server package, or the command to run as a list of strings";
       };
     };
 
     format = {
       enable = mkEnableOption "Nim formatting" // {default = config.vim.languages.enableFormat;};
       type = mkOption {
-        description = "Nim formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "Nim formatter to use";
       };
 
       package = mkOption {
-        description = "Nim formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "Nim formatter package";
       };
     };
   };

modules/plugins/languages/nix.nix

@@ -12,6 +12,7 @@
   inherit (lib.lists) isList;
   inherit (lib.strings) optionalString;
   inherit (lib.types) anything attrsOf enum either listOf nullOr package str;
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
   inherit (lib.nvim.lua) expToLua toLuaObject;
 
@@ -20,11 +21,12 @@
   useFormat = "on_attach = default_on_attach";
   noFormat = "on_attach = attach_keymaps";
 
-  defaultServer = "nil";
   packageToCmd = package: defaultCmd:
     if isList package
     then expToLua package
     else ''{"${package}/bin/${defaultCmd}"}'';
+
+  defaultServer = "nil";
   servers = {
     nil = {
       package = pkgs.nil;
@@ -145,9 +147,9 @@ in {
     lsp = {
       enable = mkEnableOption "Nix LSP support" // {default = config.vim.languages.enableLSP;};
       server = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = [defaultServer];
         description = "Nix LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
       };
 
       package = mkOption {
@@ -156,12 +158,6 @@ in {
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
       };
-
-      options = mkOption {
-        type = nullOr (attrsOf anything);
-        default = null;
-        description = "Options to pass to nixd LSP server";
-      };
     };
 
     format = {

modules/plugins/languages/nu.nix

@@ -4,28 +4,25 @@
   config,
   ...
 }: let
-  inherit (lib.options) mkEnableOption mkOption;
+  inherit (builtins) isList attrNames;
-  inherit (lib.types) str either package listOf;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.options) mkOption mkEnableOption;
+  inherit (lib.types) str either package listOf enum;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.languages) lspOptions;
+  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (builtins) isList;
 
   defaultServer = "nushell";
   servers = {
     nushell = {
       package = pkgs.nushell;
-      lspConfig = ''
+      options = {
-        lspconfig.nushell.setup{
+        cmd =
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-          cmd = ${
           if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
+          then toLuaObject cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/nu", "--no-config-file", "--lsp"}''
+          else ''{"${getExe cfg.lsp.package}", "--no-config-file", "--lsp"}'';
-        }
+      };
-        }
-      '';
     };
   };
 
@@ -42,8 +39,8 @@ in {
     lsp = {
       enable = mkEnableOption "Nu LSP support" // {default = config.vim.languages.enableLSP;};
       server = mkOption {
-        type = str;
+        type = listOf (enum (attrNames servers));
-        default = defaultServer;
+        default = [defaultServer];
         description = "Nu LSP server to use";
       };
 

modules/plugins/languages/ocaml.nix

@@ -4,12 +4,12 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) isList attrNames;
-  inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib.options) mkOption mkEnableOption;
-  inherit (lib.lists) isList;
   inherit (lib.types) either enum listOf package str;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
 
@@ -19,17 +19,12 @@
   servers = {
     ocaml-lsp = {
       package = pkgs.ocamlPackages.ocaml-lsp;
-      lspConfig = ''
+      options = {
-        lspconfig.ocamllsp.setup {
+        cmd =
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-            cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else ''{"${getExe cfg.lsp.package}"}''
+          else ''{"${getExe cfg.lsp.package}"}'';
-        };
+      };
-        }
-      '';
     };
   };
 
@@ -49,30 +44,31 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "OCaml LSP support (ocaml-lsp)" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "OCaml LSP support" // {default = config.vim.languages.enableLSP;};
       server = mkOption {
-        description = "OCaml LSP server to user";
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
         default = defaultServer;
+        description = "OCaml LSP server to user";
       };
+
       package = mkOption {
-        description = "OCaml language server package, or the command to run as a list of strings";
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
+        description = "OCaml language server package, or the command to run as a list of strings";
       };
     };
 
     format = {
-      enable = mkEnableOption "OCaml formatting support (ocamlformat)" // {default = config.vim.languages.enableFormat;};
+      enable = mkEnableOption "OCaml formatting support" // {default = config.vim.languages.enableFormat;};
       type = mkOption {
-        description = "OCaml formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "OCaml formatter to use";
       };
       package = mkOption {
-        description = "OCaml formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "OCaml formatter package";
       };
     };
   };

modules/plugins/languages/odin.nix

@@ -4,11 +4,12 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) isList attrNames;
-  inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.types) either listOf package str enum;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
 
@@ -16,17 +17,12 @@
   servers = {
     ols = {
       package = pkgs.ols;
-      lspConfig = ''
+      options = {
-        lspconfig.ols.setup {
+        cmd =
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-          cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else "{'${cfg.lsp.package}/bin/ols'}"
+          else "{'${getExe cfg.lsp.package}'}";
-        }
+      };
-        }
-      '';
     };
   };
 
@@ -42,7 +38,6 @@ in {
 
     lsp = {
       enable = mkEnableOption "Odin LSP support" // {default = config.vim.languages.enableLSP;};
-
       server = mkOption {
         type = enum (attrNames servers);
         default = defaultServer;
@@ -50,9 +45,9 @@ in {
       };
 
       package = mkOption {
-        description = "Ols package, or the command to run as a list of strings";
         type = either package (listOf str);
         default = pkgs.ols;
+        description = "Ols package, or the command to run as a list of strings";
       };
     };
   };

modules/plugins/languages/php.nix

@@ -4,12 +4,13 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) isList attrNames;
-  inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+
+  inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.types) enum either listOf package str;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
 
@@ -19,31 +20,18 @@
   servers = {
     phpactor = {
       package = pkgs.phpactor;
-      lspConfig = ''
+      options = {
-        lspconfig.phpactor.setup{
+        cmd =
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-          cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else ''
+          else ''{"${getExe cfg.lsp.package}", "language-server"}'';
-            {
+      };
-              "${getExe cfg.lsp.package}",
-              "language-server"
-            },
-          ''
-        }
-        }
-      '';
     };
 
     phan = {
-      package = pkgs.php81Packages.phan;
+      package = pkgs.php83Packages.phan;
-      lspConfig = ''
+      options = {
-        lspconfig.phan.setup{
+        cmd =
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-          cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
           else ''
@@ -59,30 +47,18 @@
                 "--language-server-on-stdin",
                 "--allow-polyfill-parser"
             },
-          ''
+          '';
-        }
+      };
-        }
-      '';
     };
 
     intelephense = {
       package = pkgs.intelephense;
-      lspConfig = ''
+      options = {
-        lspconfig.intelephense.setup{
+        cmd =
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-          cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else ''
+          else ''{"${getExe cfg.lsp.package}", "--stdio"'';
-            {
+      };
-              "${getExe cfg.lsp.package}",
-              "--stdio"
-            },
-          ''
-        }
-        }
-      '';
     };
   };
 in {
@@ -98,16 +74,16 @@ in {
       enable = mkEnableOption "PHP LSP support" // {default = config.vim.languages.enableLSP;};
 
       server = mkOption {
-        description = "PHP LSP server to use";
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
         default = defaultServer;
+        description = "PHP LSP server to use";
       };
 
       package = mkOption {
-        description = "PHP LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
+        example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
+        description = "PHP LSP server package, or the command to run as a list of strings";
       };
     };
   };
@@ -117,6 +93,7 @@ in {
       vim.treesitter.enable = true;
       vim.treesitter.grammars = [cfg.treesitter.package];
     })
+
     (mkIf cfg.lsp.enable {
       vim.lsp.lspconfig = {
         enable = true;

modules/plugins/languages/python.nix

@@ -4,12 +4,13 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) isList attrNames;
-  inherit (lib.options) mkEnableOption mkOption literalExpression;
-  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.options) mkOption mkEnableOption literalExpression;
   inherit (lib.types) enum either listOf package str bool;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.languages) lspOptions;
+  inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
 
   cfg = config.vim.languages.python;
@@ -18,47 +19,32 @@
   servers = {
     pyright = {
       package = pkgs.pyright;
-      lspConfig = ''
+      options = {
-        lspconfig.pyright.setup{
+        cmd =
-          capabilities = capabilities;
-          on_attach = default_on_attach;
-          cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/pyright-langserver", "--stdio"}''
+          else ''{"${cfg.lsp.package}/bin/pyright-langserver", "--stdio"}'';
-        }
+      };
-        }
-      '';
     };
 
     basedpyright = {
       package = pkgs.basedpyright;
-      lspConfig = ''
+      options = {
-        lspconfig.basedpyright.setup{
+        cmd =
-          capabilities = capabilities;
-          on_attach = default_on_attach;
-          cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/basedpyright-langserver", "--stdio"}''
+          else ''{"${cfg.lsp.package}/bin/basedpyright-langserver", "--stdio"}'';
-        }
+      };
-        }
-      '';
     };
 
     python-lsp-server = {
       package = pkgs.python3Packages.python-lsp-server;
-      lspConfig = ''
+      options = {
-        lspconfig.pylsp.setup{
+        cmd =
-          capabilities = capabilities;
-          on_attach = default_on_attach;
-          cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/pylsp"}''
+          else ''{"${cfg.lsp.package}/bin/pylsp"}'';
-        }
+      };
-        }
-      '';
     };
   };
 
@@ -161,27 +147,22 @@ in {
 
     treesitter = {
       enable = mkEnableOption "Python treesitter" // {default = config.vim.languages.enableTreesitter;};
-      package = mkOption {
+      package = mkGrammarOption pkgs "python";
-        description = "Python treesitter grammar to use";
-        type = package;
-        default = pkgs.vimPlugins.nvim-treesitter.builtGrammars.python;
-      };
     };
 
     lsp = {
       enable = mkEnableOption "Python LSP support" // {default = config.vim.languages.enableLSP;};
-
       server = mkOption {
-        description = "Python LSP server to use";
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
         default = defaultServer;
+        description = "Python LSP server to use";
       };
 
       package = mkOption {
-        description = "python LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
+        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
+        description = "Python LSP server package, or the command to run as a list of strings";
       };
     };
 

modules/plugins/languages/r.nix

@@ -4,12 +4,13 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) isList attrNames;
-  inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.options) mkOption mkEnableOption literalExpression;
   inherit (lib.types) enum either listOf package str;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.languages) lspOptions;
+  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption;
 
   cfg = config.vim.languages.r;
@@ -56,17 +57,12 @@
       package = pkgs.writeShellScriptBin "r_lsp" ''
         ${r-with-languageserver}/bin/R --slave -e "languageserver::run()"
       '';
-      lspConfig = ''
+      options = {
-        lspconfig.r_language_server.setup{
+        cmd =
-          capabilities = capabilities;
-          on_attach = default_on_attach;
-          cmd = ${
           if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
+          then toLuaObject cfg.lsp.package
-          else ''{"${lib.getExe cfg.lsp.package}"}''
+          else ''{"${getExe cfg.lsp.package}"}'';
-        }
+      };
-        }
-      '';
     };
   };
 in {
@@ -82,16 +78,16 @@ in {
       enable = mkEnableOption "R LSP support" // {default = config.vim.languages.enableLSP;};
 
       server = mkOption {
-        description = "R LSP server to use";
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
         default = defaultServer;
+        description = "R LSP server to use";
       };
 
       package = mkOption {
-        description = "R LSP server package, or the command to run as a list of strings";
-        example = literalExpression "[ (lib.getExe pkgs.jdt-language-server) \"-data\" \"~/.cache/jdtls/workspace\" ]";
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
+        example = literalExpression "[ (lib.getExe pkgs.jdt-language-server) \"-data\" \"~/.cache/jdtls/workspace\" ]";
+        description = "R LSP server package, or the command to run as a list of strings";
       };
     };
 
@@ -118,6 +114,11 @@ in {
       vim.treesitter.grammars = [cfg.treesitter.package];
     })
 
+    (mkIf cfg.lsp.enable {
+      vim.lsp.lspconfig.enable = true;
+      vim.lsp.lspconfig.sources.r-lsp = servers.${cfg.lsp.server}.lspConfig;
+    })
+
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
@@ -125,10 +126,5 @@ in {
         setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
       };
     })
-
-    (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
-      vim.lsp.lspconfig.sources.r-lsp = servers.${cfg.lsp.server}.lspConfig;
-    })
   ]);
 }

modules/plugins/languages/ruby.nix

@@ -4,34 +4,35 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) isList attrNames;
-  inherit (lib.options) mkEnableOption mkOption;
+
-  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.types) mkGrammarOption diagnostics;
+  inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) either listOf package str enum;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.languages) lspOptions;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics;
+  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.languages.ruby;
 
-  defaultServer = "rubyserver";
+  defaultServer = "solargraph";
   servers = {
-    rubyserver = {
+    solargraph = {
       package = pkgs.rubyPackages.solargraph;
-      lspConfig = ''
+      options = {
-        lspconfig.solargraph.setup {
+        cmd =
-          capabilities = capabilities,
+          if isList cfg.lsp.package
-          on_attach = attach_keymaps,
+          then toLuaObject cfg.lsp.package
-          flags = {
+          else ''{"${getExe cfg.lsp.package}", "stdio"}'';
-            debounce_text_changes = 150,
+
-          },
+        flags = {
-          cmd = { "${pkgs.solargraph}/bin/solargraph", "stdio" }
+          debounce_text_changes = 150;
-        }
+        };
-      '';
+      };
     };
   };
 
-  # testing
-
   defaultFormat = "rubocop";
   formats = {
     rubocop = {
@@ -58,9 +59,8 @@ in {
 
     lsp = {
       enable = mkEnableOption "Ruby LSP support" // {default = config.vim.languages.enableLSP;};
-
       server = mkOption {
-        type = enum (attrNames servers);
+        type = listOf (enum (attrNames servers));
         default = defaultServer;
         description = "Ruby LSP server to use";
       };
@@ -74,7 +74,6 @@ in {
 
     format = {
       enable = mkEnableOption "Ruby formatter support" // {default = config.vim.languages.enableFormat;};
-
       type = mkOption {
         type = enum (attrNames formats);
         default = defaultFormat;
@@ -89,10 +88,7 @@ in {
     };
 
     extraDiagnostics = {
-      enable =
+      enable = mkEnableOption "extra Ruby diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
-        mkEnableOption "Ruby extra diagnostics support"
-        // {default = config.vim.languages.enableExtraDiagnostics;};
-
       types = diagnostics {
         langDesc = "Ruby";
         inherit diagnosticsProviders;

modules/plugins/languages/rust.nix

@@ -12,6 +12,7 @@
   inherit (lib.trivial) boolToString;
   inherit (lib.lists) isList;
   inherit (lib.types) bool package str listOf either enum;
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.dag) entryAfter entryAnywhere;

modules/plugins/languages/scala.nix

@@ -6,13 +6,15 @@
 }: let
   inherit (lib.generators) mkLuaInline;
   inherit (lib.modules) mkIf mkMerge;
+
+  inherit (lib.options) mkOption mkEnableOption mkPackageOption;
+  inherit (lib.strings) optionalString;
+  inherit (lib.types) attrsOf anything bool;
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.binds) mkMappingOption;
   inherit (lib.nvim.dag) entryAfter;
   inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption luaInline;
-  inherit (lib.options) mkOption mkEnableOption mkPackageOption;
-  inherit (lib.strings) optionalString;
-  inherit (lib.types) attrsOf anything bool;
 
   listCommandsAction =
     if config.vim.telescope.enable

modules/plugins/languages/sql.nix

@@ -4,14 +4,15 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) isList attrNames;
-  inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.types) enum either listOf package str;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.meta) getExe;
-  inherit (lib.nvim.types) diagnostics;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.languages) lspOptions;
+  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.types) diagnostics mkGrammarOption;
 
   cfg = config.vim.languages.sql;
   sqlfluffDefault = pkgs.sqlfluff;
@@ -20,20 +21,20 @@
   servers = {
     sqls = {
       package = pkgs.sqls;
-      lspConfig = ''
+      options = {
-        lspconfig.sqls.setup {
+        on_attach = mkLuaInline ''
-          on_attach = function(client)
+          function(client)
-            client.server_capabilities.execute_command = true
             on_attach_keymaps(client, bufnr)
-            require'sqls'.setup{}
+            client.server_capabilities.execute_command = true
+            require('sqls').setup()
           end,
-          cmd = ${
+        '';
+
+        cmd =
           if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
+          then toLuaObject cfg.lsp.package
-          else ''{ "${cfg.lsp.package}/bin/sqls", "-config", string.format("%s/config.yml", vim.fn.getcwd()) }''
+          else ''{ "${cfg.lsp.package}/bin/sqls", "-config", string.format("%s/config.yml", vim.fn.getcwd()) }'';
-        }
+      };
-        }
-      '';
     };
   };
 
@@ -70,50 +71,42 @@ in {
 
     treesitter = {
       enable = mkEnableOption "SQL treesitter" // {default = config.vim.languages.enableTreesitter;};
-
+      package = mkGrammarOption "sql";
-      package = mkOption {
-        description = "SQL treesitter grammar to use";
-        type = package;
-        default = pkgs.vimPlugins.nvim-treesitter.builtGrammars.sql;
-      };
     };
 
     lsp = {
       enable = mkEnableOption "SQL LSP support" // {default = config.vim.languages.enableLSP;};
-
       server = mkOption {
-        description = "SQL LSP server to use";
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
         default = defaultServer;
+        description = "SQL LSP server to use";
       };
 
       package = mkOption {
-        description = "SQL LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
         type = either package (listOf str);
+        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
         default = servers.${cfg.lsp.server}.package;
+        description = "SQL LSP server package, or the command to run as a list of strings";
       };
     };
 
     format = {
       enable = mkEnableOption "SQL formatting" // {default = config.vim.languages.enableFormat;};
-
       type = mkOption {
-        description = "SQL formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "SQL formatter to use";
       };
 
       package = mkOption {
-        description = "SQL formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "SQL formatter package";
       };
     };
 
     extraDiagnostics = {
       enable = mkEnableOption "extra SQL diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
-
       types = diagnostics {
         langDesc = "SQL";
         inherit diagnosticsProviders;

modules/plugins/languages/svelte.nix

@@ -4,14 +4,15 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) isList attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+
+  inherit (lib.types) enum either listOf package str;
   inherit (lib.meta) getExe;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.types) enum either listOf package str;
+  inherit (lib.nvim.languages) lspOptions;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
 
   cfg = config.vim.languages.svelte;
@@ -20,17 +21,12 @@
   servers = {
     svelte = {
       package = pkgs.nodePackages.svelte-language-server;
-      lspConfig = ''
+      options = {
-        lspconfig.svelte.setup {
+        cmd =
-          capabilities = capabilities;
-          on_attach = attach_keymaps,
-          cmd = ${
           if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
+          then toLuaObject cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/svelteserver", "--stdio"}''
+          else ''{"${cfg.lsp.package}/bin/svelteserver", "--stdio"}'';
-        }
+      };
-        }
-      '';
     };
   };
 
@@ -79,7 +75,6 @@ in {
 
     treesitter = {
       enable = mkEnableOption "Svelte treesitter" // {default = config.vim.languages.enableTreesitter;};
-
       sveltePackage = mkGrammarOption pkgs "svelte";
     };
 
@@ -88,15 +83,15 @@ in {
 
       server = mkOption {
         description = "Svelte LSP server to use";
-        type = enum (attrNames servers);
+        type = listOf (enum (attrNames servers));
         default = defaultServer;
       };
 
       package = mkOption {
-        description = "Svelte LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
+        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
+        description = "Svelte LSP server package, or the command to run as a list of strings";
       };
     };
 

modules/plugins/languages/tailwind.nix

@@ -9,7 +9,8 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
   inherit (lib.types) enum either listOf package str;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.languages) lspOptions;
+  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim.languages.tailwind;
 
@@ -17,17 +18,12 @@
   servers = {
     tailwindcss-language-server = {
       package = pkgs.tailwindcss-language-server;
-      lspConfig = ''
+      options = {
-        lspconfig.tailwindcss.setup {
+        cmd =
-          capabilities = capabilities;
-          on_attach = default_on_attach;
-          cmd = ${
           if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
+          then toLuaObject cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/tailwindcss-language-server", "--stdio"}''
+          else ''{"${cfg.lsp.package}/bin/tailwindcss-language-server", "--stdio"}'';
-        }
+      };
-        }
-      '';
     };
   };
 in {
@@ -36,11 +32,10 @@ in {
 
     lsp = {
       enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.languages.enableLSP;};
-
       server = mkOption {
-        description = "Tailwindcss LSP server to use";
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
         default = defaultServer;
+        description = "Tailwindcss LSP server to use";
       };
 
       package = mkOption {

modules/plugins/languages/terraform.nix

@@ -4,12 +4,28 @@
   lib,
   ...
 }: let
-  inherit (lib.options) mkEnableOption mkOption;
+  inherit (builtins) isList attrNames;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) package;
+  inherit (lib.options) mkOption mkEnableOption;
+  inherit (lib.types) either package enum listOf str;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.types) mkGrammarOption;
 
   cfg = config.vim.languages.terraform;
+  defaultServer = "terraform-ls";
+  servers = {
+    terraform-ls = {
+      package = pkgs.terraform-ls;
+      options = {
+        cmd =
+          if isList cfg.lsp.package
+          then toLuaObject cfg.lsp.package
+          else ''{"${getExe cfg.lsp.package}", "serve"}'';
+      };
+    };
+  };
 in {
   options.vim.languages.terraform = {
     enable = mkEnableOption "Terraform/HCL support";
@@ -20,12 +36,18 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Terraform LSP support (terraform-ls)" // {default = config.vim.languages.enableLSP;};
+      enable = mkEnableOption "Terraform LSP support" // {default = config.vim.languages.enableLSP;};
+      server = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServer;
+        description = "Terraform LSP server to use";
+      };
 
       package = mkOption {
-        description = "terraform-ls package";
+        type = either package (listOf str);
-        type = package;
+        default = servers.${cfg.lsp.server}.package;
-        default = pkgs.terraform-ls;
+        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
+        description = "Terraform LSP server package, or the command to run as a list of strings";
       };
     };
   };

modules/plugins/languages/ts.nix

@@ -4,14 +4,14 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) isList attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.types) enum either listOf package str bool;
   inherit (lib.meta) getExe;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.types) enum either listOf package str bool;
+  inherit (lib.nvim.languages) lspOptions;
-  inherit (lib.nvim.lua) expToLua toLuaObject;
+  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption diagnostics mkPluginSetupOption;
   inherit (lib.nvim.dag) entryAnywhere;
 
@@ -21,36 +21,29 @@
   servers = {
     ts_ls = {
       package = pkgs.typescript-language-server;
-      lspConfig = ''
+      options = {
-        lspconfig.ts_ls.setup {
+        on_attach = mkLuaInline ''
-          capabilities = capabilities,
+          function(client, bufnr)
-          on_attach = function(client, bufnr)
             attach_keymaps(client, bufnr);
             client.server_capabilities.documentFormattingProvider = false;
           end,
-          cmd = ${
+        '';
+
+        cmd =
           if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
+          then toLuaObject cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/typescript-language-server", "--stdio"}''
+          else ''{"${cfg.lsp.package}/bin/typescript-language-server", "--stdio"}'';
-        }
+      };
-        }
-      '';
     };
 
     denols = {
       package = pkgs.deno;
-      lspConfig = ''
+      options = {
-        vim.g.markdown_fenced_languages = { "ts=typescript" }
+        cmd =
-        lspconfig.denols.setup {
-          capabilities = capabilities;
-          on_attach = attach_keymaps,
-          cmd = ${
           if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
+          then toLuaObject cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/deno", "lsp"}''
+          else ''{"${cfg.lsp.package}/bin/deno", "lsp"}'';
-        }
+      };
-        }
-      '';
     };
 
     # Here for backwards compatibility. Still consider tsserver a valid
@@ -58,17 +51,12 @@
     # redirect the user to the correct server.
     tsserver = {
       package = pkgs.typescript-language-server;
-      lspConfig = ''
+      options = {
-        lspconfig.ts_ls.setup {
+        cmd =
-          capabilities = capabilities;
-          on_attach = attach_keymaps,
-          cmd = ${
           if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
+          then toLuaObject cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/typescript-language-server", "--stdio"}''
+          else ''{"${cfg.lsp.package}/bin/typescript-language-server", "--stdio"}'';
-        }
+      };
-        }
-      '';
     };
   };
 
@@ -128,40 +116,37 @@ in {
 
     lsp = {
       enable = mkEnableOption "Typescript/Javascript LSP support" // {default = config.vim.languages.enableLSP;};
-
       server = mkOption {
-        description = "Typescript/Javascript LSP server to use";
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
         default = defaultServer;
+        description = "Typescript/Javascript LSP server to use";
       };
 
       package = mkOption {
-        description = "Typescript/Javascript LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
+        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
+        description = "Typescript/Javascript LSP server package, or the command to run as a list of strings";
       };
     };
 
     format = {
       enable = mkEnableOption "Typescript/Javascript formatting" // {default = config.vim.languages.enableFormat;};
-
       type = mkOption {
-        description = "Typescript/Javascript formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "Typescript/Javascript formatter to use";
       };
 
       package = mkOption {
-        description = "Typescript/Javascript formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "Typescript/Javascript formatter package";
       };
     };
 
     extraDiagnostics = {
       enable = mkEnableOption "extra Typescript/Javascript diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
-
       types = diagnostics {
         langDesc = "Typescript/Javascript";
         inherit diagnosticsProviders;
@@ -175,15 +160,14 @@ in {
           [ts-error-translator.nvim]: https://github.com/dmmulroy/ts-error-translator.nvim
 
           Typescript error translation with [ts-error-translator.nvim]
-
         '';
 
         setupOpts = mkPluginSetupOption "ts-error-translator" {
           # This is the default configuration behaviour.
           auto_override_publish_diagnostics = mkOption {
-            description = "Automatically override the publish_diagnostics handler";
             type = bool;
             default = true;
+            description = "Automatically override the publish_diagnostics handler";
           };
         };
       };

modules/plugins/languages/typst.nix

@@ -4,12 +4,14 @@
   lib,
   ...
 }: let
-  inherit (lib.options) mkEnableOption mkOption;
+  inherit (builtins) isList attrNames;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+
+  inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.types) nullOr enum either attrsOf listOf package str;
-  inherit (lib.attrsets) attrNames;
   inherit (lib.meta) getExe;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.lua) expToLua toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption;
   inherit (lib.nvim.dag) entryAnywhere;
@@ -20,39 +22,38 @@
   servers = {
     typst-lsp = {
       package = pkgs.typst-lsp;
-      lspConfig = ''
+      options = {
-        lspconfig.typst_lsp.setup {
+        on_attach = mkLuaInline ''
-          capabilities = capabilities,
+          function(client, bufnr)
-          on_attach = function(client, bufnr)
+            -- Disable semantic tokens as a workaround for a semantic token error
-            -- Disable semantic tokens as a workaround for a semantic token error when using non-english characters
+            -- when using non-english characters
             client.server_capabilities.semanticTokensProvider = nil
           end,
-          cmd = ${
+        '';
+
+        cmd =
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/typst-lsp"}''
+          else ''{"${getExe cfg.lsp.package}'';
-        },
+      };
-        }
-      '';
     };
 
     tinymist = {
       package = pkgs.tinymist;
-      lspConfig = ''
+      options = {
-        lspconfig.tinymist.setup {
+        on_attach = mkLuaInline ''
-          capabilities = capabilities,
+          function(client, bufnr)
-          single_file_support = true,
+            -- Disable semantic tokens as a workaround for a semantic token error
-          on_attach = function(client, bufnr)
+            -- when using non-english characters
-            -- Disable semantic tokens as a workaround for a semantic token error when using non-english characters
             client.server_capabilities.semanticTokensProvider = nil
           end,
-          cmd = ${
+        '';
+
+        cmd =
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/tinymist"}''
+          else ''{"${cfg.lsp.package}/bin/tinymist"}'';
-        },
+      };
-        }
-      '';
     };
   };
 
@@ -79,44 +80,46 @@ in {
       enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.languages.enableLSP;};
 
       server = mkOption {
-        description = "Typst LSP server to use";
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
         default = defaultServer;
+        description = "Typst LSP server to use";
       };
 
       package = mkOption {
-        description = "typst-lsp package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
+        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
+        description = "typst-lsp package, or the command to run as a list of strings";
       };
     };
 
     format = {
       enable = mkEnableOption "Typst document formatting" // {default = config.vim.languages.enableFormat;};
-
       type = mkOption {
-        description = "Typst formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "Typst formatter to use";
       };
 
       package = mkOption {
-        description = "Typst formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "Typst formatter package";
       };
     };
 
     extensions = {
       typst-preview-nvim = {
         enable =
-          mkEnableOption ''
+          mkEnableOption ""
-            [typst-preview.nvim]: https://github.com/chomosuke/typst-preview.nvim
+          // {
+            default = true;
+            description = ''
+              [typst-preview.nvim]: https://github.com/chomosuke/typst-preview.nvim
 
-            Low latency typst preview for Neovim via [typst-preview.nvim]
+              Low latency typst preview for Neovim via [typst-preview.nvim]
-          ''
+            '';
-          // {default = true;};
+          };
 
         setupOpts = mkPluginSetupOption "typst-preview-nvim" {
           open_cmd = mkOption {

modules/plugins/languages/vala.nix

@@ -9,6 +9,8 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
   inherit (lib.types) enum either listOf package str;
+
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
 
@@ -26,18 +28,13 @@
             --prefix PATH : ${pkgs.uncrustify}/bin
         '';
       };
-      internalFormatter = true;
+
-      lspConfig = ''
+      options = {
-        lspconfig.vala_ls.setup {
+        cmd =
-          capabilities = capabilities;
-          on_attach = default_on_attach;
-          cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/vala-language-server"}''
+          else ''{"${cfg.lsp.package}/bin/vala-language-server"}'';
-        },
+      };
-        }
-      '';
     };
   };
 in {
@@ -52,15 +49,15 @@ in {
     lsp = {
       enable = mkEnableOption "Vala LSP support" // {default = config.vim.languages.enableLSP;};
       server = mkOption {
-        description = "Vala LSP server to use";
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
         default = defaultServer;
+        description = "Vala LSP server to use";
       };
 
       package = mkOption {
-        description = "Vala LSP server package, or the command to run as a list of strings";
         type = either package (listOf str);
         default = servers.${cfg.lsp.server}.package;
+        description = "Vala LSP server package, or the command to run as a list of strings";
       };
     };
   };

modules/plugins/languages/wgsl.nix

@@ -7,10 +7,11 @@
   inherit (builtins) attrNames;
   inherit (lib.lists) isList;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.lua) expToLua;
-  inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.options) literalExpression mkEnableOption mkOption;
   inherit (lib.types) either enum listOf package str;
+  inherit (lib.nvim.languages) lspOptions;
+  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.types) mkGrammarOption;
 
   cfg = config.vim.languages.wgsl;
 
@@ -19,17 +20,12 @@
     wgsl-analyzer = {
       package = pkgs.wgsl-analyzer;
       internalFormatter = true;
-      lspConfig = ''
+      options = {
-        lspconfig.wgsl_analyzer.setup {
+        cmd =
-          capabilities = capabilities,
-          on_attach = default_on_attach,
-          cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else "{'${cfg.lsp.package}/bin/wgsl_analyzer'}"
+          else "{'${cfg.lsp.package}/bin/wgsl_analyzer'}";
-        }
+      };
-        }
-      '';
     };
   };
 in {
@@ -43,18 +39,17 @@ in {
 
     lsp = {
       enable = mkEnableOption "WGSL LSP support" // {default = config.vim.languages.enableLSP;};
-
       server = mkOption {
-        type = enum (attrNames servers);
+        type = listOf (enum (attrNames servers));
         default = defaultServer;
         description = "WGSL LSP server to use";
       };
 
       package = mkOption {
-        description = "wgsl-analyzer package, or the command to run as a list of strings";
-        example = literalExpression "[(lib.getExe pkgs.wgsl-analyzer)]";
         type = either package (listOf str);
         default = pkgs.wgsl-analyzer;
+        example = literalExpression "[(lib.getExe pkgs.wgsl-analyzer)]";
+        description = "wgsl-analyzer package, or the command to run as a list of strings";
       };
     };
   };

modules/plugins/languages/yaml.nix

@@ -4,44 +4,39 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) isList attrNames;
-  inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.types) enum either listOf package str;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
 
   cfg = config.vim.languages.yaml;
 
-  onAttach =
+  yamlOnAttach =
     if config.vim.languages.helm.lsp.enable
     then ''
-      on_attach = function(client, bufnr)
+      function(client, bufnr)
         local filetype = vim.bo[bufnr].filetype
         if filetype == "helm" then
           client.stop()
         end
       end''
-    else "on_attach = default_on_attach";
+    else "default_on_attach";
 
   defaultServer = "yaml-language-server";
   servers = {
     yaml-language-server = {
       package = pkgs.nodePackages.yaml-language-server;
-      lspConfig = ''
+      options = {
-
+        on_attach = mkLuaInline yamlOnAttach;
-
+        cmd =
-        lspconfig.yamlls.setup {
-          capabilities = capabilities,
-          ${onAttach},
-          cmd = ${
           if isList cfg.lsp.package
           then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/yaml-language-server", "--stdio"}''
+          else ''{"${cfg.lsp.package}/bin/yaml-language-server", "--stdio"}'';
-        },
+      };
-        }
-      '';
     };
   };
 in {
@@ -58,7 +53,7 @@ in {
       enable = mkEnableOption "YAML LSP support" // {default = config.vim.languages.enableLSP;};
 
       server = mkOption {
-        type = enum (attrNames servers);
+        type = listOf (enum (attrNames servers));
         default = defaultServer;
         description = "YAML LSP server to use";
       };

modules/plugins/languages/zig.nix

@@ -9,6 +9,7 @@
   inherit (lib.modules) mkIf mkMerge mkDefault;
   inherit (lib.lists) isList;
   inherit (lib.types) bool either listOf package str enum;
+  inherit (lib.nvim.languages) lspOptions;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
 
@@ -73,7 +74,6 @@ in {
 
     lsp = {
       enable = mkEnableOption "Zig LSP support" // {default = config.vim.languages.enableLSP;};
-
       server = mkOption {
         type = enum (attrNames servers);
         default = defaultServer;
@@ -81,9 +81,9 @@ in {
       };
 
       package = mkOption {
-        description = "ZLS package, or the command to run as a list of strings";
         type = either package (listOf str);
         default = pkgs.zls;
+        description = "ZLS package, or the command to run as a list of strings";
       };
     };