2105 lines
60 KiB
Nix
2105 lines
60 KiB
Nix
{ lib }:
|
|
|
|
let
|
|
sharedGlobalOrWindow = with lib; with types; {
|
|
fillchars = mkOption {
|
|
type = nullOr (listOf (enum [
|
|
"stl"
|
|
"stlnc"
|
|
"wbr"
|
|
"horiz"
|
|
"horizup"
|
|
"horizdown"
|
|
"vert"
|
|
"vertleft"
|
|
"vertright"
|
|
"verthoriz"
|
|
"fold"
|
|
"foldopen"
|
|
"foldclose"
|
|
"foldsep"
|
|
"diff"
|
|
"msgsep"
|
|
"eob"
|
|
"lastline"
|
|
]));
|
|
default = null;
|
|
defaultText = literalExpression "[]";
|
|
description = ''
|
|
Characters to fill the statuslines, vertical separators and special lines in the window.
|
|
|
|
`:help fillchars`
|
|
'';
|
|
};
|
|
};
|
|
|
|
sharedGlobalOrBuffer = with lib; with types; {
|
|
autoread = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
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.
|
|
|timestamp|
|
|
|
|
`:help autoread`
|
|
'';
|
|
};
|
|
|
|
backupcopy = mkOption {
|
|
type = nullOr (listOf (enum [ "yes" "no" "auto" "breaksymlink" "breakhardlink" ]));
|
|
default = null;
|
|
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.
|
|
|
|
`:help backupcopy`
|
|
'';
|
|
};
|
|
|
|
formatprg = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
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.
|
|
|
|
`:help formatprg`
|
|
'';
|
|
};
|
|
|
|
grepprg = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = literalExpression ''
|
|
default "grep -n ",
|
|
Unix: "grep -n $* /dev/null"
|
|
|
|
`:help grepprg`
|
|
'';
|
|
};
|
|
|
|
include = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = ''^\s*#\s*include'';
|
|
description = ''
|
|
Pattern to be used to find an include command.
|
|
|
|
`:help include`
|
|
'';
|
|
};
|
|
|
|
keywordprg = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = literalExpression ''
|
|
Windows: ":help"
|
|
otherwise: ":Man"
|
|
'';
|
|
description = ''
|
|
Program to use for the |K| command.
|
|
|
|
`:help keywordprg`
|
|
'';
|
|
};
|
|
|
|
lispwords = mkOption {
|
|
type = nullOr (listOf string);
|
|
default = null;
|
|
defaultText = literalExpression "is very long";
|
|
description = ''
|
|
list of words that influence the Lisp indenting when
|
|
enabled with the |'lisp'| option.
|
|
|
|
`:help lispwords`
|
|
'';
|
|
};
|
|
|
|
makeencoding = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
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`.
|
|
|
|
`:help makeencoding`
|
|
'';
|
|
};
|
|
};
|
|
|
|
global = with lib; with types; sharedGlobalOrWindow // sharedGlobalOrBuffer // {
|
|
allowrevins = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
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
|
|
|
|
`:help allowrevins`
|
|
'';
|
|
};
|
|
|
|
ambiwidth = mkOption {
|
|
type = nullOr (enum [ "single" "double" ]);
|
|
default = null;
|
|
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).
|
|
|
|
`:help ambiwidth`
|
|
'';
|
|
};
|
|
|
|
autochdir = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
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.
|
|
|
|
`:help autochdir`
|
|
'';
|
|
};
|
|
|
|
arabicshape = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help arabicshape`
|
|
'';
|
|
};
|
|
|
|
autowrite = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
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.
|
|
|
|
`:help autowrite`
|
|
'';
|
|
};
|
|
|
|
autowriteall = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
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.
|
|
|
|
`:help autowriteall`
|
|
'';
|
|
};
|
|
|
|
background = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
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.
|
|
|
|
`:help background`
|
|
'';
|
|
};
|
|
|
|
backspace = mkOption {
|
|
type = nullOr (listOf (enum [ "indent" "eol" "start" "nostop" ]));
|
|
default = null;
|
|
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:
|
|
|
|
`:help backspace`
|
|
'';
|
|
};
|
|
|
|
backup = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
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.
|
|
|
|
`:help backup`
|
|
`:help backup-table`
|
|
'';
|
|
};
|
|
|
|
backupdir = mkOption {
|
|
type = nullOr (listOf (either string path));
|
|
default = null;
|
|
description = ''
|
|
List of directories for the backup file, separated with commas.
|
|
|
|
`:help backupdir`
|
|
'';
|
|
};
|
|
|
|
backupext = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
description = ''
|
|
String 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.
|
|
|
|
`:help backupext`
|
|
'';
|
|
};
|
|
|
|
backupskip = mkOption {
|
|
type = nullOr (listOf (either string path));
|
|
default = null;
|
|
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.
|
|
|
|
`:help backupskip`
|
|
'';
|
|
};
|
|
|
|
belloff = mkOption {
|
|
type = nullOr (listOf (enum [
|
|
"all"
|
|
"backspace"
|
|
"cursor"
|
|
"complete"
|
|
"copy"
|
|
"ctrlg"
|
|
"error"
|
|
"esc"
|
|
"hangul"
|
|
"lang"
|
|
"mess"
|
|
"showmatch"
|
|
"operator"
|
|
"register"
|
|
"shell"
|
|
"spell"
|
|
"willmode"
|
|
]));
|
|
default = null;
|
|
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).
|
|
|
|
`:help belloff`
|
|
'';
|
|
};
|
|
|
|
breakat = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
description = ''
|
|
This option lets you choose which characters might cause a line
|
|
break if 'linebreak' is on. Only works for ASCII characters.
|
|
|
|
`:help breakat`
|
|
'';
|
|
};
|
|
|
|
browsedir = mkOption {
|
|
type = nullOr (either path (enum [ "last" "buffer" "current" ]));
|
|
default = null;
|
|
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
|
|
|
|
`:help browsedir`
|
|
'';
|
|
};
|
|
|
|
casemap = mkOption {
|
|
type = nullOr (listOf (enum [ "internal" "keepascii" ]));
|
|
default = null;
|
|
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.
|
|
|
|
`:help casemap`
|
|
'';
|
|
};
|
|
|
|
cedit = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
description = ''
|
|
The key used in Command-line Mode to open the command-line window.
|
|
Only non-printable keys are allowed.
|
|
|
|
`:help cedit`
|
|
'';
|
|
};
|
|
|
|
charconvert = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
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.
|
|
|
|
`:help charconvert`
|
|
'';
|
|
};
|
|
|
|
clipboard = mkOption {
|
|
type = nullOr (listOf (enum [ "unnamed" "unnamedplus" ]));
|
|
default = null;
|
|
description = ''
|
|
This option is a list of comma-separated names.
|
|
|
|
`:help clipboard`
|
|
'';
|
|
};
|
|
|
|
cmdheight = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
description = ''
|
|
Number of screen lines to use for the command-line. Helps avoiding |hit-enter| prompts.
|
|
|
|
`:help cmdheight`
|
|
'';
|
|
};
|
|
|
|
cmdwinheight = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
description = ''
|
|
Number of screen lines to use for the command-line window.
|
|
|
|
`:help cmdwinheight`
|
|
`:help cmdwin`
|
|
'';
|
|
};
|
|
|
|
completeopt = mkOption {
|
|
type = nullOr (listOf (enum [
|
|
"menu"
|
|
"menuone"
|
|
"longest"
|
|
"preview"
|
|
"noinsert"
|
|
"noselect"
|
|
]));
|
|
default = null;
|
|
description = ''
|
|
A comma-separated list of options for Insert mode completion |ins-completion|.
|
|
|
|
`:help completeopt`
|
|
'';
|
|
};
|
|
|
|
confirm = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
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.
|
|
|
|
`:help confirm`
|
|
'';
|
|
};
|
|
|
|
cpoptions = mkOption {
|
|
type = nullOr string;
|
|
default = 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.
|
|
|
|
`:help cpoptions`
|
|
'';
|
|
};
|
|
|
|
debug = mkOption {
|
|
type = nullOr (listOf (enum [ "msg" "throw" "beep" ]));
|
|
default = null;
|
|
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'.
|
|
|
|
`:help debug`
|
|
'';
|
|
};
|
|
|
|
define = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
description = ''
|
|
Pattern to be used to find a macro definition.
|
|
|
|
`:help defined`
|
|
'';
|
|
};
|
|
|
|
delcombine = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
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.
|
|
|
|
`:help delcombine`
|
|
'';
|
|
};
|
|
|
|
dictionary = mkOption {
|
|
type = nullOr (listOf (either string path));
|
|
default = null;
|
|
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.
|
|
|
|
`:help dictionary`
|
|
'';
|
|
};
|
|
|
|
diffexpr = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
description = ''
|
|
Expression which is evaluated to obtain a diff file (either ed-style
|
|
or unified-style) from two versions of a file.
|
|
|
|
`:help diffexpr`
|
|
`:help diff-diffexpr`
|
|
'';
|
|
};
|
|
|
|
diffopt = mkOption {
|
|
type = nullOr (listOf string);
|
|
default = null;
|
|
description = ''
|
|
Option settings for diff mode.
|
|
|
|
`:help diffopt`
|
|
'';
|
|
};
|
|
|
|
digraph = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
description = ''
|
|
Enable the entering of digraphs in Insert mode with {char1} <BS> {char2}.
|
|
|
|
`:help digraph`
|
|
`:help digraphs`
|
|
'';
|
|
};
|
|
|
|
directory = mkOption {
|
|
type = nullOr (listOf (either string path));
|
|
default = null;
|
|
description = ''
|
|
List of directory names for the swap file, separated with commas.
|
|
|
|
`:help directory`
|
|
'';
|
|
};
|
|
|
|
display = mkOption {
|
|
type = nullOr (listOf (enum [ "lastline" "truncate" "uhex" "msgsep" ]));
|
|
default = null;
|
|
description = ''
|
|
Change the way text is displayed.
|
|
|
|
`:help display`
|
|
'';
|
|
};
|
|
|
|
eadirection = mkOption {
|
|
type = nullOr (enum [ "ver" "hor" "both" ]);
|
|
default = null;
|
|
description = ''
|
|
Tells when the 'equalalways' option applies:
|
|
|
|
`:help eadirection`;
|
|
'';
|
|
};
|
|
|
|
emoji = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
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.
|
|
|
|
`:help emoji`
|
|
'';
|
|
};
|
|
|
|
equalalways = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
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.
|
|
|
|
`:help equalalways`
|
|
'';
|
|
};
|
|
|
|
equalprg = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
description = ''
|
|
External program to use for "=" command. When this option is empty
|
|
the internal formatting functions are used; either 'lisp', 'cindent'
|
|
or 'indentexpr'.
|
|
|
|
`:help equalprg`
|
|
'';
|
|
};
|
|
|
|
errorbells = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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
|
|
|
|
`:help errorbells`
|
|
'';
|
|
};
|
|
|
|
errorfile = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "errors.err";
|
|
description = ''
|
|
Name of the errorfile for the QuickFix mode.
|
|
|
|
`:help errorfile`
|
|
`:help cf`
|
|
'';
|
|
};
|
|
|
|
errorformat = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
description = ''
|
|
Scanf-like description of the format for the lines in the error file
|
|
|
|
`:help errorformat`
|
|
'';
|
|
};
|
|
|
|
eventignore = mkOption {
|
|
type = nullOr (listOf string);
|
|
default = null;
|
|
defaultText = literalExpression "[]";
|
|
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.
|
|
|
|
`:help eventignore`
|
|
'';
|
|
};
|
|
|
|
exrc = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help exrc`
|
|
`:help :trust`
|
|
'';
|
|
};
|
|
|
|
fileencodings = mkOption {
|
|
type = nullOr (listOf string);
|
|
default = null;
|
|
defaultText = literalExpression ''["ucs-bom" "utf-8" "default" "latin1"]'';
|
|
description = ''
|
|
This is a list of character encodings considered when starting to edit
|
|
an existing file.
|
|
|
|
`:help fileencodings`
|
|
'';
|
|
};
|
|
|
|
fileformats = mkOption {
|
|
type = nullOr (listOf (enum [ "dos" "unix" "mac" ]));
|
|
default = null;
|
|
defaultText = literalExpression ''
|
|
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
|
|
|
|
`:help fileformats`
|
|
'';
|
|
};
|
|
|
|
fileignorecase = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = ''
|
|
`true` for systems where case in file names is normally ignored"
|
|
'';
|
|
description = ''
|
|
When set case is ignored when using file names and directories.
|
|
|
|
`:help fileignorecase`
|
|
'';
|
|
};
|
|
|
|
foldclose = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
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.
|
|
|
|
`:help foldclose`
|
|
'';
|
|
};
|
|
|
|
foldlevelstart = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
defaultText = literalExpression "-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.
|
|
|
|
`:help foldlevelstart`
|
|
`:help foldlevel`
|
|
'';
|
|
};
|
|
|
|
foldopen = mkOption {
|
|
type = nullOr (listOf (enum [
|
|
"all"
|
|
"block"
|
|
"hor"
|
|
"insert"
|
|
"jump"
|
|
"mark"
|
|
"percent"
|
|
"quickfix"
|
|
"search"
|
|
"tag"
|
|
"undo"
|
|
]));
|
|
default = null;
|
|
defaultText = literalExpression ''
|
|
[
|
|
"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.
|
|
|
|
`:help foldopen`
|
|
'';
|
|
};
|
|
|
|
fsync = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help fsync`;
|
|
'';
|
|
};
|
|
|
|
gdefault = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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|.
|
|
|
|
`:help gdefault`
|
|
'';
|
|
};
|
|
|
|
grepformat = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = literalExpression ''%f:%l:%m,%f:%l%m,%f %l%m'';
|
|
description = ''
|
|
Format to recognize for the ":grep" command output.
|
|
|
|
`:help grepformat`
|
|
`:help errorformat`
|
|
'';
|
|
};
|
|
|
|
guicursor = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "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
|
|
|
|
`:help guicursor`
|
|
'';
|
|
};
|
|
|
|
guifont = mkOption {
|
|
type = nullOr (listOf string);
|
|
default = null;
|
|
defaultText = literalExpression "[]";
|
|
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.
|
|
|
|
`:help guifont`
|
|
'';
|
|
};
|
|
|
|
guifontwide = mkOption {
|
|
type = nullOr (listOf string);
|
|
default = null;
|
|
defaultText = literalExpression "[]";
|
|
description = ''
|
|
list of fonts to be used for double-width characters.
|
|
The first font that can be loaded is used.
|
|
|
|
`:help guifontwide`
|
|
'';
|
|
};
|
|
|
|
guioptions = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "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.
|
|
|
|
`:help guioptions`
|
|
'';
|
|
};
|
|
|
|
guitablabel = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
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.
|
|
|
|
`:help guitablabel`
|
|
`:help setting-guitablabel`
|
|
'';
|
|
};
|
|
|
|
guitabtooltip = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
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.
|
|
|
|
`:help guitabtooltip`
|
|
'';
|
|
};
|
|
|
|
helpfile = mkOption {
|
|
type = nullOr (either string path);
|
|
default = null;
|
|
defaultText = literalExpression ''
|
|
default (MS-Windows) "$VIMRUNTIME\doc\help.txt"
|
|
(others) "$VIMRUNTIME/doc/help.txt"
|
|
|
|
`:help helpfile`
|
|
'';
|
|
};
|
|
|
|
helpheight = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
defaultText = literalExpression "20";
|
|
description = ''
|
|
Minimal initial height of the help window when it is opened with the ":help" command.
|
|
|
|
`:help helpheight`
|
|
'';
|
|
};
|
|
|
|
helplang = mkOption {
|
|
type = nullOr (listOf string);
|
|
default = null;
|
|
defaultText = literalExpression "messages language or empty";
|
|
description = ''
|
|
list of languages. Vim will use the first language
|
|
for which the desired help can be found.
|
|
|
|
`:help helplang`
|
|
'';
|
|
};
|
|
|
|
hidden = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help hidden`
|
|
`:help abadon`
|
|
`:help bufhidden`
|
|
'';
|
|
};
|
|
|
|
history = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help history`
|
|
`:help cmdline-editing`
|
|
'';
|
|
};
|
|
|
|
hlsearch = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "true";
|
|
description = ''
|
|
When there is a previous search pattern, highlight all its matches.
|
|
|
|
`:help hlsearch`
|
|
`:help incsearch`
|
|
`:help match`
|
|
'';
|
|
};
|
|
|
|
icon = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "false";
|
|
description = ''
|
|
When on, the icon text of the window will be set to the value of
|
|
'iconstring' (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 'iconstring' option.
|
|
Only works if the terminal supports setting window icons.
|
|
|
|
`:help icon`
|
|
`:help iconstring`
|
|
'';
|
|
};
|
|
|
|
iconstring = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
description = ''
|
|
When this option is not empty, it will be used for the icon text of the window.
|
|
|
|
`:help iconstring`
|
|
'';
|
|
};
|
|
|
|
ignorecase = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = "false";
|
|
description = ''
|
|
Ignore case in search patterns. Also used when searching in the tags file.
|
|
|
|
Also see 'smartcase' and 'tagcase'.
|
|
|
|
`:help ignorecase`
|
|
'';
|
|
};
|
|
|
|
imcmdline = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "false";
|
|
description = ''
|
|
When set the Input Method is always on when starting to edit a command
|
|
line, unless entering a search pattern.
|
|
|
|
`:help imcmdline`
|
|
`:help imsearch`
|
|
'';
|
|
};
|
|
|
|
imdisable = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "default 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.
|
|
|
|
`:help imdisable`
|
|
'';
|
|
};
|
|
|
|
inccommand = mkOption {
|
|
type = nullOr (enum [ "nosplit" "split" ]);
|
|
default = null;
|
|
defaultText = "nosplit";
|
|
description = ''
|
|
When nonempty, shows the effects of |:substitute|, |:smagic|,
|
|
|:snomagic| and user commands with the |:command-preview| flag as you
|
|
type.
|
|
|
|
`:help inccommand`
|
|
'';
|
|
};
|
|
|
|
incsearch = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "true";
|
|
description = ''
|
|
While typing a search command, show where the pattern, as it was typed
|
|
so far, matches. The matched string is highlighted. If the pattern
|
|
is invalid or not found, nothing is shown.
|
|
|
|
`:help incsearch`
|
|
'';
|
|
};
|
|
|
|
isfname = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = literalExpression ''
|
|
Windows: "@,48-57,/,\,.,-,_,+,,,#,$,%,{,},[,],:,@-@,!,~,="
|
|
otherwise: "@,48-57,/,.,-,_,+,,,#,$,%,~,="
|
|
'';
|
|
};
|
|
|
|
isident = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = literalExpression ''
|
|
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.
|
|
|
|
`:help isident`
|
|
'';
|
|
};
|
|
|
|
isprint = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "@,161-255";
|
|
description = ''
|
|
The characters given by this option are displayed directly on the
|
|
screen. It is also used for "\p" in a |pattern|.
|
|
|
|
`:help isprint`
|
|
`:help pattern`
|
|
'';
|
|
};
|
|
|
|
jumpoptions = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = ''
|
|
List of words that change the behavior of the |jumplist|
|
|
|
|
`:help jumpoptions`
|
|
`:help jumplist`
|
|
'';
|
|
};
|
|
|
|
joinspaces = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "false";
|
|
description = ''
|
|
Insert two spaces after a '.', '?' and '!' with a join command.
|
|
Otherwise only one space is inserted.
|
|
|
|
`:help joinspaces`
|
|
'';
|
|
};
|
|
|
|
keymodel = mkOption {
|
|
type = nullOr (listOf string);
|
|
default = null;
|
|
defaultText = literalExpression "[]";
|
|
description = ''
|
|
List of comma-separated words, which enable special things that keys can do.
|
|
|
|
`:help keymodel`
|
|
'';
|
|
};
|
|
|
|
langmap = mkOption {
|
|
type = nullOr (listOf string);
|
|
default = null;
|
|
defaultText = literalExpression "[]";
|
|
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.
|
|
|
|
`:help langmap`
|
|
'';
|
|
};
|
|
|
|
langmenu = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
description = ''
|
|
Language to use for menu translation.
|
|
|
|
`:help langmenu`
|
|
'';
|
|
};
|
|
|
|
langremap = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help langremap`
|
|
'';
|
|
};
|
|
|
|
laststatus = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
defaultText = literalExpression "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
|
|
|
|
`:help laststatus`
|
|
'';
|
|
};
|
|
|
|
lazyredraw = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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|.
|
|
|
|
`:help lazyredraw`
|
|
`:help :redraw`
|
|
'';
|
|
};
|
|
|
|
linespace = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help linespace`
|
|
'';
|
|
};
|
|
|
|
loadplugins = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help loadplugins`
|
|
'';
|
|
};
|
|
|
|
magic = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help magic`
|
|
'';
|
|
};
|
|
|
|
makeef = mkOption {
|
|
type = nullOr (either string path);
|
|
default = null;
|
|
defaultText = "";
|
|
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.
|
|
|
|
`:help makeef`
|
|
'';
|
|
};
|
|
};
|
|
|
|
window = with lib; with types; sharedGlobalOrWindow // {
|
|
arabic = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "false";
|
|
description = ''
|
|
This option can be set to start editing Arabic text.
|
|
|
|
`:help arabic`
|
|
'';
|
|
};
|
|
|
|
breakindent = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help breakindent`
|
|
'';
|
|
};
|
|
|
|
breakindentopt = mkOption {
|
|
type = nullOr commas;
|
|
default = null;
|
|
defaultText = literalExpression "[]";
|
|
description = ''
|
|
Settings for 'breakindent
|
|
|
|
`:help breakindentopt`
|
|
'';
|
|
};
|
|
|
|
colorcolumn = mkOption {
|
|
type = nullOr commas;
|
|
default = null;
|
|
defaultText = literalExpression "[]";
|
|
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.
|
|
|
|
`:help colorcolumn`
|
|
'';
|
|
};
|
|
|
|
foldcolumn = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "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
|
|
|
|
`:help foldcolumn`
|
|
`:help folding`
|
|
'';
|
|
};
|
|
|
|
foldenable = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help foldenable`
|
|
`:help folding`
|
|
'';
|
|
};
|
|
|
|
foldexpr = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "0";
|
|
description = ''
|
|
The expression used for when 'foldmethod' is "expr". It is evaluated
|
|
for each line to obtain its fold level.
|
|
|
|
`:help foldexpr`
|
|
`:help fold-expr`
|
|
'';
|
|
};
|
|
|
|
foldignore = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "#";
|
|
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.
|
|
|
|
`:help foldignore`
|
|
`:help fold-indent`
|
|
'';
|
|
};
|
|
|
|
foldlevel = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
defaultText = literalExpression "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|.
|
|
|
|
`:help foldlevel`
|
|
`:help fold-foldlevel`
|
|
'';
|
|
};
|
|
|
|
foldmarker = mkOption {
|
|
type = nullOr (listOf string);
|
|
apply = x: assert (x == null || builtins.length x == 2 || abort "`foldmarker` must contain start and end markers in the list"); x;
|
|
default = null;
|
|
defaultText = literalExpression ''["{{{" "}}}"]'';
|
|
description = ''
|
|
The start and end marker used when 'foldmethod' is "marker".
|
|
|
|
`:help foldmarker`
|
|
'';
|
|
};
|
|
|
|
foldmethod = mkOption {
|
|
type = nullOr (enum [ "manual" "indent" "expr" "marker" "syntax" "diff" ]);
|
|
default = null;
|
|
defaultText = "manual";
|
|
description = ''
|
|
The kind of folding used for the current window.
|
|
|
|
`:help foldmethod`
|
|
`:help fold-manual`
|
|
`:help fold-indent`
|
|
`:help fold-expr`
|
|
`:help fold-marker`
|
|
`:help fold-syntax`
|
|
`:help fold-diff`
|
|
'';
|
|
};
|
|
|
|
foldminlines = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
defaultText = literalExpression "1";
|
|
description = ''
|
|
Sets the number of screen lines above which a fold can be displayed
|
|
closed. Also for manually closed folds.
|
|
|
|
`:help foldminlines`
|
|
'';
|
|
};
|
|
|
|
foldnestmax = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help foldnestmax`
|
|
'';
|
|
};
|
|
|
|
foldtext = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "foldtext()";
|
|
description = ''
|
|
An expression which is used to specify the text displayed for a closed fold.
|
|
|
|
`:help foldtext`
|
|
`:help fold-foldtext`
|
|
'';
|
|
};
|
|
|
|
linebreak = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help linebreak`
|
|
'';
|
|
};
|
|
|
|
list = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = "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.
|
|
|
|
`:help list`
|
|
`:help listchars`
|
|
'';
|
|
};
|
|
|
|
listchars = mkOption {
|
|
type = submodule {
|
|
options =
|
|
let
|
|
inherit (builtins) stringLength;
|
|
mkOption = { description, min ? 1, max ? 1 }: with lib; lib.mkOption {
|
|
type = types.nullOr types.string;
|
|
default = null;
|
|
apply = x:
|
|
assert (
|
|
(stringLength x >= min && stringLength x <= max)
|
|
|| abort ''
|
|
The number of characters ${x} does not correspond to the boundaries
|
|
(min: ${toString min}; max: ${toString max})
|
|
''
|
|
);
|
|
x;
|
|
inherit description;
|
|
};
|
|
in
|
|
{
|
|
eol = mkOption {
|
|
description = ''
|
|
Character to show at the end of each line. When
|
|
omitted, there is no extra character at the end of the
|
|
line.
|
|
|
|
`:help lcs-eol`
|
|
'';
|
|
};
|
|
|
|
tab = mkOption {
|
|
description = ''
|
|
Two or three characters to be used to show a tab.
|
|
The third character is optional.
|
|
|
|
`:help lcs-tab`
|
|
'';
|
|
max = 3;
|
|
};
|
|
|
|
space = mkOption {
|
|
description = ''
|
|
Character to show for a space. When omitted, spaces are left blank.
|
|
|
|
`:help lcs-space`
|
|
'';
|
|
};
|
|
|
|
multispace = mkOption {
|
|
description = ''
|
|
One or more characters to use cyclically to show for
|
|
multiple consecutive spaces. Overrides the "space"
|
|
setting, except for single spaces.
|
|
|
|
`:help lcs-multispace`
|
|
'';
|
|
max = 99;
|
|
};
|
|
|
|
lead = mkOption {
|
|
description = ''
|
|
Character to show for leading spaces. When omitted,
|
|
leading spaces are blank. Overrides the "space" and
|
|
"multispace" settings for leading spaces.
|
|
|
|
`:help lcs-lead`
|
|
'';
|
|
};
|
|
|
|
leadmultispace = mkOption {
|
|
description = ''
|
|
Like the |lcs-multispace| value, but for leading
|
|
spaces only. Also overrides |lcs-lead| for leading
|
|
multiple spaces.
|
|
|
|
`:help lcs-leadmultispace`
|
|
'';
|
|
max = 99;
|
|
};
|
|
|
|
trail = mkOption {
|
|
description = ''
|
|
Character to show for trailing spaces. When omitted,
|
|
trailing spaces are blank. Overrides the "space" and
|
|
"multispace" settings for trailing spaces.
|
|
|
|
`:help lcs-trail`
|
|
'';
|
|
};
|
|
|
|
extends = mkOption {
|
|
description = ''
|
|
Character to show in the last column, when 'wrap' is
|
|
off and the line continues beyond the right of the
|
|
screen.
|
|
|
|
`:help lcs-extends`
|
|
'';
|
|
};
|
|
|
|
precedes = mkOption {
|
|
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.
|
|
|
|
`:help lcs-precedes`
|
|
'';
|
|
};
|
|
|
|
conceal = mkOption {
|
|
description = ''
|
|
Character to show in place of concealed text, when
|
|
'conceallevel' is set to 1. A space when omitted.
|
|
|
|
`:help lcs-conceal`
|
|
'';
|
|
};
|
|
|
|
nbsp = mkOption {
|
|
description = ''
|
|
Character to show for a non-breakable space character
|
|
(0xA0 (160 decimal) and U+202F).
|
|
|
|
`:help nbsp`
|
|
'';
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
buffer = with lib; with types; sharedGlobalOrBuffer // {
|
|
autoindent = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help autoindent`
|
|
'';
|
|
};
|
|
|
|
binary = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "false";
|
|
description = ''
|
|
This option should be set before editing a binary file. You can also
|
|
use the |-b| Vim argument.
|
|
|
|
`:help binary`
|
|
'';
|
|
};
|
|
|
|
bomb = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help bomb`
|
|
'';
|
|
};
|
|
|
|
bufhidden = mkOption {
|
|
type = nullOr (enum [ "" "hide" "unload" "delete" "wipe" ]);
|
|
default = null;
|
|
defaultText = "";
|
|
description = ''
|
|
This option specifies what happens when a buffer is no longer
|
|
displayed in a window
|
|
|
|
`:help bufhidden`
|
|
'';
|
|
};
|
|
|
|
buflisted = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "true";
|
|
description = ''
|
|
When this option is set, the buffer shows up in the buffer list.
|
|
|
|
`:help buflisted`
|
|
'';
|
|
};
|
|
|
|
buftype = mkOption {
|
|
type = nullOr (enum [ "" "acwrite" "help" "nofile" "nowrite" "quickfix" "terminal" "prompt" ]);
|
|
default = null;
|
|
defaultText = "";
|
|
description = ''
|
|
This option is used together with 'bufhidden' and 'swapfile' to
|
|
specify special kinds of buffers.
|
|
|
|
`:help buftype`
|
|
`:help special-buffers`
|
|
'';
|
|
};
|
|
|
|
cindent = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "false";
|
|
description = ''
|
|
Enables automatic C program indenting.
|
|
|
|
`:help cindent`
|
|
'';
|
|
};
|
|
|
|
cinkeys = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "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.
|
|
|
|
`:help cinkeys`
|
|
'';
|
|
};
|
|
|
|
cinoptions = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
description = ''
|
|
The 'cinoptions' affect the way 'cindent' reindents lines in a C
|
|
program.
|
|
|
|
`:help cinoptions`
|
|
`:help cinoptions-values`
|
|
'';
|
|
};
|
|
|
|
cinwords = mkOption {
|
|
type = nullOr commas;
|
|
default = null;
|
|
defaultText = literalExpression ''["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 {}).
|
|
|
|
`:help cinwords`
|
|
'';
|
|
};
|
|
|
|
cinscopedecls = mkOption {
|
|
type = nullOr commas;
|
|
default = null;
|
|
defaultText = literalExpression ''["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"
|
|
|
|
`:help cinscopedecls`
|
|
'';
|
|
};
|
|
|
|
comments = mkOption {
|
|
type = nullOr commas;
|
|
default = null;
|
|
defaultText = literalExpression ''
|
|
[
|
|
"s1/*"
|
|
"mb:8"
|
|
"ex:*/"
|
|
"://"
|
|
"b:#"
|
|
":%"
|
|
":XCOMM"
|
|
"n:>"
|
|
"fb:-"
|
|
]
|
|
'';
|
|
description = ''
|
|
list of strings that can start a comment line.
|
|
|
|
`:help comments`
|
|
`:help format-comments`
|
|
'';
|
|
};
|
|
|
|
expandtab = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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 = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
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).
|
|
|
|
`:help fileencoding`
|
|
'';
|
|
};
|
|
|
|
fileformat = mkOption {
|
|
type = nullOr (enum [ "dos" "unix" "mac" ]);
|
|
default = null;
|
|
defaultText = literalExpression ''
|
|
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 = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
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.
|
|
|
|
`:help filetype`
|
|
`:help :filetype`
|
|
'';
|
|
|
|
};
|
|
|
|
fixendofline = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help fixendofline`
|
|
`:help binary`
|
|
`:help endofline`
|
|
`:help eol-and-eof`
|
|
'';
|
|
};
|
|
|
|
formatexpr = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
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.
|
|
|
|
`:help formatexpr`
|
|
'';
|
|
};
|
|
|
|
formatlistpat = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = ''^\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
|
|
|
|
`:help formatlistpat`
|
|
`:help formatoptions`
|
|
'';
|
|
};
|
|
|
|
formatoptions = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "tcqj";
|
|
description = ''
|
|
This is a sequence of letters which describes how automatic
|
|
formatting is to be done.
|
|
|
|
`:help formatoptios`
|
|
`:help fo-table`
|
|
'';
|
|
};
|
|
|
|
iminsert = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
defaultText = literalExpression "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
|
|
|
|
`:help iminsert`
|
|
'';
|
|
};
|
|
|
|
imsearch = mkOption {
|
|
type = nullOr number;
|
|
default = null;
|
|
defaultText = literalExpression "-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
|
|
|
|
`:help imsearch`
|
|
'';
|
|
};
|
|
|
|
includexpr = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
description = ''
|
|
Expression to be used to transform the string found with the 'include'
|
|
option to a file name.
|
|
|
|
`:help includexpr`
|
|
'';
|
|
};
|
|
|
|
indentexpr = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
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.
|
|
|
|
`:help indentexpr`
|
|
'';
|
|
};
|
|
|
|
indentkeys = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "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.
|
|
|
|
`:help indentkeys`
|
|
'';
|
|
};
|
|
|
|
infercase = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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.
|
|
|
|
`:help infercase`
|
|
'';
|
|
};
|
|
|
|
iskeyward = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "@,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|.
|
|
|
|
`:help iskeyword`
|
|
`:help pattern`
|
|
'';
|
|
|
|
};
|
|
|
|
keymap = mkOption {
|
|
type = nullOr string;
|
|
default = null;
|
|
defaultText = "";
|
|
description = ''
|
|
Name of a keyboard mapping.
|
|
|
|
`:help keymap`
|
|
`:help mbyte-keymap`
|
|
'';
|
|
};
|
|
|
|
lisp = mkOption {
|
|
type = nullOr bool;
|
|
default = null;
|
|
defaultText = literalExpression "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".
|
|
|
|
`:help lisp`
|
|
'';
|
|
};
|
|
|
|
lispoptions = mkOption {
|
|
type = nullOr (listOf string);
|
|
default = null;
|
|
defaultText = listExpression "[]";
|
|
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)
|
|
|
|
`:help lispoptions`
|
|
'';
|
|
};
|
|
};
|
|
in
|
|
{
|
|
inherit global window buffer;
|
|
all = global // window // buffer;
|
|
}
|