mirror of
https://github.com/nix-community/nixvim.git
synced 2025-06-21 08:35:43 +02:00
717 lines
22 KiB
Nix
717 lines
22 KiB
Nix
{
|
|
lib,
|
|
helpers,
|
|
pkgs,
|
|
config,
|
|
...
|
|
} @ args:
|
|
with lib; let
|
|
cfg = config.plugins.nvim-cmp;
|
|
cmpLib = import ./cmp-helpers.nix args;
|
|
|
|
snippetEngines = {
|
|
"vsnip" = ''vim.fn["vsnip#anonymous"](args.body)'';
|
|
"luasnip" = ''require('luasnip').lsp_expand(args.body)'';
|
|
"snippy" = ''require('snippy').expand_snippet(args.body)'';
|
|
"ultisnips" = ''vim.fn["UltiSnips#Anon"](args.body)'';
|
|
};
|
|
in {
|
|
options.plugins.nvim-cmp =
|
|
helpers.extraOptionsOptions
|
|
// {
|
|
enable = mkEnableOption "nvim-cmp";
|
|
|
|
package = helpers.mkPackageOption "nvim-cmp" pkgs.vimPlugins.nvim-cmp;
|
|
|
|
performance = {
|
|
debounce = helpers.defaultNullOpts.mkInt 60 ''
|
|
Sets debounce time
|
|
This is the interval used to group up completions from different sources
|
|
for filtering and displaying.
|
|
'';
|
|
|
|
throttle = helpers.defaultNullOpts.mkInt 30 ''
|
|
Sets throttle time.
|
|
This is used to delay filtering and displaying completions.
|
|
'';
|
|
|
|
fetchingTimeout = helpers.defaultNullOpts.mkInt 500 ''
|
|
Sets the timeout of candidate fetching process.
|
|
The nvim-cmp will wait to display the most prioritized source.
|
|
'';
|
|
|
|
asyncBudget = helpers.defaultNullOpts.mkInt 1 ''
|
|
Maximum time (in ms) an async function is allowed to run during one step of the event loop.
|
|
'';
|
|
|
|
maxViewEntries = helpers.defaultNullOpts.mkInt 200 ''
|
|
Maximum number of items to show in the entries list.
|
|
'';
|
|
};
|
|
|
|
preselect = helpers.defaultNullOpts.mkEnumFirstDefault ["Item" "None"] ''
|
|
- "Item": nvim-cmp will preselect the item that the source specified.
|
|
- "None": nvim-cmp will not preselect any items.
|
|
'';
|
|
|
|
mapping = mkOption {
|
|
default = null;
|
|
type = with types;
|
|
nullOr
|
|
(
|
|
attrsOf
|
|
(
|
|
either
|
|
str
|
|
(
|
|
submodule {
|
|
options = {
|
|
action = mkOption {
|
|
type = nonEmptyStr;
|
|
description = "The function the mapping should call";
|
|
example = ''"cmp.mapping.scroll_docs(-4)"'';
|
|
};
|
|
modes = mkOption {
|
|
default = null;
|
|
type = nullOr (listOf 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
|
|
'';
|
|
};
|
|
};
|
|
};
|
|
|
|
mappingPresets = mkOption {
|
|
default = [];
|
|
type = types.listOf (types.enum [
|
|
"insert"
|
|
"cmdline"
|
|
]);
|
|
description = ''
|
|
Mapping presets to use; cmp.mapping.preset.
|
|
\$\{mappingPreset} will be called with the configured mappings.
|
|
'';
|
|
example = ''[ "insert" "cmdline" ]'';
|
|
};
|
|
|
|
snippet = {
|
|
expand =
|
|
helpers.mkNullOrOption
|
|
(
|
|
with types;
|
|
either
|
|
helpers.rawType
|
|
(enum (attrNames snippetEngines))
|
|
)
|
|
''
|
|
The snippet expansion function. That's how nvim-cmp interacts with a
|
|
particular snippet engine.
|
|
|
|
You may directly provide one of those four supported engines:
|
|
- vsnip
|
|
- luasnip
|
|
- snippy
|
|
- ultisnips
|
|
|
|
You can also provide a custom function:
|
|
```nix
|
|
{
|
|
__raw = \'\'
|
|
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
|
|
\'\';
|
|
};
|
|
```
|
|
'';
|
|
};
|
|
|
|
completion = {
|
|
keywordLength = helpers.defaultNullOpts.mkInt 1 ''
|
|
The number of characters needed to trigger auto-completion.
|
|
'';
|
|
|
|
keywordPattern =
|
|
helpers.defaultNullOpts.mkStr
|
|
''\%(-\?\d\+\%(\.\d\+\)\?\|\h\w*\%(-\w*\)*\)''
|
|
''
|
|
The default keyword pattern.
|
|
|
|
Note: the provided pattern will be embedded as such: `[[PATTERN]]`.
|
|
'';
|
|
|
|
autocomplete =
|
|
helpers.defaultNullOpts.mkNullable
|
|
(
|
|
with types;
|
|
either
|
|
(listOf str)
|
|
(types.enum [false])
|
|
)
|
|
''[ "TextChanged" ]''
|
|
''
|
|
The event to trigger autocompletion.
|
|
If set to `"false"`, then completion is only invoked manually
|
|
(e.g. by calling `cmp.complete`).
|
|
'';
|
|
|
|
completeopt = helpers.defaultNullOpts.mkStr "menu,menuone,noselect" ''
|
|
Like vim's completeopt setting. In general, you don't need to change this.
|
|
'';
|
|
};
|
|
|
|
confirmation = {
|
|
getCommitCharacters =
|
|
helpers.defaultNullOpts.mkStr
|
|
''
|
|
function(commit_characters)
|
|
return commit_characters
|
|
end
|
|
''
|
|
''
|
|
You can append or exclude commitCharacters via this configuration option
|
|
function. The commitCharacters are defined by the LSP spec.
|
|
'';
|
|
};
|
|
|
|
formatting = {
|
|
expandableIndicator = helpers.defaultNullOpts.mkBool true ''
|
|
Boolean to show the `~` expandable indicator in cmp's floating window.
|
|
'';
|
|
|
|
fields =
|
|
helpers.defaultNullOpts.mkNullable
|
|
(with types; listOf str)
|
|
''[ "kind" "abbr" "menu" ]''
|
|
"An array of completion fields to specify their order.";
|
|
|
|
format =
|
|
helpers.defaultNullOpts.mkStr
|
|
''
|
|
function(_, vim_item)
|
|
return vim_item
|
|
end
|
|
''
|
|
''
|
|
`fun(entry: cmp.Entry, vim_item: vim.CompletedItem): vim.CompletedItem`
|
|
The function used to customize the appearance of the completion menu. See
|
|
|complete-items|. This value can also be used to modify the `dup` property.
|
|
NOTE: The `vim.CompletedItem` can contain the special properties
|
|
`abbr_hl_group`, `kind_hl_group` and `menu_hl_group`.
|
|
'';
|
|
};
|
|
|
|
matching = {
|
|
disallowFuzzyMatching = helpers.defaultNullOpts.mkBool false ''
|
|
Whether to allow fuzzy matching.
|
|
'';
|
|
|
|
disallowFullfuzzyMatching = helpers.defaultNullOpts.mkBool false ''
|
|
Whether to allow full-fuzzy matching.
|
|
'';
|
|
|
|
disallowPartialFuzzyMatching = helpers.defaultNullOpts.mkBool true ''
|
|
Whether to allow fuzzy matching without prefix matching.
|
|
'';
|
|
|
|
disallowPartialMatching = helpers.defaultNullOpts.mkBool false ''
|
|
Whether to allow partial matching.
|
|
'';
|
|
|
|
disallowPrefixUnmatching = helpers.defaultNullOpts.mkBool false ''
|
|
Whether to allow prefix unmatching.
|
|
'';
|
|
};
|
|
|
|
sorting = {
|
|
priorityWeight = helpers.defaultNullOpts.mkInt 2 ''
|
|
Each item's original priority (given by its corresponding source) will be
|
|
increased by `#sources - (source_index - 1)` and multiplied by `priority_weight`.
|
|
That is, the final priority is calculated by the following formula:
|
|
|
|
`final_score = orig_score + ((#sources - (source_index - 1)) * sorting.priority_weight)`
|
|
'';
|
|
|
|
comparators =
|
|
helpers.defaultNullOpts.mkNullable (types.listOf types.str)
|
|
''[ "offset" "exact" "score" "recently_used" "locality" "kind" "length" "order" ]''
|
|
''
|
|
The function to customize the sorting behavior.
|
|
You can use built-in comparators via `cmp.config.compare.*`.
|
|
|
|
Signature: `(fun(entry1: cmp.Entry, entry2: cmp.Entry): boolean | nil)[]`
|
|
'';
|
|
};
|
|
|
|
autoEnableSources = mkOption {
|
|
type = types.bool;
|
|
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 = helpers.mkNullOrOption types.attrs ''
|
|
Any specific options defined by the source itself.
|
|
|
|
If direct lua code is needed use `helpers.mkRaw`.
|
|
'';
|
|
|
|
keywordLength = helpers.mkNullOrOption types.int ''
|
|
The source-specific keyword length to trigger auto completion.
|
|
'';
|
|
|
|
keywordPattern = helpers.mkNullOrOption types.str ''
|
|
The source-specific keyword pattern.
|
|
|
|
Note: the provided pattern will be embedded as such: `[[PATTERN]]`.
|
|
'';
|
|
|
|
triggerCharacters = helpers.mkNullOrOption (with types; listOf str) ''
|
|
A source-specific keyword pattern.
|
|
'';
|
|
|
|
priority = helpers.mkNullOrOption types.int "The source-specific priority value.";
|
|
|
|
groupIndex = helpers.mkNullOrOption types.int ''
|
|
The source group index.
|
|
|
|
For instance, you can set the `buffer`'s source `groupIndex` to a larger number
|
|
if you don't want to see `buffer` source items while `nvim-lsp` source is available:
|
|
|
|
```nix
|
|
sources = [
|
|
{
|
|
name = "nvim_lsp";
|
|
groupIndex = 1;
|
|
}
|
|
{
|
|
name = "buffer";
|
|
groupIndex = 2;
|
|
}
|
|
];
|
|
```
|
|
'';
|
|
|
|
entryFilter = helpers.mkNullOrOption types.str ''
|
|
A source-specific entry filter, with the following function signature:
|
|
|
|
`function(entry: cmp.Entry, ctx: cmp.Context): boolean`
|
|
|
|
Returning `true` will keep the entry, while returning `false` will remove it.
|
|
|
|
This can be used to hide certain entries from a given source. For instance, you
|
|
could hide all entries with kind `Text` from the `nvim_lsp` filter using the
|
|
following source definition:
|
|
|
|
```
|
|
{
|
|
name = 'nvim_lsp',
|
|
entry_filter = function(entry, ctx)
|
|
return require('cmp.types').lsp.CompletionItemKind[entry:get_kind()] ~= 'Text'
|
|
end
|
|
}
|
|
```
|
|
|
|
Using the `ctx` parameter, you can further customize the behaviour of the source.
|
|
'';
|
|
};
|
|
};
|
|
in
|
|
mkOption {
|
|
default = null;
|
|
type = with types;
|
|
nullOr
|
|
(
|
|
listOf
|
|
(
|
|
either
|
|
source_config
|
|
(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`.
|
|
|
|
Default: `[]`
|
|
'';
|
|
example = ''
|
|
[
|
|
{ name = "nvim_lsp"; }
|
|
{ name = "luasnip"; } #For luasnip users.
|
|
{ name = "path"; }
|
|
{ name = "buffer"; }
|
|
]
|
|
'';
|
|
};
|
|
|
|
view = {
|
|
entries =
|
|
helpers.defaultNullOpts.mkNullable (with types; either str attrs)
|
|
''
|
|
{
|
|
name = "custom";
|
|
selection_order = "top_down";
|
|
}
|
|
''
|
|
''
|
|
The view class used to customize nvim-cmp's appearance.
|
|
'';
|
|
|
|
docs = {
|
|
autoOpen = helpers.defaultNullOpts.mkBool true ''
|
|
Specify whether to show the docs_view when selecting an item.
|
|
'';
|
|
};
|
|
};
|
|
|
|
window = let
|
|
# Reusable options
|
|
mkWinhighlightOption = default:
|
|
helpers.defaultNullOpts.mkStr
|
|
default
|
|
''
|
|
Specify the window's winhighlight option.
|
|
See |nvim_open_win|.
|
|
'';
|
|
|
|
zindex = helpers.mkNullOrOption types.int ''
|
|
The completion window's zindex.
|
|
See |nvim_open_win|.
|
|
'';
|
|
in {
|
|
completion = {
|
|
border =
|
|
helpers.defaultNullOpts.mkBorder
|
|
''[ "" "" "" "" "" "" "" "" ]''
|
|
"nvim-cmp window"
|
|
"";
|
|
|
|
winhighlight =
|
|
mkWinhighlightOption
|
|
"Normal:Pmenu,FloatBorder:Pmenu,CursorLine:PmenuSel,Search:None";
|
|
|
|
inherit zindex;
|
|
|
|
scrolloff = helpers.defaultNullOpts.mkInt 0 ''
|
|
Specify the window's scrolloff option.
|
|
See |'scrolloff'|.
|
|
'';
|
|
|
|
colOffset = helpers.defaultNullOpts.mkInt 0 ''
|
|
Offsets the completion window relative to the cursor.
|
|
'';
|
|
|
|
sidePadding = helpers.defaultNullOpts.mkInt 1 ''
|
|
The amount of padding to add on the completion window's sides.
|
|
'';
|
|
|
|
scrollbar = helpers.defaultNullOpts.mkBool true ''
|
|
Whether the scrollbar should be enabled if there are more items that fit
|
|
'';
|
|
};
|
|
|
|
documentation = {
|
|
border =
|
|
helpers.defaultNullOpts.mkBorder
|
|
''[ "" "" "" " " "" "" "" " " ]''
|
|
"nvim-cmp documentation window"
|
|
"";
|
|
|
|
winhighlight = mkWinhighlightOption "FloatBorder:NormalFloat";
|
|
|
|
inherit zindex;
|
|
|
|
maxWidth =
|
|
helpers.defaultNullOpts.mkNullable
|
|
(with types; either int str)
|
|
"math.floor((40 * 2) * (vim.o.columns / (40 * 2 * 16 / 9)))"
|
|
"The documentation window's max width.";
|
|
|
|
maxHeight =
|
|
helpers.defaultNullOpts.mkNullable
|
|
(with types; either int str)
|
|
"math.floor(40 * (40 / vim.o.lines))"
|
|
"The documentation window's max height.";
|
|
};
|
|
};
|
|
|
|
# This can be kept as types.attrs since experimental features are often removed or completely
|
|
# changed after a while
|
|
experimental = helpers.mkNullOrOption types.attrs "Experimental features";
|
|
};
|
|
|
|
config = let
|
|
setupOptions = with cfg;
|
|
{
|
|
performance = with performance; {
|
|
inherit
|
|
debounce
|
|
throttle
|
|
;
|
|
fetching_timeout = fetchingTimeout;
|
|
async_budget = asyncBudget;
|
|
max_view_entries = maxViewEntries;
|
|
};
|
|
preselect =
|
|
helpers.ifNonNull' preselect
|
|
(helpers.mkRaw "cmp.PreselectMode.${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 =
|
|
helpers.ifNonNull' mapping
|
|
(mapAttrs
|
|
(
|
|
key: action:
|
|
helpers.mkRaw (
|
|
if isString action
|
|
then action
|
|
else let
|
|
inherit (action) modes;
|
|
modesString =
|
|
optionalString
|
|
(
|
|
(modes != null)
|
|
&& ((length modes) >= 1)
|
|
)
|
|
("," + (helpers.toLuaObject modes));
|
|
in "cmp.mapping(${action.action}${modesString})"
|
|
)
|
|
)
|
|
mapping);
|
|
|
|
luaMappings = helpers.toLuaObject mappings;
|
|
|
|
wrapped =
|
|
lists.fold
|
|
(
|
|
presetName: prevString: ''cmp.mapping.preset.${presetName}(${prevString})''
|
|
)
|
|
luaMappings
|
|
mappingPresets;
|
|
in
|
|
helpers.mkRaw wrapped;
|
|
|
|
snippet = with snippet; {
|
|
expand =
|
|
if isString expand
|
|
then
|
|
helpers.mkRaw ''
|
|
function(args)
|
|
${snippetEngines.${expand}}
|
|
end
|
|
''
|
|
else expand;
|
|
};
|
|
|
|
completion = with completion; {
|
|
keyword_length = keywordLength;
|
|
keyword_pattern =
|
|
helpers.ifNonNull' keywordPattern
|
|
(helpers.mkRaw "[[${keywordPattern}]]");
|
|
autocomplete =
|
|
if isList autocomplete
|
|
then
|
|
map
|
|
(triggerEvent:
|
|
helpers.mkRaw "require('cmp.types').cmp.TriggerEvent.${triggerEvent}")
|
|
autocomplete
|
|
# either null or false
|
|
else autocomplete;
|
|
inherit completeopt;
|
|
};
|
|
|
|
confirmation = with confirmation; {
|
|
get_commit_characters =
|
|
if (isString getCommitCharacters)
|
|
then helpers.mkRaw getCommitCharacters
|
|
else getCommitCharacters;
|
|
};
|
|
|
|
formatting = with formatting; {
|
|
expandable_indicator = expandableIndicator;
|
|
inherit fields;
|
|
format = helpers.mkRaw format;
|
|
};
|
|
|
|
matching = with matching; {
|
|
disallow_fuzzy_matching = disallowFuzzyMatching;
|
|
disallow_fullfuzzy_matching = disallowFullfuzzyMatching;
|
|
disallow_partial_fuzzy_matching = disallowPartialFuzzyMatching;
|
|
disallow_partial_matching = disallowPartialMatching;
|
|
disallow_prefix_unmatching = disallowPrefixUnmatching;
|
|
};
|
|
|
|
sorting = with sorting; {
|
|
priority_weight = priorityWeight;
|
|
comparators =
|
|
helpers.ifNonNull' comparators
|
|
(
|
|
map
|
|
(
|
|
funcName:
|
|
helpers.mkRaw "require('cmp.config.compare').${funcName}"
|
|
)
|
|
comparators
|
|
);
|
|
};
|
|
|
|
sources = let
|
|
convertSourceAttrs = source:
|
|
with source; {
|
|
inherit
|
|
name
|
|
option
|
|
;
|
|
keyword_length = keywordLength;
|
|
keywordPattern =
|
|
helpers.ifNonNull' keywordPattern (helpers.mkRaw "[[${keywordPattern}]]");
|
|
trigger_characters = triggerCharacters;
|
|
inherit priority;
|
|
group_index = groupIndex;
|
|
entry_filter = entryFilter;
|
|
};
|
|
in
|
|
if sources == null || sources == []
|
|
then null
|
|
# List of lists of sources -> we use the `cmp.config.sources` helper
|
|
else if isList (head sources)
|
|
then let
|
|
sourcesListofLists =
|
|
map
|
|
(map convertSourceAttrs)
|
|
sources;
|
|
in
|
|
helpers.mkRaw "cmp.config.sources(${helpers.toLuaObject sourcesListofLists})"
|
|
# List of sources
|
|
else map convertSourceAttrs sources;
|
|
|
|
view = with view; {
|
|
inherit entries;
|
|
docs = with docs; {
|
|
auto_open = autoOpen;
|
|
};
|
|
};
|
|
window = with window; {
|
|
completion = with completion; {
|
|
inherit
|
|
border
|
|
winhighlight
|
|
zindex
|
|
scrolloff
|
|
;
|
|
col_offset = colOffset;
|
|
side_padding = sidePadding;
|
|
inherit scrollbar;
|
|
};
|
|
documentation = with documentation; {
|
|
inherit
|
|
border
|
|
winhighlight
|
|
zindex
|
|
;
|
|
max_width =
|
|
if isInt maxWidth
|
|
then maxWidth
|
|
else helpers.mkRaw maxWidth;
|
|
max_height =
|
|
if isInt maxHeight
|
|
then maxHeight
|
|
else helpers.mkRaw maxHeight;
|
|
};
|
|
};
|
|
inherit experimental;
|
|
}
|
|
// cfg.extraOptions;
|
|
in
|
|
mkIf cfg.enable {
|
|
extraPlugins = [cfg.package];
|
|
|
|
extraConfigLua = helpers.wrapDo ''
|
|
local cmp = require('cmp')
|
|
cmp.setup(${helpers.toLuaObject setupOptions})
|
|
'';
|
|
|
|
# If autoEnableSources is set to true, figure out which are provided by the user
|
|
# and enable the corresponding plugins.
|
|
plugins = let
|
|
sourcesFlattenedList =
|
|
if cfg.sources == null
|
|
then []
|
|
else flatten cfg.sources;
|
|
|
|
# Take only the names from the sources provided by the user
|
|
foundSources =
|
|
lists.unique
|
|
(
|
|
map
|
|
(source: source.name)
|
|
sourcesFlattenedList
|
|
);
|
|
|
|
# A list of known source names
|
|
knownSourceNames = attrNames cmpLib.pluginAndSourceNames;
|
|
|
|
attrsEnabled = listToAttrs (map
|
|
(name: {
|
|
# Name of the corresponding plugin to enable
|
|
name = cmpLib.pluginAndSourceNames.${name};
|
|
|
|
# Whether or not we enable it
|
|
value.enable = mkIf (elem name foundSources) true;
|
|
})
|
|
knownSourceNames);
|
|
in
|
|
mkMerge [
|
|
(mkIf cfg.autoEnableSources attrsEnabled)
|
|
(mkIf (elem "nvim_lsp" foundSources)
|
|
{
|
|
lsp.capabilities = ''
|
|
capabilities = require('cmp_nvim_lsp').default_capabilities()
|
|
'';
|
|
})
|
|
];
|
|
};
|
|
}
|