1912 lines
52 KiB
Nix
1912 lines
52 KiB
Nix
{ lib }:
|
|
|
|
let
|
|
inherit (builtins) mapAttrs;
|
|
mkVimOptOption =
|
|
key:
|
|
{ type
|
|
, vimDefault
|
|
, default ? null
|
|
, description ? ""
|
|
, extraHelp ? [ ]
|
|
, apply ? null
|
|
}:
|
|
lib.mkOption {
|
|
type = lib.types.nullOr type;
|
|
inherit apply default;
|
|
defaultText = lib.literalExpression (builtins.toJSON vimDefault);
|
|
description = lib.concatLines (
|
|
[ description "" ]
|
|
++ map (help: "`:help ${help}") ([ key ] ++ extraHelp)
|
|
);
|
|
};
|
|
|
|
|
|
sharedGlobalOrWindow = with lib; with types; {
|
|
fillchars = {
|
|
type = listOf (enum [
|
|
"stl"
|
|
"stlnc"
|
|
"wbr"
|
|
"horiz"
|
|
"horizup"
|
|
"horizdown"
|
|
"vert"
|
|
"vertleft"
|
|
"vertright"
|
|
"verthoriz"
|
|
"fold"
|
|
"foldopen"
|
|
"foldclose"
|
|
"foldsep"
|
|
"diff"
|
|
"msgsep"
|
|
"eob"
|
|
"lastline"
|
|
]);
|
|
vimDefault = [ ];
|
|
description = ''
|
|
Characters to fill the statuslines, vertical separators and special lines in the window.
|
|
'';
|
|
};
|
|
};
|
|
|
|
sharedGlobalOrBuffer = with lib; with types; {
|
|
autoread = {
|
|
type = bool;
|
|
vimDefault = true;
|
|
description = ''
|
|
When a file has been detected to have been changed outside of Vim and
|
|
it has not been changed inside of Vim, automatically read it again.
|
|
When the file has been deleted this is not done, so you have the text
|
|
from before it was deleted. When it appears again then it is read.
|
|
'';
|
|
extraHelp = [ "timestamp" ];
|
|
};
|
|
|
|
backupcopy = {
|
|
type = listOf (enum [ "yes" "no" "auto" "breaksymlink" "breakhardlink" ]);
|
|
vimDefault = [ "auto" ];
|
|
description = ''
|
|
When writing a file and a backup is made, this option tells how it's
|
|
done. This is a comma-separated list of words.
|
|
'';
|
|
};
|
|
|
|
formatprg = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
The name of an external program that will be used to format the lines
|
|
selected with the |gq| operator. The program must take the input on
|
|
stdin and produce the output on stdout.
|
|
'';
|
|
};
|
|
|
|
grepprg = {
|
|
type = str;
|
|
vimDefault = ''
|
|
default "grep -n ",
|
|
Unix: "grep -n $* /dev/null"
|
|
'';
|
|
};
|
|
|
|
include = {
|
|
type = str;
|
|
vimDefault = ''^\s*#\s*include'';
|
|
description = ''
|
|
Pattern to be used to find an include command.
|
|
'';
|
|
};
|
|
|
|
keywordprg = {
|
|
type = str;
|
|
vimDefault = ''
|
|
Windows: ":help"
|
|
otherwise: ":Man"
|
|
'';
|
|
description = ''
|
|
Program to use for the |K| command.
|
|
'';
|
|
};
|
|
|
|
lispwords = {
|
|
type = listOf str;
|
|
vimDefault = is very long;
|
|
description = ''
|
|
list of words that influence the Lisp indenting when
|
|
enabled with the |'lisp'| option.
|
|
'';
|
|
};
|
|
|
|
makeencoding = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
Encoding used for reading the output of external commands. When empty,
|
|
encoding is not converted.
|
|
This is used for `:make`, `:lmake`, `:grep`, `:lgrep`, `:grepadd`,
|
|
`:lgrepadd`, `:cfile`, `:cgetfile`, `:caddfile`, `:lfile`, `:lgetfile`,
|
|
and `:laddfile`.
|
|
|
|
'';
|
|
};
|
|
};
|
|
|
|
global = with lib; with types; sharedGlobalOrWindow // sharedGlobalOrBuffer // {
|
|
allowrevins = {
|
|
type = bool;
|
|
description = ''
|
|
Allow CTRL-_ in Insert and Command-line mode. This is default off, to
|
|
avoid that users that accidentally type CTRL-_ instead of SHIFT-_ get
|
|
into reverse Insert mode, and don't know how to get out. See
|
|
|
|
'';
|
|
};
|
|
|
|
ambiwidth = {
|
|
type = (enum [ "single" "double" ]);
|
|
description = ''
|
|
Tells Vim what to do with characters with East Asian Width Class
|
|
Ambiguous (such as Euro, Registered Sign, Copyright Sign, Greek
|
|
letters, Cyrillic letters).
|
|
|
|
'';
|
|
};
|
|
|
|
autochdir = {
|
|
type = bool;
|
|
description = ''
|
|
When on, Vim will change the current working directory whenever you
|
|
open a file, switch buffers, delete a buffer or open/close a window.
|
|
It will change to the directory containing the file which was opened
|
|
or selected. When a buffer has no name it also has no directory, thus
|
|
the current directory won't change when navigating to it.
|
|
Note: When this option is on some plugins may not work.
|
|
|
|
'';
|
|
};
|
|
|
|
arabicshape = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
When on and 'termbidi' is off, the required visual character
|
|
corrections that need to take place for displaying the Arabic language
|
|
take effect.
|
|
|
|
'';
|
|
};
|
|
|
|
autowrite = {
|
|
type = bool;
|
|
description = ''
|
|
Write the contents of the file, if it has been modified, on each
|
|
`:next`, `:rewind`, `:last`, `:first`, `:previous`, `:stop`,
|
|
`:suspend`, `:tag`, `:!`, `:make`, CTRL-] and CTRL-^ command; and when
|
|
a `:buffer`, CTRL-O, CTRL-I, '{A-Z0-9}, or `{A-Z0-9} command takes one
|
|
to another file.
|
|
|
|
'';
|
|
};
|
|
|
|
autowriteall = {
|
|
type = bool;
|
|
description = ''
|
|
Like 'autowrite', but also used for commands ":edit", ":enew", ":quit",
|
|
":qall", ":exit", ":xit", ":recover" and closing the Vim window.
|
|
Setting this option also implies that Vim behaves like 'autowrite' has
|
|
been set.
|
|
'';
|
|
};
|
|
|
|
background = {
|
|
type = str;
|
|
description = ''
|
|
When set to "dark" or "light", adjusts the default color groups for
|
|
that background type. The |TUI| or other UI sets this on startup
|
|
(triggering |OptionSet|) if it can detect the background color.
|
|
|
|
This option does NOT change the background color, it tells Nvim what
|
|
the "inherited" (terminal/GUI) background looks like.
|
|
See |:hi-normal| if you want to set the background color explicitly.
|
|
|
|
When a color scheme is loaded (the "g:colors_name" variable is set)
|
|
setting 'background' will cause the color scheme to be reloaded. If
|
|
the color scheme adjusts to the value of 'background' this will work.
|
|
However, if the color scheme sets 'background' itself the effect may
|
|
be undone. First delete the "g:colors_name" variable when needed.
|
|
|
|
'';
|
|
};
|
|
|
|
backspace = {
|
|
type = listOf (enum [ "indent" "eol" "start" "nostop" ]);
|
|
description = ''
|
|
Influences the working of <BS>, <Del>, CTRL-W and CTRL-U in Insert
|
|
mode. This is a list of items, separated by commas. Each item allows
|
|
a way to backspace over something:
|
|
|
|
'';
|
|
};
|
|
|
|
backup = {
|
|
type = bool;
|
|
description = ''
|
|
Make a backup before overwriting a file. Leave it around after the
|
|
file has been successfully written. If you do not want to keep the
|
|
backup file, but you do want a backup while the file is being
|
|
written, reset this option and set the 'writebackup' option (this is
|
|
the default). If you do not want a backup file at all reset both
|
|
options (use this if your file system is almost full). See the
|
|
|backup-table| for more explanations.
|
|
'';
|
|
extraHelp = [ "backup-table" ];
|
|
};
|
|
|
|
backupdir = {
|
|
type = listOf (either str path);
|
|
description = ''
|
|
List of directories for the backup file, separated with commas.
|
|
|
|
'';
|
|
};
|
|
|
|
backupext = {
|
|
type = str;
|
|
description = ''
|
|
str which is appended to a file name to make the name of the
|
|
backup file. The default is quite unusual, because this avoids
|
|
accidentally overwriting existing files with a backup file. You might
|
|
prefer using ".bak", but make sure that you don't have files with
|
|
".bak" that you want to keep.
|
|
Only normal file name characters can be used; "/\*?[|<>" are illegal.
|
|
|
|
'';
|
|
};
|
|
|
|
backupskip = {
|
|
type = listOf (either str path);
|
|
description = ''
|
|
A list of file patterns. When one of the patterns matches with the
|
|
name of the file which is written, no backup file is created. Both
|
|
the specified file name and the full path name of the file are used.
|
|
The pattern is used like with |:autocmd|, see |autocmd-pattern|.
|
|
Watch out for special characters, see |option-backslash|.
|
|
When $TMPDIR, $TMP or $TEMP is not defined, it is not used for the
|
|
default value. "/tmp/*" is only used for Unix.
|
|
|
|
'';
|
|
};
|
|
|
|
belloff = {
|
|
type = listOf (enum [
|
|
"all"
|
|
"backspace"
|
|
"cursor"
|
|
"complete"
|
|
"copy"
|
|
"ctrlg"
|
|
"error"
|
|
"esc"
|
|
"hangul"
|
|
"lang"
|
|
"mess"
|
|
"showmatch"
|
|
"operator"
|
|
"register"
|
|
"shell"
|
|
"spell"
|
|
"willmode"
|
|
]);
|
|
description = ''
|
|
Specifies for which events the bell will not be rung. It is a comma-
|
|
separated list of items. For each item that is present, the bell
|
|
will be silenced. This is most useful to specify specific events in
|
|
insert mode to be silenced.
|
|
|
|
item | meaning when present
|
|
--------------------------------------------------------------------
|
|
all | All events.
|
|
backspace | When hitting <BS> or <Del> and deleting results in an error.
|
|
cursor | Fail to move around using the cursor keys or
|
|
| <PageUp>/<PageDown> in |Insert-mode|.
|
|
complete | Error occurred when using |i_CTRL-X_CTRL-K| or
|
|
| |i_CTRL-X_CTRL-T|.
|
|
copy | Cannot copy char from insert mode using |i_CTRL-Y| or
|
|
| |i_CTRL-E|.
|
|
ctrlg | Unknown Char after <C-G> in Insert mode.
|
|
error | Other Error occurred (e.g. try to join last line)
|
|
| (mostly used in |Normal-mode| or |Cmdline-mode|).
|
|
esc | hitting <Esc> in |Normal-mode|.
|
|
hangul | Ignored.
|
|
lang | Calling the beep module for Lua/Mzscheme/TCL.
|
|
mess | No output available for |g<|.
|
|
showmatch | Error occurred for 'showmatch' function.
|
|
operator | Empty region error |cpo-E|.
|
|
register | Unknown register after <C-R> in |Insert-mode|.
|
|
shell | Bell from shell output |:!|.
|
|
spell | Error happened on spell suggest.
|
|
wildmode | More matches in |cmdline-completion| available
|
|
| (depends on the 'wildmode' setting).
|
|
|
|
'';
|
|
};
|
|
|
|
breakat = {
|
|
type = str;
|
|
description = ''
|
|
This option lets you choose which characters might cause a line
|
|
break if 'linebreak' is on. Only works for ASCII characters.
|
|
|
|
'';
|
|
};
|
|
|
|
browsedir = {
|
|
type = (either path (enum [ "last" "buffer" "current" ]));
|
|
description = ''
|
|
Which directory to use for the file browser:
|
|
last Use same directory as with last file browser, where a file was opened or saved.
|
|
buffer Use the directory of the related buffer.
|
|
current Use the current directory.
|
|
{path} Use the specified directory
|
|
|
|
'';
|
|
};
|
|
|
|
casemap = {
|
|
type = listOf (enum [ "internal" "keepascii" ]);
|
|
description = ''
|
|
Specifies details about changing the case of letters. It may contain
|
|
these words, separated by a comma:
|
|
- internal - Use internal case mapping functions, the current locale does not change the case
|
|
mapping. When "internal" is omitted, the towupper() and towlower() system library functions are
|
|
used when available.
|
|
- keepascii - For the ASCII characters (0x00 to 0x7f) use the US case mapping, the current locale
|
|
is not effective. This probably only matters for Turkish.
|
|
|
|
'';
|
|
};
|
|
|
|
cedit = {
|
|
type = str;
|
|
description = ''
|
|
The key used in Command-line Mode to open the command-line window.
|
|
Only non-printable keys are allowed.
|
|
|
|
'';
|
|
};
|
|
|
|
charconvert = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
An expression that is used for character encoding conversion. It is
|
|
evaluated when a file that is to be read or has been written has a
|
|
different encoding from what is desired.
|
|
|
|
'';
|
|
};
|
|
|
|
clipboard = {
|
|
type = listOf (enum [ "unnamed" "unnamedplus" ]);
|
|
description = ''
|
|
This option is a list of comma-separated names.
|
|
|
|
'';
|
|
};
|
|
|
|
cmdheight = {
|
|
type = number;
|
|
description = ''
|
|
Number of screen lines to use for the command-line. Helps avoiding |hit-enter| prompts.
|
|
|
|
'';
|
|
};
|
|
|
|
cmdwinheight = {
|
|
type = number;
|
|
description = ''
|
|
Number of screen lines to use for the command-line window.
|
|
'';
|
|
extraHelp = [ "cmdwin" ];
|
|
};
|
|
|
|
completeopt = {
|
|
type = listOf (enum [
|
|
"menu"
|
|
"menuone"
|
|
"longest"
|
|
"preview"
|
|
"noinsert"
|
|
"noselect"
|
|
]);
|
|
description = ''
|
|
A comma-separated list of options for Insert mode completion |ins-completion|.
|
|
|
|
'';
|
|
};
|
|
|
|
confirm = {
|
|
type = bool;
|
|
description = ''
|
|
When 'confirm' is on, certain operations that would normally
|
|
fail because of unsaved changes to a buffer, e.g. ":q" and ":e",
|
|
instead raise a dialog asking if you wish to save the current
|
|
file(s). You can still use a ! to unconditionally |abandon| a buffer.
|
|
If 'confirm' is off you can still activate confirmation for one
|
|
command only (this is most useful in mappings) with the |:confirm|
|
|
command.
|
|
|
|
'';
|
|
};
|
|
|
|
cpoptions = {
|
|
type = str;
|
|
vimDefault = true;
|
|
description = ''
|
|
A sequence of single character flags. When a character is present
|
|
this indicates Vi-compatible behavior. This is used for things where
|
|
not being Vi-compatible is mostly or sometimes preferred.
|
|
'cpoptions' stands for "compatible-options".
|
|
Commas can be added for readability.
|
|
|
|
'';
|
|
};
|
|
|
|
debug = {
|
|
type = listOf (enum [ "msg" "throw" "beep" ]);
|
|
description = ''
|
|
These values can be used:
|
|
- msg Error messages that would otherwise be omitted will be given anyway.
|
|
- throw Error messages that would otherwise be omitted will be given anyway and also throw an exception and set |v:errmsg|.
|
|
- beep A message will be given when otherwise only a beep would be produced.
|
|
|
|
The values can be combined, separated by a comma.
|
|
"msg" and "throw" are useful for debugging 'foldexpr', 'formatexpr' or
|
|
'indentexpr'.
|
|
|
|
'';
|
|
};
|
|
|
|
define = {
|
|
type = str;
|
|
description = ''
|
|
Pattern to be used to find a macro definition.
|
|
|
|
'';
|
|
};
|
|
|
|
delcombine = {
|
|
type = bool;
|
|
description = ''
|
|
If editing Unicode and this option is set, backspace and Normal mode
|
|
"x" delete each combining character on its own. When it is off (the
|
|
default) the character along with its combining characters are
|
|
deleted.
|
|
|
|
'';
|
|
};
|
|
|
|
dictionary = {
|
|
type = listOf (either str path);
|
|
description = ''
|
|
List of file names, separated by commas, that are used to lookup words
|
|
for keyword completion commands |i_CTRL-X_CTRL-K|. Each file should
|
|
contain a list of words. This can be one word per line, or several
|
|
words per line, separated by non-keyword characters (white space is
|
|
preferred). Maximum line length is 510 bytes.
|
|
|
|
'';
|
|
};
|
|
|
|
diffexpr = {
|
|
type = str;
|
|
description = ''
|
|
Expression which is evaluated to obtain a diff file (either ed-style
|
|
or unified-style) from two versions of a file.
|
|
|
|
'';
|
|
extraHelp = [ "diff-diffexpr" ];
|
|
};
|
|
|
|
diffopt = {
|
|
type = listOf str;
|
|
description = ''
|
|
Option settings for diff mode.
|
|
|
|
'';
|
|
};
|
|
|
|
digraph = {
|
|
type = bool;
|
|
description = ''
|
|
Enable the entering of digraphs in Insert mode with {char1} <BS> {char2}.
|
|
|
|
'';
|
|
extraHelp = [ "digraphs" ];
|
|
};
|
|
|
|
directory = {
|
|
type = listOf (either str path);
|
|
description = ''
|
|
List of directory names for the swap file, separated with commas.
|
|
|
|
'';
|
|
};
|
|
|
|
display = {
|
|
type = listOf (enum [ "lastline" "truncate" "uhex" "msgsep" ]);
|
|
description = ''
|
|
Change the way text is displayed.
|
|
|
|
'';
|
|
};
|
|
|
|
eadirection = {
|
|
type = (enum [ "ver" "hor" "both" ]);
|
|
description = ''
|
|
Tells when the 'equalalways' option applies:
|
|
|
|
'';
|
|
};
|
|
|
|
emoji = {
|
|
type = bool;
|
|
description = ''
|
|
When on all Unicode emoji characters are considered to be full width.
|
|
This excludes "text emoji" characters, which are normally displayed as
|
|
single width.
|
|
|
|
'';
|
|
};
|
|
|
|
equalalways = {
|
|
type = bool;
|
|
description = ''
|
|
When on, all the windows are automatically made the same size after
|
|
splitting or closing a window. This also happens the moment the
|
|
option is switched on. When off, splitting a window will reduce the
|
|
size of the current window and leave the other windows the same.
|
|
|
|
'';
|
|
};
|
|
|
|
equalprg = {
|
|
type = str;
|
|
description = ''
|
|
External program to use for "=" command. When this option is empty
|
|
the internal formatting functions are used; either 'lisp', 'cindent'
|
|
or 'indentexpr'.
|
|
|
|
'';
|
|
};
|
|
|
|
errorbells = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
Ring the bell (beep or screen flash) for error messages. This only
|
|
makes a difference for error messages, the bell will be used always
|
|
for a lot of errors without a message
|
|
|
|
'';
|
|
};
|
|
|
|
errorfile = {
|
|
type = str;
|
|
vimDefault = "errors.err";
|
|
description = ''
|
|
Name of the errorfile for the QuickFix mode.
|
|
|
|
'';
|
|
extraHelp = [ "cf" ];
|
|
};
|
|
|
|
errorformat = {
|
|
type = str;
|
|
description = ''
|
|
Scanf-like description of the format for the lines in the error file
|
|
|
|
'';
|
|
};
|
|
|
|
eventignore = {
|
|
type = listOf str;
|
|
vimDefault = [ ];
|
|
description = ''
|
|
A list of autocommand event names, which are to be ignored.
|
|
When set to "all" or when "all" is one of the items, all autocommand
|
|
events are ignored, autocommands will not be executed.
|
|
|
|
'';
|
|
};
|
|
|
|
exrc = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
Automatically execute .nvim.lua, .nvimrc, and .exrc files in the
|
|
current directory, if the file is in the |trust| list. Use |:trust| to
|
|
manage trusted files.
|
|
|
|
'';
|
|
extraHelp = [ ":trust" ];
|
|
};
|
|
|
|
fileencodings = {
|
|
type = listOf str;
|
|
vimDefault = ''["ucs-bom" "utf-8" "default" "latin1"]'';
|
|
description = ''
|
|
This is a list of character encodings considered when starting to edit
|
|
an existing file.
|
|
|
|
'';
|
|
};
|
|
|
|
fileformats = {
|
|
type = listOf (enum [ "dos" "unix" "mac" ]);
|
|
vimDefault = ''
|
|
Windows default: ["dos" "unix"],
|
|
Unix default: ["unix" "dos"]
|
|
'';
|
|
description = ''
|
|
This gives the end-of-line (<EOL>) formats that will be tried when
|
|
starting to edit a new buffer and when reading a file into an existing
|
|
buffer
|
|
|
|
'';
|
|
};
|
|
|
|
fileignorecase = {
|
|
type = bool;
|
|
vimDefault = ''
|
|
`true` for systems where case in file names is normally ignored"
|
|
'';
|
|
description = ''
|
|
When set case is ignored when using file names and directories.
|
|
|
|
'';
|
|
};
|
|
|
|
foldclose = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
When set to "all", a fold is closed when the cursor isn't in it and
|
|
its level is higher than 'foldlevel'. Useful if you want folds to
|
|
automatically close when moving out of them.
|
|
|
|
'';
|
|
};
|
|
|
|
foldlevelstart = {
|
|
type = number;
|
|
vimDefault = -1;
|
|
description = ''
|
|
Sets 'foldlevel' when starting to edit another buffer in a window.
|
|
Useful to always start editing with all folds closed (value zero),
|
|
some folds closed (one) or no folds closed (99).
|
|
|
|
When the value is negative, it is not used.
|
|
|
|
'';
|
|
extraHelp = [ "foldlevel" ];
|
|
};
|
|
|
|
foldopen = {
|
|
type = listOf (enum [
|
|
"all"
|
|
"block"
|
|
"hor"
|
|
"insert"
|
|
"jump"
|
|
"mark"
|
|
"percent"
|
|
"quickfix"
|
|
"search"
|
|
"tag"
|
|
"undo"
|
|
]);
|
|
vimDefault = ''
|
|
[
|
|
"block"
|
|
"hor"
|
|
"mark"
|
|
"percent"
|
|
"quickfix"
|
|
"search"
|
|
"tag"
|
|
"undo"
|
|
]
|
|
'';
|
|
description = ''
|
|
Specifies for which type of commands folds will be opened, if the
|
|
command moves the cursor into a closed fold. It is a comma-separated
|
|
list of items.
|
|
|
|
'';
|
|
};
|
|
|
|
fsync = {
|
|
type = bool;
|
|
vimDefault = true;
|
|
description = ''
|
|
When on, the OS function fsync() will be called after saving a file
|
|
(|:write|, |writefile()|, …), |swap-file|, |undo-persistence| and |shada-file|.
|
|
This flushes the file to disk, ensuring that it is safely written.
|
|
Slow on some systems: writing buffers, quitting Nvim, and other
|
|
operations may sometimes take a few seconds.
|
|
|
|
'';
|
|
};
|
|
|
|
gvimDefault = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
When on, the ":substitute" flag 'g' is default on. This means that
|
|
all matches in a line are substituted instead of one. When a 'g' flag
|
|
is given to a ":substitute" command, this will toggle the substitution
|
|
of all or one match. See |complex-change|.
|
|
|
|
'';
|
|
};
|
|
|
|
grepformat = {
|
|
type = str;
|
|
vimDefault = ''%f:%l:%m,%f:%l%m,%f %l%m'';
|
|
description = ''
|
|
Format to recognize for the ":grep" command output.
|
|
|
|
'';
|
|
extraHelp = [ "errorformat" ];
|
|
};
|
|
|
|
guicursor = {
|
|
type = str;
|
|
vimDefault = "n-v-c-sm:block,i-ci-ve:ver25,r-cr-o:hor20";
|
|
description = ''
|
|
Configures the cursor style for each mode. Works in the GUI and many
|
|
terminals. See |tui-cursor-shape|.
|
|
|
|
To disable cursor-styling, reset the option
|
|
|
|
'';
|
|
};
|
|
|
|
guifont = {
|
|
type = listOf str;
|
|
vimDefault = [ ];
|
|
description = ''
|
|
This is a list of fonts which will be used for the GUI version of Vim.
|
|
In its simplest form the value is just one font name. When
|
|
the font cannot be found you will get an error message. To try other
|
|
font names a list can be specified, font names separated with commas.
|
|
The first valid font is used.
|
|
|
|
'';
|
|
};
|
|
|
|
guifontwide = {
|
|
type = listOf str;
|
|
vimDefault = [ ];
|
|
description = ''
|
|
list of fonts to be used for double-width characters.
|
|
The first font that can be loaded is used.
|
|
|
|
'';
|
|
};
|
|
|
|
guioptions = {
|
|
type = str;
|
|
vimDefault = "egmrLT";
|
|
description = ''
|
|
This option only has an effect in the GUI version of Vim. It is a
|
|
sequence of letters which describes what components and options of the
|
|
GUI should be used.
|
|
|
|
'';
|
|
};
|
|
|
|
guitablabel = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
When non-empty describes the text to use in a label of the GUI tab
|
|
pages line. When empty and when the result is empty Vim will use a
|
|
default label.
|
|
|
|
'';
|
|
extraHelp = [ "setting-guitablabel" ];
|
|
};
|
|
|
|
guitabtooltip = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
When non-empty describes the text to use in a tooltip for the GUI tab
|
|
pages line. When empty Vim will use a default tooltip.
|
|
|
|
'';
|
|
};
|
|
|
|
helpfile = {
|
|
type = (either str path);
|
|
vimDefault = ''
|
|
default (MS-Windows) "$VIMRUNTIME\doc\help.txt"
|
|
(others) "$VIMRUNTIME/doc/help.txt"
|
|
|
|
'';
|
|
};
|
|
|
|
helpheight = {
|
|
type = number;
|
|
vimDefault = 20;
|
|
description = ''
|
|
Minimal initial height of the help window when it is opened with the ":help" command.
|
|
|
|
'';
|
|
};
|
|
|
|
helplang = {
|
|
type = listOf str;
|
|
vimDefault = messages language or empty;
|
|
description = ''
|
|
list of languages. Vim will use the first language
|
|
for which the desired help can be found.
|
|
|
|
'';
|
|
};
|
|
|
|
hidden = {
|
|
type = bool;
|
|
vimDefault = true;
|
|
description = ''
|
|
When off a buffer is unloaded (including loss of undo information)
|
|
when it is abandoned. When on a buffer becomes hidden when it is
|
|
abandoned. A buffer displayed in another window does not become
|
|
hidden, of course.
|
|
|
|
'';
|
|
extraHelp = [
|
|
"abadon"
|
|
"bufhidden"
|
|
];
|
|
};
|
|
|
|
history = {
|
|
type = number;
|
|
vimDefault = 10000;
|
|
description = ''
|
|
A history of ":" commands, and a history of previous search patterns
|
|
is remembered. This option decides how many entries may be stored in
|
|
each of these histories
|
|
|
|
The maximum is 10000.
|
|
|
|
'';
|
|
extraHelp = [ "cmdline-editing" ];
|
|
};
|
|
|
|
hlsearch = {
|
|
type = bool;
|
|
vimDefault = true;
|
|
description = ''
|
|
When there is a previous search pattern, highlight all its matches.
|
|
|
|
'';
|
|
extraHelp = [
|
|
"incsearch"
|
|
"match"
|
|
];
|
|
};
|
|
|
|
icon = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
When on, the icon text of the window will be set to the value of
|
|
'iconstr' (if it is not empty), or to the name of the file
|
|
currently being edited. Only the last part of the name is used.
|
|
Overridden by the 'iconstr' option.
|
|
Only works if the terminal supports setting window icons.
|
|
|
|
'';
|
|
extraHelp = [ "iconstring" ];
|
|
};
|
|
|
|
iconstring = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
When this option is not empty, it will be used for the icon text of the window.
|
|
|
|
'';
|
|
};
|
|
|
|
ignorecase = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
Ignore case in search patterns. Also used when searching in the tags file.
|
|
|
|
Also see 'smartcase' and 'tagcase'.
|
|
|
|
'';
|
|
};
|
|
|
|
imcmdline = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
When set the Input Method is always on when starting to edit a command
|
|
line, unless entering a search pattern.
|
|
|
|
'';
|
|
extraHelp = [ "imsearch" ];
|
|
};
|
|
|
|
imdisable = {
|
|
type = bool;
|
|
vimDefault = ''
|
|
false
|
|
true for some systems (SGI)
|
|
'';
|
|
description = ''
|
|
When set the Input Method is never used. This is useful to disable
|
|
the IM when it doesn't work properly.
|
|
|
|
'';
|
|
};
|
|
|
|
inccommand = {
|
|
type = (enum [ "nosplit" "split" ]);
|
|
vimDefault = "nosplit";
|
|
description = ''
|
|
When nonempty, shows the effects of |:substitute|, |:smagic|,
|
|
|:snomagic| and user commands with the |:command-preview| flag as you
|
|
type.
|
|
|
|
'';
|
|
};
|
|
|
|
incsearch = {
|
|
type = bool;
|
|
vimDefault = true;
|
|
description = ''
|
|
While typing a search command, show where the pattern, as it was typed
|
|
so far, matches. The matched str is highlighted. If the pattern
|
|
is invalid or not found, nothing is shown.
|
|
|
|
'';
|
|
};
|
|
|
|
isfname = {
|
|
type = str;
|
|
vimDefault = ''
|
|
Windows: "@,48-57,/,\,.,-,_,+,,,#,$,%,{,},[,],:,@-@,!,~,="
|
|
otherwise: "@,48-57,/,.,-,_,+,,,#,$,%,~,="
|
|
'';
|
|
};
|
|
|
|
isident = {
|
|
type = str;
|
|
vimDefault = ''
|
|
Windows: "@,48-57,_,128-167,224-235"
|
|
otherwise: "@,48-57,_,192-255"
|
|
'';
|
|
description = ''
|
|
The characters given by this option are included in identifiers.
|
|
Identifiers are used in recognizing environment variables and after a
|
|
match of the 'define' option.
|
|
|
|
'';
|
|
};
|
|
|
|
isprint = {
|
|
type = str;
|
|
vimDefault = "@,161-255";
|
|
description = ''
|
|
The characters given by this option are displayed directly on the
|
|
screen. It is also used for "\p" in a |pattern|.
|
|
|
|
'';
|
|
extraHelp = [ "pattern" ];
|
|
};
|
|
|
|
jumpoptions = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
List of words that change the behavior of the |jumplist|
|
|
|
|
'';
|
|
extraHelp = [ "jumplist" ];
|
|
};
|
|
|
|
joinspaces = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
Insert two spaces after a '.', '?' and '!' with a join command.
|
|
Otherwise only one space is inserted.
|
|
|
|
'';
|
|
};
|
|
|
|
keymodel = {
|
|
type = listOf str;
|
|
vimDefault = [ ];
|
|
description = ''
|
|
List of comma-separated words, which enable special things that keys can do.
|
|
|
|
'';
|
|
};
|
|
|
|
langmap = {
|
|
type = listOf str;
|
|
vimDefault = [ ];
|
|
description = ''
|
|
This option allows switching your keyboard into a special language
|
|
mode. When you are typing text in Insert mode the characters are
|
|
inserted directly. When in Normal mode the 'langmap' option takes
|
|
care of translating these special characters to the original meaning
|
|
of the key. This means you don't have to change the keyboard mode to
|
|
be able to execute Normal mode commands.
|
|
|
|
'';
|
|
};
|
|
|
|
langmenu = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
Language to use for menu translation.
|
|
|
|
'';
|
|
};
|
|
|
|
langremap = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
When off, setting 'langmap' does not apply to characters resulting from
|
|
a mapping. If setting 'langmap' disables some of your mappings, make
|
|
sure this option is off.
|
|
|
|
'';
|
|
};
|
|
|
|
laststatus = {
|
|
type = number;
|
|
vimDefault = 2;
|
|
description = ''
|
|
The value of this option influences when the last window will have a
|
|
status line:
|
|
- 0: never
|
|
- 1: only if there are at least two windows
|
|
- 2: always
|
|
- 3: always and ONLY the last window
|
|
|
|
'';
|
|
};
|
|
|
|
lazyredraw = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
When this option is set, the screen will not be redrawn while
|
|
executing macros, registers and other commands that have not been
|
|
typed. Also, updating the window title is postponed. To force an
|
|
update use |:redraw|.
|
|
|
|
'';
|
|
extraHelp = [ ":redraw" ];
|
|
};
|
|
|
|
linespace = {
|
|
type = number;
|
|
vimDefault = 0;
|
|
description = ''
|
|
Number of pixel lines inserted between characters. Useful if the font
|
|
uses the full character cell height, making lines touch each other.
|
|
When non-zero there is room for underlining.
|
|
|
|
'';
|
|
};
|
|
|
|
loadplugins = {
|
|
type = bool;
|
|
vimDefault = true;
|
|
description = ''
|
|
When on the plugin scripts are loaded when starting up |load-plugins|.
|
|
This option can be reset in your |vimrc| file to disable the loading
|
|
of plugins.
|
|
|
|
'';
|
|
};
|
|
|
|
magic = {
|
|
type = bool;
|
|
vimDefault = true;
|
|
description = ''
|
|
Changes the special characters that can be used in search patterns.
|
|
See |pattern|.
|
|
WARNING: Switching this option off most likely breaks plugins! That
|
|
is because many patterns assume it's on and will fail when it's off.
|
|
|
|
'';
|
|
};
|
|
|
|
makeef = {
|
|
type = (either str path);
|
|
vimDefault = "";
|
|
description = ''
|
|
Name of the errorfile for the |:make| command (see |:make_makeprg|)
|
|
and the |:grep| command.
|
|
When it is empty, an internally generated temp file will be used.
|
|
When "##" is included, it is replaced by a number to make the name
|
|
unique.
|
|
|
|
'';
|
|
};
|
|
};
|
|
|
|
window = with lib; with types; sharedGlobalOrWindow // {
|
|
arabic = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
This option can be set to start editing Arabic text.
|
|
|
|
'';
|
|
};
|
|
|
|
breakindent = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
Every wrapped line will continue visually indented (same amount of
|
|
space as the beginning of that line), thus preserving horizontal blocks
|
|
of text.
|
|
|
|
'';
|
|
};
|
|
|
|
breakindentopt = {
|
|
type = commas;
|
|
vimDefault = [ ];
|
|
description = ''
|
|
Settings for 'breakindent
|
|
|
|
'';
|
|
};
|
|
|
|
colorcolumn = {
|
|
type = commas;
|
|
vimDefault = [ ];
|
|
description = ''
|
|
'colorcolumn' is a comma-separated list of screen columns that are
|
|
highlighted with ColorColumn |hl-ColorColumn|. Useful to align
|
|
text. Will make screen redrawing slower.
|
|
|
|
'';
|
|
};
|
|
|
|
concealcursor = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
Sets the modes in which text in the cursor line can also be concealed.
|
|
|
|
'';
|
|
};
|
|
|
|
conceallevel = {
|
|
type = number;
|
|
vimDefault = 0;
|
|
description = ''
|
|
Determine how text with the "conceal" syntax attribute |:syn-conceal|
|
|
is shown
|
|
|
|
'';
|
|
extraHelp = [ "syn-conceal" ];
|
|
};
|
|
|
|
cursorbind = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
When this option is set, as the cursor in the current
|
|
window moves other cursorbound windows (windows that also have
|
|
this option set) move their cursors to the corresponding line and
|
|
column.
|
|
|
|
'';
|
|
};
|
|
|
|
foldcolumn = {
|
|
type = str;
|
|
vimDefault = "0";
|
|
description = ''
|
|
When and how to draw the foldcolumn. Valid values are:
|
|
"auto": resize to the minimum amount of folds to display.
|
|
"auto:[1-9]": resize to accommodate multiple folds up to the selected level
|
|
"0": to disable foldcolumn
|
|
"[1-9]": to display a fixed number of columns
|
|
|
|
'';
|
|
extraHelp = [ "folding" ];
|
|
};
|
|
|
|
foldenable = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
When off, all folds are open. This option can be used to quickly
|
|
switch between showing all text unfolded and viewing the text with
|
|
folds (including manually opened or closed folds). It can be toggled
|
|
with the |zi| command. The 'foldcolumn' will remain blank when
|
|
'foldenable' is off.
|
|
|
|
'';
|
|
extraHelp = [ "folding" ];
|
|
};
|
|
|
|
foldexpr = {
|
|
type = str;
|
|
vimDefault = "0";
|
|
description = ''
|
|
The expression used for when 'foldmethod' is "expr". It is evaluated
|
|
for each line to obtain its fold level.
|
|
|
|
'';
|
|
extraHelp = [ "fold-expr" ];
|
|
};
|
|
|
|
foldignore = {
|
|
type = str;
|
|
vimDefault = "#";
|
|
description = ''
|
|
Used only when 'foldmethod' is "indent". Lines starting with
|
|
characters in 'foldignore' will get their fold level from surrounding
|
|
lines. White space is skipped before checking for this character.
|
|
|
|
'';
|
|
extraHelp = [ "fold-indent" ];
|
|
};
|
|
|
|
foldlevel = {
|
|
type = number;
|
|
vimDefault = 0;
|
|
description = ''
|
|
Sets the fold level: Folds with a higher level will be closed.
|
|
Setting this option to zero will close all folds. Higher numbers will
|
|
close fewer folds.
|
|
This option is set by commands like |zm|, |zM| and |zR|.
|
|
|
|
'';
|
|
extraHelp = [ "fold-foldlevel" ];
|
|
};
|
|
|
|
foldmarker = {
|
|
type = listOf str;
|
|
apply = x: assert (x == null || builtins.length x == 2 || abort "`foldmarker` must contain start and end markers in the list"); x;
|
|
vimDefault = ''["{{{" "}}}"]'';
|
|
description = ''
|
|
The start and end marker used when 'foldmethod' is "marker".
|
|
|
|
'';
|
|
};
|
|
|
|
foldmethod = {
|
|
type = (enum [ "manual" "indent" "expr" "marker" "syntax" "diff" ]);
|
|
vimDefault = "manual";
|
|
description = ''
|
|
The kind of folding used for the current window.
|
|
'';
|
|
extraHelp = [
|
|
"fold-manual"
|
|
"fold-indent"
|
|
"fold-expr"
|
|
"fold-marker"
|
|
"fold-syntax"
|
|
"fold-diff"
|
|
];
|
|
};
|
|
|
|
foldminlines = {
|
|
type = number;
|
|
vimDefault = 1;
|
|
description = ''
|
|
Sets the number of screen lines above which a fold can be displayed
|
|
closed. Also for manually closed folds.
|
|
|
|
'';
|
|
};
|
|
|
|
foldnestmax = {
|
|
type = number;
|
|
vimDefault = 20;
|
|
description = ''
|
|
Sets the maximum nesting of folds for the "indent" and "syntax"
|
|
methods. This avoids that too many folds will be created. Using more
|
|
than 20 doesn't work, because the internal limit is 20.
|
|
|
|
'';
|
|
};
|
|
|
|
foldtext = {
|
|
type = str;
|
|
vimDefault = "foldtext()";
|
|
description = ''
|
|
An expression which is used to specify the text displayed for a closed fold.
|
|
|
|
'';
|
|
extraHelp = [ "fold-foldtext" ];
|
|
};
|
|
|
|
linebreak = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
If on, Vim will wrap long lines at a character in 'breakat' rather
|
|
than at the last character that fits on the screen. Unlike
|
|
'wrapmargin' and 'textwidth', this does not insert <EOL>s in the file,
|
|
it only affects the way the file is displayed, not its contents.
|
|
|
|
'';
|
|
};
|
|
|
|
list = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
List mode: By default, show tabs as ">", trailing spaces as "-", and
|
|
non-breakable space characters as "+". Useful to see the difference
|
|
between tabs and spaces and for trailing blanks. Further changed by
|
|
the 'listchars' option.
|
|
|
|
'';
|
|
extraHelp = [ "listchars" ];
|
|
};
|
|
|
|
listchars = {
|
|
type = submodule {
|
|
options =
|
|
let
|
|
inherit (builtins) strLength;
|
|
mkListcharsOption = k: { description, min ? 1, max ? 1 }: mkVimOptOption k {
|
|
type = lib.types.str;
|
|
apply = x:
|
|
assert (
|
|
(strLength x >= min && strLength x <= max)
|
|
|| abort ''
|
|
The number of characters ${x} does not correspond to the boundaries
|
|
(min: ${tostr min}; max: ${tostr max})
|
|
''
|
|
);
|
|
x;
|
|
inherit description;
|
|
};
|
|
in
|
|
(mapAttrs mkListcharsOption {
|
|
eol = {
|
|
description = ''
|
|
Character to show at the end of each line. When
|
|
omitted, there is no extra character at the end of the
|
|
line.
|
|
'';
|
|
};
|
|
|
|
tab = {
|
|
description = ''
|
|
Two or three characters to be used to show a tab.
|
|
The third character is optional.
|
|
'';
|
|
max = 3;
|
|
};
|
|
|
|
space = {
|
|
description = ''
|
|
Character to show for a space. When omitted, spaces are left blank.
|
|
'';
|
|
};
|
|
|
|
multispace = {
|
|
description = ''
|
|
One or more characters to use cyclically to show for
|
|
multiple consecutive spaces. Overrides the "space"
|
|
setting, except for single spaces.
|
|
'';
|
|
max = 99;
|
|
};
|
|
|
|
lead = {
|
|
description = ''
|
|
Character to show for leading spaces. When omitted,
|
|
leading spaces are blank. Overrides the "space" and
|
|
"multispace" settings for leading spaces.
|
|
|
|
'';
|
|
};
|
|
|
|
leadmultispace = {
|
|
description = ''
|
|
Like the |lcs-multispace| value, but for leading
|
|
spaces only. Also overrides |lcs-lead| for leading
|
|
multiple spaces.
|
|
'';
|
|
max = 99;
|
|
};
|
|
|
|
trail = {
|
|
description = ''
|
|
Character to show for trailing spaces. When omitted,
|
|
trailing spaces are blank. Overrides the "space" and
|
|
"multispace" settings for trailing spaces.
|
|
'';
|
|
};
|
|
|
|
extends = {
|
|
description = ''
|
|
Character to show in the last column, when 'wrap' is
|
|
off and the line continues beyond the right of the
|
|
screen.
|
|
'';
|
|
};
|
|
|
|
precedes = {
|
|
description = ''
|
|
Character to show in the first visible column of the
|
|
physical line, when there is text preceding the
|
|
character visible in the first column.
|
|
'';
|
|
};
|
|
|
|
conceal = {
|
|
description = ''
|
|
Character to show in place of concealed text, when
|
|
'conceallevel' is set to 1. A space when omitted.
|
|
'';
|
|
};
|
|
|
|
nbsp = {
|
|
description = ''
|
|
Character to show for a non-breakable space character
|
|
(0xA0 (160 decimal) and U+202F).
|
|
'';
|
|
};
|
|
});
|
|
};
|
|
};
|
|
};
|
|
|
|
buffer = with lib; with types; sharedGlobalOrBuffer // {
|
|
autoindent = {
|
|
type = bool;
|
|
vimDefault = true;
|
|
description = ''
|
|
Copy indent from current line when starting a new line (typing <CR>
|
|
in Insert mode or when using the "o" or "O" command). If you do not
|
|
type anything on the new line except <BS> or CTRL-D and then type
|
|
<Esc>, CTRL-O or <CR>, the indent is deleted again.
|
|
|
|
'';
|
|
};
|
|
|
|
binary = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
This option should be set before editing a binary file. You can also
|
|
use the |-b| Vim argument.
|
|
'';
|
|
};
|
|
|
|
bomb = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
When writing a file and the following conditions are met, a BOM (Byte
|
|
Order Mark) is prepended to the file:
|
|
- this option is on
|
|
- the 'binary' option is off
|
|
- 'fileencoding' is "utf-8", "ucs-2", "ucs-4" or one of the little/big
|
|
endian variants.
|
|
|
|
'';
|
|
};
|
|
|
|
bufhidden = {
|
|
type = (enum [ "" "hide" "unload" "delete" "wipe" ]);
|
|
vimDefault = "";
|
|
description = ''
|
|
This option specifies what happens when a buffer is no longer
|
|
displayed in a window
|
|
|
|
'';
|
|
};
|
|
|
|
buflisted = {
|
|
type = bool;
|
|
vimDefault = true;
|
|
description = ''
|
|
When this option is set, the buffer shows up in the buffer list.
|
|
|
|
'';
|
|
};
|
|
|
|
buftype = {
|
|
type = (enum [ "" "acwrite" "help" "nofile" "nowrite" "quickfix" "terminal" "prompt" ]);
|
|
vimDefault = "";
|
|
description = ''
|
|
This option is used together with 'bufhidden' and 'swapfile' to
|
|
specify special kinds of buffers.
|
|
|
|
'';
|
|
extraHelp = [ "special-buffers" ];
|
|
};
|
|
|
|
cindent = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
Enables automatic C program indenting.
|
|
|
|
'';
|
|
};
|
|
|
|
cinkeys = {
|
|
type = str;
|
|
vimDefault = "0{,0},0),0],:,0#,!^F,o,O,e";
|
|
description = ''
|
|
A list of keys that, when typed in Insert mode, cause reindenting of
|
|
the current line.
|
|
|
|
'';
|
|
};
|
|
|
|
cinoptions = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
The 'cinoptions' affect the way 'cindent' reindents lines in a C
|
|
program.
|
|
'';
|
|
extraHelp = [ "cinoptions-values" ];
|
|
};
|
|
|
|
cinwords = {
|
|
type = commas;
|
|
vimDefault = ''["if" "else" "while" "do" "for" "switch"]'';
|
|
descrpition = ''
|
|
These keywords start an extra indent in the next line when
|
|
'smartindent' or 'cindent' is set. For 'cindent' this is only done at
|
|
an appropriate place (inside {}).
|
|
|
|
'';
|
|
};
|
|
|
|
cinscopedecls = {
|
|
type = commas;
|
|
vimDefault = ''["public" "protected" "private"]'';
|
|
descrpition = ''
|
|
Keywords that are interpreted as a C++ scope declaration by |cino-g|.
|
|
Useful e.g. for working with the Qt framework that defines additional
|
|
scope declarations "signals", "public slots" and "private slots"
|
|
|
|
'';
|
|
};
|
|
|
|
comments = {
|
|
type = commas;
|
|
vimDefault = ''
|
|
[
|
|
"s1/*"
|
|
"mb:8"
|
|
"ex:*/"
|
|
"://"
|
|
"b:#"
|
|
":%"
|
|
":XCOMM"
|
|
"n:>"
|
|
"fb:-"
|
|
]
|
|
'';
|
|
description = ''
|
|
list of strs that can start a comment line.
|
|
|
|
'';
|
|
extraHelp = [ "format-comments" ];
|
|
};
|
|
|
|
commentstring = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
A template for a comment. The "%s" in the value is replaced with the
|
|
comment text. Currently only used to add markers for folding, see
|
|
|fold-marker|.
|
|
|
|
'';
|
|
extraHelp = [ "fold-marker" ];
|
|
};
|
|
|
|
complete = {
|
|
type = commas;
|
|
vimDefault = ''["." "w" "b" "u" "t"]'';
|
|
description = ''
|
|
This option specifies how keyword completion |ins-completion| works
|
|
when CTRL-P or CTRL-N are used.
|
|
|
|
'';
|
|
extraHelp = [ "ins-completion" ];
|
|
};
|
|
|
|
completefunc = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
This option specifies a function to be used for Insert mode completion
|
|
with CTRL-X CTRL-U.
|
|
|
|
'';
|
|
extraHelp = [
|
|
"complete-functions"
|
|
"i_CTRL-X_CTRL-U"
|
|
];
|
|
};
|
|
|
|
copyindent = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
Copy the structure of the existing lines indent when autoindenting a
|
|
new line. Normally the new indent is reconstructed by a series of
|
|
tabs followed by spaces as required (unless |'expandtab'| is enabled,
|
|
in which case only spaces are used). Enabling this option makes the
|
|
new line copy whatever characters were used for indenting on the
|
|
existing line.
|
|
|
|
'';
|
|
extraHelp = [
|
|
"expandtab"
|
|
"preverseindent"
|
|
];
|
|
};
|
|
|
|
expandtab = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
In Insert mode: Use the appropriate number of spaces to insert a
|
|
<Tab>. Spaces are used in indents with the '>' and '<' commands and
|
|
when 'autoindent' is on. To insert a real tab when 'expandtab' is
|
|
on, use CTRL-V<Tab>. See also |:retab| and |ins-expandtab|.
|
|
'';
|
|
};
|
|
|
|
fileencoding = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
File-content encoding for the current buffer. Conversion is done with
|
|
iconv() or as specified with 'charconvert'.
|
|
|
|
When 'fileencoding' is not UTF-8, conversion will be done when
|
|
writing the file. For reading see below.
|
|
When 'fileencoding' is empty, the file will be saved with UTF-8
|
|
encoding (no conversion when reading or writing a file).
|
|
|
|
'';
|
|
};
|
|
|
|
fileformat = {
|
|
type = (enum [ "dos" "unix" "mac" ]);
|
|
vimDefault = ''
|
|
Windows default: "dos",
|
|
Unix default: "unix"
|
|
'';
|
|
description = ''
|
|
This gives the <EOL> of the current buffer, which is used for
|
|
reading/writing the buffer from/to a file:
|
|
- dos <CR><NL>
|
|
- unix <NL>
|
|
- mac <CR>
|
|
When "dos" is used, CTRL-Z at the end of a file is ignored.
|
|
'';
|
|
};
|
|
|
|
filetype = {
|
|
type = str;
|
|
description = ''
|
|
When this option is set, the FileType autocommand event is triggered.
|
|
|
|
Otherwise this option does not always reflect the current file type.
|
|
This option is normally set when the file type is detected. To enable
|
|
this use the ":filetype on" command. |:filetype|
|
|
|
|
When a dot appears in the value then this separates two filetype names.
|
|
|
|
'';
|
|
extraHelp = [ ":filetype" ];
|
|
};
|
|
|
|
fixendofline = {
|
|
type = bool;
|
|
vimDefault = true;
|
|
description = ''
|
|
When writing a file and this option is on, <EOL> at the end of file
|
|
will be restored if missing. Turn this option off if you want to
|
|
preserve the situation from the original file.
|
|
When the 'binary' option is set the value of this option doesn't
|
|
matter.
|
|
|
|
'';
|
|
extraHelp = [
|
|
"binary"
|
|
"endofline"
|
|
"eol-and-eof"
|
|
];
|
|
};
|
|
|
|
formatexpr = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
Expression which is evaluated to format a range of lines for the |gq|
|
|
operator or automatic formatting (see 'formatoptions'). When this
|
|
option is empty 'formatprg' is used.
|
|
|
|
'';
|
|
};
|
|
|
|
formatlistpat = {
|
|
type = str;
|
|
vimDefault = ''^\s*\d\+[\]:.)}\t ]\s*'';
|
|
description = ''
|
|
A pattern that is used to recognize a list header. This is used for
|
|
the "n" flag in 'formatoptions'.
|
|
|
|
The default recognizes a number, followed by an optional punctuation
|
|
|
|
'';
|
|
extraHelp = [ "formatoptions" ];
|
|
};
|
|
|
|
formatoptions = {
|
|
type = str;
|
|
vimDefault = "tcqj";
|
|
description = ''
|
|
This is a sequence of letters which describes how automatic
|
|
formatting is to be done.
|
|
|
|
'';
|
|
extraHelp = [ "fo-table" ];
|
|
};
|
|
|
|
iminsert = {
|
|
type = number;
|
|
vimDefault = 0;
|
|
description = ''
|
|
Specifies whether :lmap or an Input Method (IM) is to be used in
|
|
Insert mode. Valid values:
|
|
- 0 :lmap is off and IM is off
|
|
- 1 :lmap is ON and IM is off
|
|
- 2 :lmap is off and IM is ON
|
|
|
|
'';
|
|
};
|
|
|
|
imsearch = {
|
|
type = number;
|
|
vimDefault = -1;
|
|
description = ''
|
|
Specifies whether :lmap or an Input Method (IM) is to be used when
|
|
entering a search pattern. Valid values:
|
|
- -1 the value of 'iminsert' is used, makes it look like
|
|
'iminsert' is also used when typing a search pattern
|
|
- 0 :lmap is off and IM is off
|
|
- 1 :lmap is ON and IM is off
|
|
- 2 :lmap is off and IM is ON
|
|
|
|
'';
|
|
};
|
|
|
|
includexpr = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
Expression to be used to transform the str found with the 'include'
|
|
option to a file name.
|
|
|
|
'';
|
|
};
|
|
|
|
indentexpr = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
Expression which is evaluated to obtain the proper indent for a line.
|
|
It is used when a new line is created, for the |=| operator and
|
|
in Insert mode as specified with the 'indentkeys' option.
|
|
|
|
'';
|
|
};
|
|
|
|
indentkeys = {
|
|
type = str;
|
|
vimDefault = "0{,0},0),0],:,0#,!^F,o,O,e";
|
|
description = ''
|
|
A list of keys that, when typed in Insert mode, cause reindenting of
|
|
the current line.
|
|
|
|
'';
|
|
};
|
|
|
|
infercase = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
When doing keyword completion in insert mode |ins-completion|, and
|
|
'ignorecase' is also on, the case of the match is adjusted depending
|
|
on the typed text. If the typed text contains a lowercase letter
|
|
where the match has an upper case letter, the completed part is made
|
|
lowercase.
|
|
|
|
'';
|
|
};
|
|
|
|
iskeyward = {
|
|
type = str;
|
|
vimDefault = "@,48-57,_,192-255";
|
|
description = ''
|
|
Keywords are used in searching and recognizing with many commands:
|
|
"w", "*", "[i", etc. It is also used for "\k" in a |pattern|.
|
|
|
|
'';
|
|
extraHelp = [ "pattern" ];
|
|
};
|
|
|
|
keymap = {
|
|
type = str;
|
|
vimDefault = "";
|
|
description = ''
|
|
Name of a keyboard mapping.
|
|
|
|
'';
|
|
extraHelp = [ "mbyte-keymap" ];
|
|
};
|
|
|
|
lisp = {
|
|
type = bool;
|
|
vimDefault = false;
|
|
description = ''
|
|
Lisp mode: When <Enter> is typed in insert mode set the indent for
|
|
the next line to Lisp standards (well, sort of). Also happens with
|
|
"cc" or "S".
|
|
|
|
'';
|
|
};
|
|
|
|
lispoptions = {
|
|
type = listOf str;
|
|
vimDefault = [ ];
|
|
description = ''
|
|
list of items that influence the Lisp indenting when
|
|
enabled with the |'lisp'| option. Currently only one item is
|
|
supported:
|
|
|
|
- expr:1 use 'indentexpr' for Lisp indenting when it is set
|
|
- expr:0 do not use 'indentexpr' for Lisp indenting (default)
|
|
'';
|
|
extraHelp = [ "list" ];
|
|
};
|
|
};
|
|
in
|
|
mapAttrs (_: mapAttrs mkVimOptOption) {
|
|
inherit global window buffer;
|
|
}
|