configuration.nix

@@ -105,10 +105,12 @@ isMaximal: {
       transparent = false;
     };
 
-    autopairs.nvim-autopairs.enable = true;
+    autopairs.enable = true;
 
-    autocomplete.nvim-cmp.enable = true;
+    autocomplete = {
-    snippets.luasnip.enable = true;
+      enable = true;
+      type = "nvim-cmp";
+    };
 
     filetree = {
       nvimTree = {

docs/manual/hacking/keybinds.md

@@ -7,26 +7,37 @@ section contains a general overview to how you may utilize said functions.
 
 ## Custom Key Mappings Support for a Plugin {#sec-custom-key-mappings}
 
-To set a mapping, you should define it in `vim.keymaps`.
+To set a mapping, you should define it in `vim.maps.<<mode>>`.
+The available modes are:
+
+- normal
+- insert
+- select
+- visual
+- terminal
+- normalVisualOp
+- visualOnly
+- operator
+- insertCommand
+- lang
+- command
 
 An example, simple keybinding, can look like this:
 
 ```nix
 {
-  vim.keymaps = [
+  vim.maps.normal = {
-    {
+    "<leader>wq" = {
-      key = "<leader>wq";
-      mode = ["n"];
       action = ":wq<CR>";
       silent = true;
       desc = "Save file and quit";
-    }
+    };
-  ];
+  };
 }
 ```
 
 There are many settings available in the options. Please refer to the
-[documentation](https://notashelf.github.io/nvf/options.html#opt-vim.keymaps)
+[documentation](https://notashelf.github.io/nvf/options.html#opt-vim.maps.command._name_.action)
 to see a list of them.
 
 **nvf** provides a list of helper commands, so that you don't have to write the

docs/release-notes/rl-0.7.md

@@ -28,11 +28,10 @@ configuration formats.
 
 ### `vim.maps` rewrite {#sec-vim-maps-rewrite}
 
-Instead of specifying map modes using submodules (eg.: `vim.maps.normal`), a new
+Instead of specifying map modes using submodules (eg.: `vim.maps.normal`), a new `vim.keymaps`
-`vim.keymaps` submodule with support for a `mode` option has been introduced. It
+submodule with support for a `mode` option has been introduced. It can be either a string, or a
-can be either a string, or a list of strings, where a string represents the
+list of strings, where a string represents the short-name of the map mode(s), that the mapping
-short-name of the map mode(s), that the mapping should be set for. See
+should be set for. See `:help map-modes` for more information.
-`:help map-modes` for more information.
 
 For example:
 
@@ -63,6 +62,7 @@ Note that we are looking to add more alternatives in the future like
 dressing.nvim and actions-preview.nvim, in case fastaction doesn't work for
 everyone.
 
+
 ## Changelog {#sec-release-0.7-changelog}
 
 [ItsSorae](https://github.com/ItsSorae):
@@ -150,29 +150,12 @@ everyone.
 - Replace `vim.lsp.nvimCodeActionMenu` with `vim.ui.fastaction`, see the
   breaking changes section above for more details
 
-- Add a `setupOpts` option to nvim-surround, which allows modifying options that
+- Add a `setupOpts` option to nvim-surround, which allows modifying options that aren't defined in nvf. Move the alternate nvim-surround keybinds to use `setupOpts`.
-  aren't defined in nvf. Move the alternate nvim-surround keybinds to use
-  `setupOpts`.
-
-- Remove `autopairs.type`, and rename `autopairs.enable` to
-  `autopairs.nvim-autopairs.enable`. The new
-  [](#opt-vim.autopairs.nvim-autopairs.enable) supports `setupOpts` format by
-  default.
-
-- Refactor of `nvim-cmp` and completion related modules
-  - Remove `autocomplete.type` in favor of per-plugin enable options such as
-    [](#opt-vim.autocomplete.nvim-cmp.enable).
-  - Deprecate legacy Vimsnip in favor of Luasnip, and integrate
-    friendly-snippets for bundled snippets. [](#opt-vim.snippets.luasnip.enable)
-    can be used to toggle Luasnip.
-  - Add sorting function options for completion sources under
-    [](#opt-vim.autocomplete.nvim-cmp.setupOpts.sorting.comparators)
 
 [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.
@@ -259,9 +242,10 @@ everyone.
 - Add LSP and Treesitter support for R under `vim.languages.R`.
 - Add Otter support under `vim.lsp.otter` and an assert to prevent conflict with
   ccc
-
+  
 [Bloxx12](https://github.com/Bloxx12)
 
 - Add support for [base16 theming](https://github.com/RRethy/base16-nvim) under
   `vim.theme`
 - Fix internal breakage in `elixir-tools` setup.
+

flake.lock

@@ -316,22 +316,6 @@
         "type": "github"
       }
     },
-    "plugin-cmp-luasnip": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1696878902,
-        "narHash": "sha256-nUJJl2zyK/oSwz5RzI9j3gf9zpDfCImCYbPbVsyXgz8=",
-        "owner": "saadparwaiz1",
-        "repo": "cmp_luasnip",
-        "rev": "05a9ab28b53f71d1aece421ef32fee2cb857a843",
-        "type": "github"
-      },
-      "original": {
-        "owner": "saadparwaiz1",
-        "repo": "cmp_luasnip",
-        "type": "github"
-      }
-    },
     "plugin-cmp-nvim-lsp": {
       "flake": false,
       "locked": {
@@ -380,6 +364,22 @@
         "type": "github"
       }
     },
+    "plugin-cmp-vsnip": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1669100283,
+        "narHash": "sha256-2mkN03noOr5vBvRbSb35xZKorSH+8savQNZtgM9+QcM=",
+        "owner": "hrsh7th",
+        "repo": "cmp-vsnip",
+        "rev": "989a8a73c44e926199bfd05fa7a516d51f2d2752",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hrsh7th",
+        "repo": "cmp-vsnip",
+        "type": "github"
+      }
+    },
     "plugin-codewindow-nvim": {
       "flake": false,
       "locked": {
@@ -588,22 +588,6 @@
         "type": "github"
       }
     },
-    "plugin-friendly-snippets": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1727061933,
-        "narHash": "sha256-yTsuV5unoujY0mhLINssYYBWCeefe+nJaxQHJKm7hlk=",
-        "owner": "rafamadriz",
-        "repo": "friendly-snippets",
-        "rev": "00ba9dd3df89509f95437b8d595553707c46d5ea",
-        "type": "github"
-      },
-      "original": {
-        "owner": "rafamadriz",
-        "repo": "friendly-snippets",
-        "type": "github"
-      }
-    },
     "plugin-gesture-nvim": {
       "flake": false,
       "locked": {
@@ -874,19 +858,6 @@
         "owner": "horriblename",
         "ref": "require-rewrite",
         "repo": "lzn-auto-require",
-    "plugin-luasnip": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1726165831,
-        "narHash": "sha256-nkaa1NGOI28Et2QitQB+Spv+J42QVdHE1oywteLcJJw=",
-        "owner": "L3MON4D3",
-        "repo": "LuaSnip",
-        "rev": "e808bee352d1a6fcf902ca1a71cee76e60e24071",
-        "type": "github"
-      },
-      "original": {
-        "owner": "L3MON4D3",
-        "repo": "LuaSnip",
         "type": "github"
       }
     },
@@ -1819,6 +1790,22 @@
         "type": "github"
       }
     },
+    "plugin-vim-vsnip": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1704937299,
+        "narHash": "sha256-gvm6z4pgSULBVPukewRyjwxZ0vZgreQWbG/0kOB1QBo=",
+        "owner": "hrsh7th",
+        "repo": "vim-vsnip",
+        "rev": "02a8e79295c9733434aab4e0e2b8c4b7cea9f3a9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hrsh7th",
+        "repo": "vim-vsnip",
+        "type": "github"
+      }
+    },
     "plugin-which-key": {
       "flake": false,
       "locked": {
@@ -1873,10 +1860,10 @@
         "plugin-cheatsheet-nvim": "plugin-cheatsheet-nvim",
         "plugin-cinnamon-nvim": "plugin-cinnamon-nvim",
         "plugin-cmp-buffer": "plugin-cmp-buffer",
-        "plugin-cmp-luasnip": "plugin-cmp-luasnip",
         "plugin-cmp-nvim-lsp": "plugin-cmp-nvim-lsp",
         "plugin-cmp-path": "plugin-cmp-path",
         "plugin-cmp-treesitter": "plugin-cmp-treesitter",
+        "plugin-cmp-vsnip": "plugin-cmp-vsnip",
         "plugin-codewindow-nvim": "plugin-codewindow-nvim",
         "plugin-comment-nvim": "plugin-comment-nvim",
         "plugin-copilot-cmp": "plugin-copilot-cmp",
@@ -1890,7 +1877,6 @@
         "plugin-fastaction-nvim": "plugin-fastaction-nvim",
         "plugin-fidget-nvim": "plugin-fidget-nvim",
         "plugin-flutter-tools": "plugin-flutter-tools",
-        "plugin-friendly-snippets": "plugin-friendly-snippets",
         "plugin-gesture-nvim": "plugin-gesture-nvim",
         "plugin-gitsigns-nvim": "plugin-gitsigns-nvim",
         "plugin-glow-nvim": "plugin-glow-nvim",
@@ -1908,7 +1894,6 @@
         "plugin-lualine": "plugin-lualine",
         "plugin-lz-n": "plugin-lz-n",
         "plugin-lzn-auto-require": "plugin-lzn-auto-require",
-        "plugin-luasnip": "plugin-luasnip",
         "plugin-mind-nvim": "plugin-mind-nvim",
         "plugin-minimap-vim": "plugin-minimap-vim",
         "plugin-modes-nvim": "plugin-modes-nvim",
@@ -1967,6 +1952,7 @@
         "plugin-vim-markdown": "plugin-vim-markdown",
         "plugin-vim-repeat": "plugin-vim-repeat",
         "plugin-vim-startify": "plugin-vim-startify",
+        "plugin-vim-vsnip": "plugin-vim-vsnip",
         "plugin-which-key": "plugin-which-key",
         "rnix-lsp": "rnix-lsp",
         "systems": "systems_2"

flake.nix

@@ -288,6 +288,11 @@
       flake = false;
     };
 
+    plugin-cmp-vsnip = {
+      url = "github:hrsh7th/cmp-vsnip";
+      flake = false;
+    };
+
     plugin-cmp-path = {
       url = "github:hrsh7th/cmp-path";
       flake = false;
@@ -298,19 +303,9 @@
       flake = false;
     };
 
-    plugin-cmp-luasnip = {
-      url = "github:saadparwaiz1/cmp_luasnip";
-      flake = false;
-    };
-
     # snippets
-    plugin-luasnip = {
+    plugin-vim-vsnip = {
-      url = "github:L3MON4D3/LuaSnip";
+      url = "github:hrsh7th/vim-vsnip";
-      flake = false;
-    };
-
-    plugin-friendly-snippets = {
-      url = "github:rafamadriz/friendly-snippets";
       flake = false;
     };
 

lib/attrsets.nix

@@ -1,5 +0,0 @@
-{lib}: let
-  inherit (builtins) listToAttrs;
-in {
-  mapListToAttrs = f: list: listToAttrs (map f list);
-}

lib/default.nix

@@ -10,7 +10,6 @@
   dag = import ./dag.nix {inherit lib;};
   languages = import ./languages.nix {inherit lib;};
   lists = import ./lists.nix {inherit lib;};
-  attrsets = import ./attrsets.nix {inherit lib;};
   lua = import ./lua.nix {inherit lib;};
   neovimConfiguration = import ../modules {inherit inputs lib;};
 }

lib/languages.nix

@@ -2,8 +2,8 @@
 {lib}: let
   inherit (builtins) isString getAttr;
   inherit (lib.options) mkOption;
+  inherit (lib.attrsets) listToAttrs;
   inherit (lib.types) bool;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
 in {
   # Converts a boolean to a yes/no string. This is used in lots of
   # configuration formats.
@@ -12,21 +12,21 @@ in {
     config,
     diagnosticsProviders,
   }:
-    mapListToAttrs
+    listToAttrs
-    (v: let
+    (map (v: let
-      type =
+        type =
-        if isString v
+          if isString v
-        then v
+          then v
-        else getAttr v.type;
+          else getAttr v.type;
-      package =
+        package =
-        if isString v
+          if isString v
-        then diagnosticsProviders.${type}.package
+          then diagnosticsProviders.${type}.package
-        else v.package;
+          else v.package;
-    in {
+      in {
-      name = "${lang}-diagnostics-${type}";
+        name = "${lang}-diagnostics-${type}";
-      value = diagnosticsProviders.${type}.nullConfig package;
+        value = diagnosticsProviders.${type}.nullConfig package;
-    })
+      })
-    config;
+      config);
 
   mkEnable = desc:
     mkOption {

lib/types/default.nix

@@ -6,10 +6,10 @@
   typesDag = import ./dag.nix {inherit lib;};
   typesPlugin = import ./plugins.nix {inherit inputs lib;};
   typesLanguage = import ./languages.nix {inherit lib;};
-  customTypes = import ./custom.nix {inherit lib;};
+  typesTypes = import ./types.nix {inherit lib;};
 in {
   inherit (typesDag) dagOf;
   inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
   inherit (typesLanguage) diagnostics mkGrammarOption;
-  inherit (customTypes) anythingConcatLists char hexColor mergelessListOf;
+  inherit (typesTypes) anythingConcatLists char hexColor;
 }

lib/types/plugins.nix

@@ -97,7 +97,7 @@ in {
 
       default = {};
       type = submodule {
-        freeformType = anything;
+        freeformType = attrsOf anything;
         options = opts;
       };
     };

lib/types/types.nix

@@ -1,7 +1,7 @@
 {lib}: let
-  inherit (lib.options) showOption showFiles getFiles mergeOneOption mergeEqualOption;
+  inherit (lib) isStringLike showOption showFiles getFiles mergeOneOption mergeEqualOption mkOptionType;
-  inherit (lib.strings) isString isStringLike;
+  inherit (lib.strings) isString;
-  inherit (lib.types) anything attrsOf listOf mkOptionType;
+  inherit (lib.types) anything attrsOf;
   inherit (lib.nvim.types) anythingConcatLists;
   inherit (builtins) typeOf isAttrs any head concatLists stringLength match;
 in {
@@ -52,16 +52,6 @@ in {
         (mergeFunctions.${commonType} or mergeEqualOption) loc defs;
     };
 
-  mergelessListOf = elemType: let
-    super = listOf elemType;
-  in
-    super
-    // {
-      name = "mergelessListOf";
-      description = "mergeless ${super.description}";
-      merge = mergeEqualOption;
-    };
-
   char = mkOptionType {
     name = "char";
     description = "character";

modules/extra/deprecations.nix

@@ -1,5 +1,5 @@
 {lib, ...}: let
-  inherit (lib.modules) mkRemovedOptionModule mkRenamedOptionModule;
+  inherit (lib.modules) mkRemovedOptionModule;
 in {
   imports = [
     # 2024-06-06
@@ -14,26 +14,5 @@ in {
       available under `vim.ui.fastaction` as a replacement. Simply remove everything under
       `vim.lsp.nvimCodeActionMenu`, and set `vim.ui.fastaction.enable` to `true`.
     '')
-
-    (mkRemovedOptionModule ["vim" "autopairs" "enable"] ''
-      vim.autopairs.enable has been removed in favor of per-plugin modules.
-      You can enable nvim-autopairs with vim.autopairs.nvim-autopairs.enable instead.
-    '')
-    (mkRemovedOptionModule ["vim" "autopairs" "type"] ''
-      vim.autopairs.type has been removed in favor of per-plugin modules.
-      You can enable nvim-autopairs with vim.autopairs.nvim-autopairs.enable instead.
-    '')
-    (mkRemovedOptionModule ["vim" "autocomplete" "enable"] ''
-      vim.autocomplete.enable has been removed in favor of per-plugin modules.
-      You can enable nvim-cmp with vim.autocomplete.nvim-cmp.enable instead.
-    '')
-    (mkRemovedOptionModule ["vim" "autocomplete" "type"] ''
-      vim.autocomplete.type has been removed in favor of per-plugin modules.
-      You can enable nvim-cmp with vim.autocomplete.nvim-cmp.enable instead.
-    '')
-    (mkRemovedOptionModule ["vim" "snippets" "vsnip" "enable"] ''
-      vim.snippets.vsnip.enable has been removed in favor of the more modern luasnip.
-    '')
-    (mkRenamedOptionModule ["vim" "lsp" "lspkind" "mode"] ["vim" "lsp" "lspkind" "setupOpts" "mode"])
   ];
 }

modules/neovim/mappings/options.nix

@@ -1,5 +1,5 @@
 {lib, ...}: let
-  inherit (lib.options) mkOption literalMD;
+  inherit (lib.options) mkOption;
   inherit (lib.types) either str listOf attrsOf nullOr submodule;
   inherit (lib.nvim.config) mkBool;
 
@@ -42,7 +42,7 @@
 
             See `:help map-modes` for a list of modes.
           '';
-          example = literalMD ''`["n" "v" "c"]` for normal, visual and command mode'';
+          example = ''`["n" "v" "c"]` for normal, visual and command mode'';
         };
       };
   };

modules/plugins/assistant/copilot/config.nix

@@ -34,8 +34,6 @@ in {
         "copilot-cmp"
       ];
 
-    vim.autocomplete.nvim-cmp.sources = {copilot = "[Copilot]";};
-
     vim.pluginRC.copilot = entryAnywhere ''
       require("copilot").setup(${toLuaObject cfg.setupOpts})
 

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

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

modules/plugins/autopairs/nvim-autopairs/nvim-autopairs.nix

@@ -1,14 +1,21 @@
 {lib, ...}: let
   inherit (lib) mkRemovedOptionModule;
-  inherit (lib.options) mkEnableOption;
+  inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (lib.types) enum;
 in {
   imports = [
     (mkRemovedOptionModule ["vim" "autopairs" "nvim-compe"] "nvim-compe is deprecated and no longer suported.")
   ];
 
-  options.vim.autopairs.nvim-autopairs = {
+  options.vim = {
-    enable = mkEnableOption "autopairs";
+    autopairs = {
-    setupOpts = mkPluginSetupOption "nvim-autopairs" {};
+      enable = mkEnableOption "autopairs" // {default = false;};
+
+      type = mkOption {
+        type = enum ["nvim-autopairs"];
+        default = "nvim-autopairs";
+        description = "Set the autopairs type. Options: nvim-autopairs [nvim-autopairs]";
+      };
+    };
   };
 }

modules/plugins/completion/nvim-cmp/config.nix

@@ -3,115 +3,246 @@
   config,
   ...
 }: let
-  inherit (lib.modules) mkIf;
+  inherit (builtins) toJSON;
-  inherit (lib.strings) optionalString;
+  inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.generators) mkLuaInline;
+  inherit (lib.attrsets) attrNames mapAttrsToList;
-  inherit (lib.nvim.binds) addDescriptionsToMappings;
+  inherit (lib.strings) concatMapStringsSep concatStringsSep optionalString;
-  inherit (lib.nvim.dag) entryAfter;
+  inherit (lib.nvim.binds) addDescriptionsToMappings mkSetLuaBinding;
-  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.dag) entryAnywhere entryAfter;
-  inherit (builtins) attrNames;
 
-  cfg = config.vim.autocomplete.nvim-cmp;
+  cfg = config.vim.autocomplete;
-  luasnipEnable = config.vim.snippets.luasnip.enable;
+  lspkindEnabled = config.vim.lsp.enable && config.vim.lsp.lspkind.enable;
+
+  self = import ./nvim-cmp.nix {inherit lib;};
+  mappingDefinitions = self.options.vim.autocomplete.mappings;
 
-  self = import ./nvim-cmp.nix {inherit lib config;};
-  mappingDefinitions = self.options.vim.autocomplete.nvim-cmp.mappings;
   mappings = addDescriptionsToMappings cfg.mappings mappingDefinitions;
+
+  builtSources =
+    concatMapStringsSep
+    "\n"
+    (n: "{ name = '${n}'},")
+    (attrNames cfg.sources);
+
+  builtMaps =
+    concatStringsSep
+    "\n"
+    (mapAttrsToList
+      (n: v:
+        if v == null
+        then ""
+        else "${n} = '${v}',")
+      cfg.sources);
+
+  dagPlacement =
+    if lspkindEnabled
+    then entryAfter ["lspkind"]
+    else entryAnywhere;
 in {
   config = mkIf cfg.enable {
-    vim = {
+    vim.startPlugins = [
-      startPlugins = [
+      "nvim-cmp"
-        "nvim-cmp"
+      "cmp-buffer"
-        "cmp-buffer"
+      "cmp-vsnip"
-        "cmp-path"
+      "cmp-path"
-      ];
+      "vim-vsnip"
+    ];
 
-      autocomplete.nvim-cmp.sources = {
+    vim.autocomplete.sources = {
-        nvim-cmp = null;
+      "nvim-cmp" = null;
-        buffer = "[Buffer]";
+      "vsnip" = "[VSnip]";
-        path = "[Path]";
+      "buffer" = "[Buffer]";
-      };
+      "crates" = "[Crates]";
-
+      "path" = "[Path]";
-      autocomplete.nvim-cmp.setupOpts = {
+      "copilot" = "[Copilot]";
-        sources = map (s: {name = s;}) (attrNames cfg.sources);
-
-        # TODO: try to get nvim-cmp to follow global border style
-        window = mkIf config.vim.ui.borders.enable {
-          completion = mkLuaInline "cmp.config.window.bordered()";
-          documentation = mkLuaInline "cmp.config.window.bordered()";
-        };
-
-        formatting.format = cfg.format;
-      };
-
-      pluginRC.nvim-cmp = mkIf cfg.enable (entryAfter ["autopairs" "luasnip"] ''
-        local luasnip = require("luasnip")
-        local cmp = require("cmp")
-        cmp.setup(${toLuaObject cfg.setupOpts})
-      '');
-
-      # `cmp` and `luasnip` are defined above, in the `nvim-cmp` section
-      autocomplete.nvim-cmp.setupOpts.mapping = {
-        ${mappings.complete.value} = mkLuaInline "cmp.mapping.complete()";
-        ${mappings.close.value} = mkLuaInline "cmp.mapping.abort()";
-        ${mappings.scrollDocsUp.value} = mkLuaInline "cmp.mapping.scroll_docs(-4)";
-        ${mappings.scrollDocsDown.value} = mkLuaInline "cmp.mapping.scroll_docs(4)";
-
-        ${mappings.confirm.value} = mkLuaInline ''
-          cmp.mapping(function(fallback)
-            if cmp.visible() then
-              ${
-            if luasnipEnable
-            then ''
-              if luasnip.expandable() then
-                luasnip.expand()
-              else
-                cmp.confirm({ select = true })
-              end
-            ''
-            else "cmp.confirm({ select = true })"
-          }
-            else
-                fallback()
-            end
-          end)
-        '';
-
-        ${mappings.next.value} = mkLuaInline ''
-          cmp.mapping(function(fallback)
-            local has_words_before = function()
-              local line, col = unpack(vim.api.nvim_win_get_cursor(0))
-              return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
-            end
-
-            if cmp.visible() then
-              cmp.select_next_item()
-              ${optionalString luasnipEnable ''
-            elseif luasnip.locally_jumpable(1) then
-              luasnip.jump(1)
-          ''}
-            elseif has_words_before() then
-              cmp.complete()
-            else
-              fallback()
-            end
-          end)
-        '';
-
-        ${mappings.previous.value} = mkLuaInline ''
-          cmp.mapping(function(fallback)
-            if cmp.visible() then
-              cmp.select_prev_item()
-              ${optionalString luasnipEnable ''
-            elseif luasnip.locally_jumpable(-1) then
-              luasnip.jump(-1)
-          ''}
-            else
-              fallback()
-            end
-          end)
-        '';
-      };
     };
+
+    vim.maps.insert = mkMerge [
+      (mkSetLuaBinding mappings.complete ''
+        require('cmp').complete
+      '')
+      (let
+        defaultKeys =
+          if config.vim.autopairs.enable
+          then "require('nvim-autopairs').autopairs_cr()"
+          else "vim.api.nvim_replace_termcodes(${toJSON mappings.confirm.value}, true, false, true)";
+      in
+        mkSetLuaBinding mappings.confirm ''
+          function()
+            if not require('cmp').confirm({ select = true }) then
+              vim.fn.feedkeys(${defaultKeys}, 'n')
+            end
+          end
+        '')
+      (mkSetLuaBinding mappings.next ''
+        function()
+          local has_words_before = function()
+            local line, col = unpack(vim.api.nvim_win_get_cursor(0))
+            return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
+          end
+
+          local cmp = require('cmp')
+
+          local feedkey = function(key, mode)
+            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
+          end
+
+          if cmp.visible() then
+            cmp.select_next_item()
+          elseif vim.fn['vsnip#available'](1) == 1 then
+            feedkey("<Plug>(vsnip-expand-or-jump)", "")
+          elseif has_words_before() then
+            cmp.complete()
+          else
+            local termcode = vim.api.nvim_replace_termcodes(${toJSON mappings.next.value}, true, false, true)
+
+            vim.fn.feedkeys(termcode, 'n')
+          end
+        end
+      '')
+      (mkSetLuaBinding mappings.previous ''
+        function()
+          local cmp = require('cmp')
+
+          local feedkey = function(key, mode)
+            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
+          end
+
+          if cmp.visible() then
+            cmp.select_prev_item()
+          elseif vim.fn['vsnip#available'](-1) == 1 then
+            feedkeys("<Plug>(vsnip-jump-prev)", "")
+          end
+        end
+      '')
+      (mkSetLuaBinding mappings.close ''
+        require('cmp').mapping.abort()
+      '')
+      (mkSetLuaBinding mappings.scrollDocsUp ''
+        require('cmp').mapping.scroll_docs(-4)
+      '')
+      (mkSetLuaBinding mappings.scrollDocsDown ''
+        require('cmp').mapping.scroll_docs(4)
+      '')
+    ];
+
+    vim.maps.command = mkMerge [
+      (mkSetLuaBinding mappings.complete ''
+        require('cmp').complete
+      '')
+      (mkSetLuaBinding mappings.close ''
+        require('cmp').mapping.close()
+      '')
+      (mkSetLuaBinding mappings.scrollDocsUp ''
+        require('cmp').mapping.scroll_docs(-4)
+      '')
+      (mkSetLuaBinding mappings.scrollDocsDown ''
+        require('cmp').mapping.scroll_docs(4)
+      '')
+    ];
+
+    vim.maps.select = mkMerge [
+      (mkSetLuaBinding mappings.next ''
+        function()
+          local cmp = require('cmp')
+          local has_words_before = function()
+            local line, col = unpack(vim.api.nvim_win_get_cursor(0))
+            return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
+          end
+
+          local feedkey = function(key, mode)
+            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
+          end
+
+          if cmp.visible() then
+            cmp.select_next_item()
+          elseif vim.fn['vsnip#available'](1) == 1 then
+            feedkey("<Plug>(vsnip-expand-or-jump)", "")
+          elseif has_words_before() then
+            cmp.complete()
+          else
+            local termcode = vim.api.nvim_replace_termcodes(${toJSON mappings.next.value}, true, false, true)
+
+            vim.fn.feedkeys(termcode, 'n')
+          end
+        end
+      '')
+      (mkSetLuaBinding mappings.previous ''
+        function()
+          local cmp = require('cmp')
+
+          local feedkey = function(key, mode)
+            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true)
+          end
+
+          if cmp.visible() then
+            cmp.select_prev_item()
+          elseif vim.fn['vsnip#available'](-1) == 1 then
+            feedkeys("<Plug>(vsnip-jump-prev)", "")
+          end
+        end
+      '')
+    ];
+
+    # TODO: alternative snippet engines to vsnip
+    # https://github.com/hrsh7th/nvim-cmp/blob/main/doc/cmp.txt#L82
+    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 = ({
+          ${builtMaps}
+        })[entry.source.name]
+        return vim_item
+      end
+
+      ${optionalString lspkindEnabled ''
+        lspkind_opts.before = ${cfg.formatting.format}
+      ''}
+
+      local cmp = require'cmp'
+      cmp.setup({
+        ${optionalString config.vim.ui.borders.enable ''
+        -- explicitly enabled by setting ui.borders.enable = true
+        -- TODO: try to get nvim-cmp to follow global border style
+        window = {
+          completion = cmp.config.window.bordered(),
+          documentation = cmp.config.window.bordered(),
+        },
+      ''}
+
+        snippet = {
+          expand = function(args)
+            vim.fn["vsnip#anonymous"](args.body)
+          end,
+        },
+
+        sources = {
+          ${builtSources}
+        },
+
+        completion = {
+          completeopt = 'menu,menuone,noinsert',
+          ${optionalString (!cfg.alwaysComplete) "autocomplete = false"}
+        },
+
+        formatting = {
+          format =
+      ${
+        if lspkindEnabled
+        then "lspkind.cmp_format(lspkind_opts)"
+        else cfg.formatting.format
+      },
+        }
+      })
+      ${optionalString (config.vim.autopairs.enable && config.vim.autopairs.type == "nvim-autopairs") ''
+        local cmp_autopairs = require('nvim-autopairs.completion.cmp')
+        cmp.event:on('confirm_done', cmp_autopairs.on_confirm_done({ map_char = { text = ""} }))
+      ''}
+    '');
+
+    vim.snippets.vsnip.enable =
+      if (cfg.type == "nvim-cmp")
+      then true
+      else config.vim.snippets.vsnip.enable;
   };
 }

modules/plugins/completion/nvim-cmp/default.nix

@@ -1,4 +1,4 @@
-{
+_: {
   imports = [
     ./config.nix
     ./nvim-cmp.nix

modules/plugins/completion/nvim-cmp/nvim-cmp.nix

@@ -1,103 +1,72 @@
-{
+{lib, ...}: let
-  lib,
+  inherit (lib.options) mkEnableOption mkOption literalMD;
-  config,
-  ...
-}: let
-  inherit (lib.options) mkEnableOption mkOption literalExpression literalMD;
-  inherit (lib.types) str attrsOf nullOr either;
-  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.binds) mkMappingOption;
-  inherit (lib.nvim.types) mkPluginSetupOption luaInline mergelessListOf;
+  inherit (lib.types) enum attrsOf nullOr str bool;
-  inherit (lib.nvim.lua) toLuaObject;
-  inherit (builtins) isString;
-
-  cfg = config.vim.autocomplete.nvim-cmp;
 in {
-  options.vim.autocomplete.nvim-cmp = {
+  options.vim = {
-    enable = mkEnableOption "nvim-cmp";
+    autocomplete = {
-    setupOpts = mkPluginSetupOption "the autocomplete plugin" {
+      enable = mkEnableOption "autocomplete" // {default = false;};
-      completion.completeopt = mkOption {
-        type = str;
-        default = "menu,menuone,noinsert";
-        description = ''
-          A comma-separated list of options for completion.
 
-          See `:help completeopt` for the complete list.
+      alwaysComplete = mkOption {
+        type = bool;
+        description = "Automatically show completion.";
+        default = true;
+      };
+
+      mappings = {
+        complete = mkMappingOption "Complete [nvim-cmp]" "<C-Space>";
+        confirm = mkMappingOption "Confirm [nvim-cmp]" "<CR>";
+        next = mkMappingOption "Next item [nvim-cmp]" "<Tab>";
+        previous = mkMappingOption "Previous item [nvim-cmp]" "<S-Tab>";
+        close = mkMappingOption "Close [nvim-cmp]" "<C-e>";
+        scrollDocsUp = mkMappingOption "Scroll docs up [nvim-cmp]" "<C-d>";
+        scrollDocsDown = mkMappingOption "Scroll docs down [nvim-cmp]" "<C-f>";
+      };
+
+      type = mkOption {
+        type = enum ["nvim-cmp"];
+        default = "nvim-cmp";
+        description = "Set the autocomplete plugin. Options: [nvim-cmp]";
+      };
+
+      sources = mkOption {
+        description = ''
+          Attribute set of source names for nvim-cmp.
+
+          If an attribute set is provided, then the menu value of
+          `vim_item` in the format will be set to the value (if
+          utilizing the `nvim_cmp_menu_map` function).
+
+          Note: only use a single attribute name per attribute set
+        '';
+        type = attrsOf (nullOr str);
+        default = {};
+        example = ''
+          {nvim-cmp = null; buffer = "[Buffer]";}
         '';
       };
 
-      sorting.comparators = mkOption {
+      formatting = {
-        type = mergelessListOf (either str luaInline);
+        format = mkOption {
-        default = [
+          description = ''
-          "offset"
+            The function used to customize the appearance of the completion menu.
-          "exact"
-          "score"
-          "kind"
-          "length"
-          "sort_text"
-        ];
-        description = ''
-          The comparator functions used for sorting completions.
 
-          You can either pass a valid inline lua function
+            If [](#opt-vim.lsp.lspkind.enable) is true, then the function
-          (see `:help cmp-config.sorting.comparators`),
+            will be called before modifications from lspkind.
-          or a string, in which case the builtin comparator with that name will
+
-          be used.
+            Default is to call the menu mapping function.
-        '';
+          '';
-        apply = map (
+          type = str;
-          c:
+          default = "nvim_cmp_menu_map";
-            if isString c
+          example = literalMD ''
-            then mkLuaInline ("cmp.config.compare." + c)
+            ```lua
-            else c
+            function(entry, vim_item)
-        );
+              return vim_item
+            end
+            ```
+          '';
+        };
       };
     };
-
-    mappings = {
-      complete = mkMappingOption "Complete [nvim-cmp]" "<C-Space>";
-      confirm = mkMappingOption "Confirm [nvim-cmp]" "<CR>";
-      next = mkMappingOption "Next item [nvim-cmp]" "<Tab>";
-      previous = mkMappingOption "Previous item [nvim-cmp]" "<S-Tab>";
-      close = mkMappingOption "Close [nvim-cmp]" "<C-e>";
-      scrollDocsUp = mkMappingOption "Scroll docs up [nvim-cmp]" "<C-d>";
-      scrollDocsDown = mkMappingOption "Scroll docs down [nvim-cmp]" "<C-f>";
-    };
-
-    format = mkOption {
-      type = luaInline;
-      default = mkLuaInline ''
-        function(entry, vim_item)
-          vim_item.menu = (${toLuaObject cfg.sources})[entry.source.name]
-          return vim_item
-        end
-      '';
-      defaultText = literalMD ''
-        ```lua
-        function(entry, vim_item)
-          vim_item.menu = (''${toLuaObject config.vim.autocomplete.nvim-cmp.sources})[entry.source.name]
-          return vim_item
-        end
-        ```
-      '';
-      description = ''
-        The function used to customize the completion menu entires. This is
-        outside of `setupOpts` to allow for an easier integration with
-        lspkind.nvim.
-
-        See `:help cmp-config.formatting.format`.
-      '';
-    };
-
-    sources = mkOption {
-      type = attrsOf (nullOr str);
-      default = {};
-      description = "The list of sources used by nvim-cmp";
-      example = literalExpression ''
-        {
-          nvim-cmp = null;
-          buffer = "[Buffer]";
-        }
-      '';
-    };
   };
 }

modules/plugins/languages/rust.nix

@@ -9,7 +9,7 @@
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.strings) optionalString;
   inherit (lib.trivial) boolToString;
-  inherit (lib.lists) isList;
+  inherit (lib.lists) isList optionals;
   inherit (lib.types) bool package str listOf either enum;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
@@ -101,7 +101,7 @@ in {
       vim = {
         startPlugins = ["crates-nvim"];
         lsp.null-ls.enable = mkIf cfg.crates.codeActions true;
-        autocomplete.nvim-cmp.sources = {crates = "[Crates]";};
+        autocomplete.sources = {"crates" = "[Crates]";};
         pluginRC.rust-crates = entryAnywhere ''
           require('crates').setup {
             null_ls = {

modules/plugins/lsp/config.nix

@@ -11,7 +11,7 @@
   inherit (lib.nvim.binds) addDescriptionsToMappings;
 
   cfg = config.vim.lsp;
-  usingNvimCmp = config.vim.autocomplete.nvim-cmp.enable;
+  usingNvimCmp = config.vim.autocomplete.enable && config.vim.autocomplete.type == "nvim-cmp";
   self = import ./module.nix {inherit config lib pkgs;};
 
   mappingDefinitions = self.options.vim.lsp.mappings;
@@ -25,7 +25,7 @@ in {
     vim = {
       startPlugins = optional usingNvimCmp "cmp-nvim-lsp";
 
-      autocomplete.nvim-cmp.sources = {nvim_lsp = "[LSP]";};
+      autocomplete.sources = {"nvim_lsp" = "[LSP]";};
 
       pluginRC.lsp-setup = ''
         vim.g.formatsave = ${boolToString cfg.formatOnSave};

modules/plugins/lsp/lspkind/config.nix

@@ -3,32 +3,18 @@
   lib,
   ...
 }: let
-  inherit (lib.modules) mkIf mkForce;
+  inherit (lib.modules) mkIf;
-  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.dag) entryAnywhere;
-  inherit (lib.nvim.lua) toLuaObject;
 
-  cfg = config.vim.lsp.lspkind;
+  cfg = config.vim.lsp;
 in {
-  config = mkIf cfg.enable {
+  config = mkIf (cfg.enable && cfg.lspkind.enable) {
-    assertions = [
+    vim.startPlugins = ["lspkind"];
-      {
+    vim.pluginRC.lspkind = entryAnywhere ''
-        assertion = config.vim.autocomplete.nvim-cmp.enable;
+      local lspkind = require'lspkind'
-        message = ''
+      local lspkind_opts = {
-          While lspkind supports Neovim's native lsp upstream, using that over
+        mode = '${cfg.lspkind.mode}'
-          nvim-cmp isn't recommended, nor supported by nvf.
-
-          Please migrate to nvim-cmp if you want to use lspkind.
-        '';
       }
-    ];
+    '';
-
-    vim = {
-      startPlugins = ["lspkind"];
-
-      lsp.lspkind.setupOpts.before = config.vim.autocomplete.nvim-cmp.format;
-      autocomplete.nvim-cmp.setupOpts.formatting.format = mkForce (mkLuaInline ''
-        require("lspkind").cmp_format(${toLuaObject cfg.setupOpts})
-      '');
-    };
   };
 }

modules/plugins/lsp/lspkind/lspkind.nix

@@ -1,22 +1,16 @@
 {lib, ...}: let
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) enum nullOr;
+  inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkPluginSetupOption luaInline;
 in {
-  options.vim.lsp.lspkind = {
+  options.vim.lsp = {
-    enable = mkEnableOption "vscode-like pictograms for lsp [lspkind]";
+    lspkind = {
-    setupOpts = mkPluginSetupOption "lspkind.nvim" {
+      enable = mkEnableOption "vscode-like pictograms for lsp [lspkind]";
+
       mode = mkOption {
         description = "Defines how annotations are shown";
         type = enum ["text" "text_symbol" "symbol_text" "symbol"];
         default = "symbol_text";
       };
-
-      before = mkOption {
-        description = "The function that will be called before lspkind's modifications are applied";
-        type = nullOr luaInline;
-        default = null;
-      };
     };
   };
 }

modules/plugins/notes/obsidian/obsidian.nix

@@ -45,10 +45,10 @@ in {
 
         completion = {
           nvim_cmp = mkOption {
-            # If using nvim-cmp, otherwise set to false
+            # if using nvim-cmp, otherwise set to false
             type = bool;
             description = "If using nvim-cmp, otherwise set to false";
-            default = config.vim.autocomplete.nvim-cmp.enable;
+            default = config.vim.autocomplete.type == "nvim-cmp";
           };
         };
       };

modules/plugins/snippets/default.nix

@@ -1,5 +1,5 @@
 {
   imports = [
-    ./luasnip
+    ./vsnip
   ];
 }

modules/plugins/snippets/luasnip/config.nix

@@ -1,17 +0,0 @@
-{
-  config,
-  lib,
-  ...
-}: let
-  inherit (lib.modules) mkIf;
-
-  cfg = config.vim.snippets.luasnip;
-in {
-  config = mkIf cfg.enable {
-    vim = {
-      startPlugins = ["luasnip" "cmp-luasnip"] ++ cfg.providers;
-      autocomplete.nvim-cmp.sources = {luasnip = "[LuaSnip]";};
-      pluginRC.luasnip = cfg.loaders;
-    };
-  };
-}

modules/plugins/snippets/luasnip/default.nix

@@ -1,6 +0,0 @@
-{
-  imports = [
-    ./luasnip.nix
-    ./config.nix
-  ];
-}

modules/plugins/snippets/luasnip/luasnip.nix

@@ -1,36 +0,0 @@
-{lib, ...}: let
-  inherit (lib.options) mkEnableOption mkOption literalExpression literalMD;
-  inherit (lib.types) listOf lines;
-  inherit (lib.nvim.types) pluginType;
-in {
-  options.vim.snippets.luasnip = {
-    enable = mkEnableOption "luasnip";
-    providers = mkOption {
-      type = listOf pluginType;
-      default = ["friendly-snippets"];
-      description = ''
-        The snippet provider packages.
-
-        ::: {.note}
-        These are simply appended to {option} `vim.startPlugins`.
-        :::
-      '';
-      example = literalExpression "[\"vimPlugins.vim-snippets\"]";
-    };
-    loaders = mkOption {
-      type = lines;
-      default = "require('luasnip.loaders.from_vscode').lazy_load()";
-      defaultText = literalMD ''
-        ```lua
-        require('luasnip.loaders.from_vscode').lazy_load()
-        ```
-      '';
-      description = "Lua code used to load snippet providers.";
-      example = literalMD ''
-        ```lua
-        require("luasnip.loaders.from_snipmate").lazy_load()
-        ```
-      '';
-    };
-  };
-}

modules/plugins/snippets/vsnip/config.nix

@@ -0,0 +1,13 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf;
+
+  cfg = config.vim.snippets.vsnip;
+in {
+  config = mkIf cfg.enable {
+    vim.startPlugins = ["vim-vsnip"];
+  };
+}

modules/plugins/snippets/vsnip/default.nix

@@ -0,0 +1,5 @@
+{
+  imports = [
+    ./vsnip.nix
+  ];
+}

modules/plugins/snippets/vsnip/vsnip.nix

@@ -0,0 +1,7 @@
+{lib, ...}: let
+  inherit (lib.options) mkEnableOption;
+in {
+  options.vim.snippets.vsnip = {
+    enable = mkEnableOption "vim-vsnip: snippet LSP/VSCode's format";
+  };
+}

modules/plugins/theme/theme.nix

@@ -4,11 +4,10 @@
   ...
 }: let
   inherit (lib.options) mkOption;
-  inherit (lib.attrsets) attrNames;
+  inherit (lib.attrsets) attrNames listToAttrs;
   inherit (lib.strings) hasPrefix;
   inherit (lib.types) bool lines enum;
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.dag) entryBefore;
   inherit (lib.nvim.types) hexColor;
 
@@ -18,8 +17,7 @@
   };
 
   numbers = ["0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F"];
-  base16Options =
+  base16Options = listToAttrs (map (n: {
-    mapListToAttrs (n: {
       name = "base0${n}";
       value = mkOption {
         description = "The base0${n} color to use";
@@ -30,7 +28,7 @@
           else "#${v}";
       };
     })
-    numbers;
+    numbers);
 in {
   options.vim.theme = {
     enable = mkOption {

modules/plugins/treesitter/config.nix

@@ -11,7 +11,7 @@
   inherit (lib.nvim.dag) entryBefore entryAfter;
 
   cfg = config.vim.treesitter;
-  usingNvimCmp = config.vim.autocomplete.nvim-cmp.enable;
+  usingNvimCmp = config.vim.autocomplete.enable && config.vim.autocomplete.type == "nvim-cmp";
 
   self = import ./treesitter.nix {inherit pkgs lib;};
   mappingDefinitions = self.options.vim.treesitter.mappings;
@@ -21,7 +21,7 @@ in {
     vim = {
       startPlugins = ["nvim-treesitter"] ++ optional usingNvimCmp "cmp-treesitter";
 
-      autocomplete.nvim-cmp.sources = {treesitter = "[Treesitter]";};
+      autocomplete.sources = {"treesitter" = "[Treesitter]";};
       treesitter.grammars = optionals cfg.addDefaultGrammars cfg.defaultGrammars;
 
       maps = {

modules/plugins/ui/noice/noice.nix

@@ -21,7 +21,7 @@ in {
             mkBool true "override the lsp markdown formatter with Noice";
 
           "cmp.entry.get_documentation" =
-            mkBool config.vim.autocomplete.nvim-cmp.enable "override cmp documentation with Noice";
+            mkBool (config.vim.autocomplete.type == "nvim-cmp") "override cmp documentation with Noice";
         };
 
         signature = {