Adding nvim-cmp plugin (#25)

* started adding nvim-cmp

* nvim-cmp: added snippet option

* nvim-cmp: added mapping option

* nvim-cmp: added completion option

* nvim-cmp: added confirmation config option

* nvim-cmp: added formatting options

* nvim-cmp: added matching option

* nvim-cmp: added sorting option

* nvim-cmp: added sources option

* nvim-cmp: added a bunch of sources

* nvim-cmp: auto enabling cmp source plugins should mostly work now

* nvim-cmp: added view option

* nvim_cmp: added window option

* nvim-cmp: added experimental option

* nvim-cmp: mappingPresets now works
This commit is contained in:
Alexander Nortung 2022-07-28 21:38:38 +02:00 committed by GitHub
parent d40a8b99f3
commit f12a79bda6
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 465 additions and 0 deletions

View file

@ -0,0 +1,54 @@
{ lib, pkgs, ... }@attrs:
let
helpers = import ../../helpers.nix { lib = lib; };
in with helpers; with lib;
{
mkCmpSourcePlugin = { name, extraPlugins ? [], useDefaultPackage ? true, ... }: mkPlugin attrs {
inherit name;
extraPlugins = extraPlugins ++ (lists.optional useDefaultPackage pkgs.vimPlugins.${name});
description = "Enable ${name}";
};
pluginAndSourceNames = {
"luasnip" = "cmp_luasnip";
"snippy" = "cmp-snippy";
"ultisnips" = "cmp-nvim-ultisnips";
"vsnip" = "cmp-vsnip";
"buffer" = "cmp-buffer";
"calc" = "cmp-calc";
"dictionary" = "cmp-dictionary";
"digraphs" = "cmp-digraphs";
"omni" = "cmp-omni";
"spell" = "cmp-spell";
"nvim_lsp" = "cmp-nvim-lsp";
"nvim_lsp_document_symbol" = "cmp-nvim-lsp-document-symbol";
"nvim_lsp_signature_help" = "cmp-nvim-lsp-signature-help";
"vim_lsp" = "cmp-vim-lsp";
"path" = "cmp-path";
"git" = "cmp-git";
"conventionalcommits" = "cmp-conventionalcommits";
"cmdline" = "cmp-cmdline";
"cmp-cmdline-history" = "cmp-cmdline-history";
"fuzzy_buffer" = "cmp-fuzzy-buffer";
"fuzzy_path" = "cmp-fuzzy-path";
"rg" = "cmp-rg";
"fish" = "cmp-fish";
"tmux" = "cmp-tmux";
"zsh" = "cmp-zsh";
"crates" = "crates-nvim";
"npm" = "cmp-npm";
"cmp-clippy" = "cmp-clippy";
"cmp_tabnine" = "cmp-tabnine";
"copilot" = "cmp-copilot";
"dap" = "cmp-dap";
"emoji" = "cmp-emoji";
"greek" = "cmp-greek";
"latex_symbols" = "cmp-latex-symbols";
"look" = "cmp-look";
"nvim_lua" = "cmp-nvim-lua";
"pandoc_references" = "cmp-pandoc-references";
"cmp_pandoc" = "cmp-pandoc-nvim";
"treesitter" = "cmp-treesitter";
"vimwiki-tags" = "cmp-vimwiki-tags";
};
}

View file

@ -0,0 +1,397 @@
{ pkgs, config, lib, ... }@args:
with lib;
let
cfg = config.programs.nixvim.plugins.nvim-cmp;
helpers = import ../../helpers.nix { lib = lib; };
mkNullOrOption = helpers.mkNullOrOption;
cmpLib = import ./cmp-helpers.nix args;
# functionName should be a string
# parameters should be a list of strings
wrapWithFunction = functionName: parameters: let
parameterString = strings.concatStringsSep "," parameters;
in ''${functionName}(${parameterString})'';
in
{
options.programs.nixvim.plugins.nvim-cmp = {
enable = mkEnableOption "Enable nvim-cmp";
performance = mkOption {
default = null;
type = types.nullOr (types.submodule ({...}: {
options = {
debounce = mkOption {
type = types.nullOr types.int;
default = null;
};
throttle = mkOption {
type = types.nullOr types.int;
default = null;
};
};
}));
};
preselect = mkOption {
type = types.nullOr (types.enum [ "Item" "None" ]);
default = null;
example = ''"Item"'';
};
snippet = mkOption {
default = null;
type = types.nullOr (types.submodule ({...}: {
options = {
expand = mkOption {
type = types.nullOr types.str;
example = ''
function(args)
vim.fn["vsnip#anonymous"](args.body) -- For `vsnip` users.
-- require('luasnip').lsp_expand(args.body) -- For `luasnip` users.
-- require('snippy').expand_snippet(args.body) -- For `snippy` users.
-- vim.fn["UltiSnips#Anon"](args.body) -- For `ultisnips` users.
end
'';
};
};
}));
};
mappingPresets = mkOption {
default = [];
type = types.listOf (types.enum [
"insert"
"cmdline"
# Not sure if there are more or if this should just be str
]);
description = "Mapping presets to use; cmp.mapping.preset.\${mappingPreset} will be called with the configured mappings";
example = ''
[ "insert" "cmdline" ]
'';
};
mapping = mkOption {
default = null;
type = types.nullOr (types.attrsOf (types.either types.str (types.submodule ({...}: {
options = {
action = mkOption {
type = types.nonEmptyStr;
description = "The function the mapping should call";
example = ''"cmp.mapping.scroll_docs(-4)"'';
};
modes = mkOption {
default = null;
type = types.nullOr (types.listOf types.str);
example = ''[ "i" "s" ]'';
};
};
}))));
example = ''
{
"<CR>" = "cmp.mapping.confirm({ select = true })";
"<Tab>" = {
modes = [ "i" "s" ];
action = '${""}'
function(fallback)
if cmp.visible() then
cmp.select_next_item()
elseif luasnip.expandable() then
luasnip.expand()
elseif luasnip.expand_or_jumpable() then
luasnip.expand_or_jump()
elseif check_backspace() then
fallback()
else
fallback()
end
end
'${""}';
};
}
'';
};
completion = mkOption {
default = null;
type = types.nullOr (types.submodule ({...}: {
options = {
keyword_length = mkOption {
default = null;
type = types.nullOr types.int;
};
keyword_pattern = mkOption {
default = null;
type = types.nullOr types.str;
};
autocomplete = mkOption {
default = null;
type = types.nullOr types.str;
description = "Lua code for the event.";
example = ''"false"'';
};
completeopt = mkOption {
default = null;
type = types.nullOr types.str;
};
};
}));
};
confirmation = mkOption {
default = null;
type = types.nullOr (types.submodule ({...}: {
options = {
get_commit_characters = mkOption {
default = null;
type = types.nullOr types.str;
description = "Direct lua code as a string";
};
};
}));
};
formatting = mkOption {
default = null;
type = types.nullOr (types.submodule ({...}: {
options = {
fields = mkOption {
default = null;
type = types.nullOr (types.listOf types.str);
example = ''[ "kind" "abbr" "menu" ]'';
};
format = mkOption {
default = null;
type = types.nullOr types.str;
description = "A lua function as a string";
};
};
}));
};
matching = mkOption {
default = null;
type = types.nullOr (types.submodule ({...}: {
options = {
disallow_fuzzy_matching = mkOption {
default = null;
type = types.nullOr types.bool;
};
disallow_partial_matching = mkOption {
default = null;
type = types.nullOr types.bool;
};
disallow_prefix_unmatching = mkOption {
default = null;
type = types.nullOr types.bool;
};
};
}));
};
sorting = mkOption {
default = null;
type = types.nullOr (types.submodule ({...}: {
options = {
priority_weight = mkOption {
default = null;
type = types.nullOr types.int;
};
comparators = mkOption {
default = null;
type = types.nullOr types.str;
};
};
}));
};
auto_enable_sources = mkOption {
default = true;
description = ''
Scans the sources array and installs the plugins if they are known to nixvim.
'';
};
sources = let
source_config = types.submodule ({...}: {
options = {
name = mkOption {
type = types.str;
description = "The name of the source.";
example = ''"buffer"'';
};
option = mkOption {
default = null;
type = with types; nullOr (attrsOf anything);
description = "If direct lua code is needed use helpers.mkRaw";
};
keyword_length = mkOption {
default = null;
type = types.nullOr types.int;
};
keyword_pattern = mkOption {
default = null;
type = types.nullOr types.int;
};
trigger_characters = mkOption {
default = null;
type = with types; nullOr (listOf str);
};
priority = mkOption {
default = null;
type = types.nullOr types.int;
};
max_item_count = mkOption {
default = null;
type = types.nullOr types.int;
};
group_index = mkOption {
default = null;
type = types.nullOr types.int;
};
};
});
in mkOption {
default = null;
type = with types; nullOr (either (listOf source_config) (listOf (listOf source_config)));
description = ''
The sources to use.
Can either be a list of sourceConfigs which will be made directly to a Lua object.
Or it can be a list of lists, which will use the cmp built-in helper function `cmp.config.sources`.
'';
example = ''
[
{ name = "nvim_lsp"; }
{ name = "luasnip"; } #For luasnip users.
{ name = "path"; }
{ name = "buffer"; }
]
'';
};
view = mkOption {
default = null;
type = types.nullOr (types.submodule ({...}: {
options = {
entries = mkOption {
default = null;
type = with types; nullOr (either str attrs);
};
};
}));
};
window = let
# Reusable options
border = with types; mkNullOrOption (either str (listOf str)) null;
winhighlight = mkNullOrOption types.str null;
zindex = mkNullOrOption types.int null;
in mkOption {
default = null;
type = types.nullOr (types.submodule ({...}: {
options = {
completion = mkOption {
default = null;
type = types.nullOr (types.submodule ({...}: {
options = {
inherit border winhighlight zindex;
};
}));
};
documentation = mkOption {
default = null;
type = types.nullOr (types.submodule ({...}: {
options = {
inherit border winhighlight zindex;
max_width = mkNullOrOption types.int "Window's max width";
max_height = mkNullOrOption types.int "Window's max height";
};
}));
};
};
}));
};
# This can be kept as types.attrs since experimental features are often removed or completely changed after a while
experimental = mkNullOrOption types.attrs "Experimental features";
};
config = let
options = {
enabled = cfg.enable;
performance = cfg.performance;
preselect = if (isNull cfg.preselect) then null else helpers.mkRaw "cmp.PreselectMode.${cfg.preselect}";
# Not very readable sorry
# If null then null
# If an attribute is a string, just treat it as lua code for that mapping
# If an attribute is a module, create a mapping with cmp.mapping() using the action as the first input and the modes as the second.
mapping = let
mappings = if (isNull cfg.mapping) then null
else mapAttrs (bind: mapping: helpers.mkRaw (if isString mapping then mapping
else "cmp.mapping(${mapping.action}${optionalString (mapping.modes != null && length mapping.modes >= 1) ("," + (helpers.toLuaObject mapping.modes))})")) cfg.mapping;
luaMappings = (helpers.toLuaObject mappings);
wrapped = lists.fold (presetName: prevString: ''cmp.mapping.preset.${presetName}(${prevString})'') luaMappings cfg.mappingPresets;
in helpers.mkRaw wrapped;
snippet = {
expand = if (isNull cfg.snippet.expand) then null else helpers.mkRaw cfg.snippet.expand;
};
completion = if (isNull cfg.completion) then null else {
keyword_length = cfg.completion.keyword_length;
keyword_pattern = cfg.completion.keyword_pattern;
autocomplete = if (isNull cfg.completion.autocomplete) then null else mkRaw cfg.completion.autocomplete;
completeopt = cfg.completion.completeopt;
};
confirmation = if (isNull cfg.confirmation) then null else {
get_commit_characters =
if (isString cfg.confirmation.get_commit_characters) then helpers.mkRaw cfg.confirmation.get_commit_characters
else cfg.confirmation.get_commit_characters;
};
formatting = if (isNull cfg.formatting) then null else {
fields = cfg.formatting.fields;
format = if (isNull cfg.formatting.format) then null else helpers.mkRaw cfg.formatting.format;
};
matching = cfg.matching;
sorting = if (isNull cfg.sorting) then null else {
priority_weight = cfg.sorting.priority_weight;
comparators = if (isNull cfg.sorting.comparators) then null else helpers.mkRaw cfg.sorting.comparators;
};
sources = cfg.sources;
view = cfg.view;
window = cfg.window;
experimental = cfg.experimental;
};
in mkIf cfg.enable {
programs.nixvim = {
extraPlugins = [ pkgs.vimPlugins.nvim-cmp ];
extraConfigLua = ''
local cmp = require('cmp')
cmp.setup(${helpers.toLuaObject options})
'';
# If auto_enable_sources is set to true, figure out which are provided by the user
# and enable the corresponding plugins.
plugins = let
flattened_sources = if (isNull cfg.sources) then [] else flatten cfg.sources;
# Take only the names from the sources provided by the user
found_sources = lists.unique (lists.map (source: source.name) flattened_sources);
# A list of known source names
known_source_names = attrNames cmpLib.pluginAndSourceNames;
attrs_enabled = listToAttrs (map (name: {
name = cmpLib.pluginAndSourceNames.${name};
value.enable = mkIf (elem name found_sources) true;
}) known_source_names);
in mkIf cfg.auto_enable_sources attrs_enabled;
};
};
}

View file

@ -0,0 +1,12 @@
{ lib, pkgs, ... }@attrs:
with lib;
let
cmpLib = import ../cmp-helpers.nix attrs;
cmpSourcesPluginNames = lib.attrValues cmpLib.pluginAndSourceNames;
pluginModules = lists.map (name: cmpLib.mkCmpSourcePlugin { inherit name; }) cmpSourcesPluginNames;
in
{
# For extra cmp plugins
imports = [
] ++ pluginModules;
}

View file

@ -11,6 +11,8 @@
./colorschemes/tokyonight.nix ./colorschemes/tokyonight.nix
./completion/coq.nix ./completion/coq.nix
./completion/nvim-cmp
./completion/nvim-cmp/sources
./git/fugitive.nix ./git/fugitive.nix
./git/gitgutter.nix ./git/gitgutter.nix