From 3d64ef464a4a534a079d538d4848c78fb0a2e7d9 Mon Sep 17 00:00:00 2001 From: Dmitriy Pleshevskiy Date: Mon, 13 May 2024 14:30:59 +0300 Subject: [PATCH] wip --- modules/vim/options.nix | 1866 +++++++++++++++++++++++++++++++++++++++ modules/vim/opts.nix | 13 +- 2 files changed, 1868 insertions(+), 11 deletions(-) create mode 100644 modules/vim/options.nix diff --git a/modules/vim/options.nix b/modules/vim/options.nix new file mode 100644 index 0000000..f06c4e3 --- /dev/null +++ b/modules/vim/options.nix @@ -0,0 +1,1866 @@ +{ lib }: + +let + shared = with lib; with types; { + # global or window + 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` + ''; + }; + + # global or buffer + 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` + ''; + }; + + # global or buffer + grepprg = mkOption { + type = nullOr string; + default = null; + defaultText = literalExpression '' + default "grep -n ", + Unix: "grep -n $* /dev/null" + + `:help grepprg` + ''; + }; + + # global or buffer + include = mkOption { + type = nullOr string; + default = null; + defaultText = ''^\s*#\s*include''; + description = '' + Pattern to be used to find an include command. + + `:help include` + ''; + }; + + # global or buffer + keywordprg = mkOption { + type = nullOr string; + default = null; + defaultText = literalExpression '' + Windows: ":help" + otherwise: ":Man" + ''; + description = '' + Program to use for the |K| command. + + `:help keywordprg` + ''; + }; + + # global or buffer + 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` + ''; + }; + }; + + global = with lib; with types; { + inherit (shared) fillchars formatprg grepprg include keywordprg lispwords; + + 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` + ''; + }; + # TODO: arabic, arabicshape + # TODO: autoindent + 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` + ''; + }; + + 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 , , 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` + ''; + }; + + 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` + ''; + }; + + 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 or and deleting results in an error. + cursor | Fail to move around using the cursor keys or + | / 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 in Insert mode. + error | Other Error occurred (e.g. try to join last line) + | (mostly used in |Normal-mode| or |Cmdline-mode|). + esc | hitting 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 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` + ''; + }; + + # TODO: binary + # TODO: bomb + + 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` + ''; + }; + # TODO: breakindent, breakindentopt + + 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` + ''; + }; + + # TODO: bufhidden, buflisted, buftype + + 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` + ''; + }; + + 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} {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 () 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; { + inherit (shared) fillchars; + + 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 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; { + inherit (shared) formatprg grepprg include keywordprg lispwords; + + expandtab = mkOption { + type = nullOr bool; + default = null; + defaultText = literalExpression "false"; + description = '' + In Insert mode: Use the appropriate number of spaces to insert a + . 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. 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 of the current buffer, which is used for + reading/writing the buffer from/to a file: + - dos + - unix + - mac + 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, 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 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; +} diff --git a/modules/vim/opts.nix b/modules/vim/opts.nix index f2ea2fd..34aca32 100644 --- a/modules/vim/opts.nix +++ b/modules/vim/opts.nix @@ -1,22 +1,13 @@ { config, lib, ... }: +let options = import ./options.nix { inherit lib; }; in { options.vim = with lib; with types; { g = mkOption { type = attrsOf (oneOf [ str bool number ]); default = { }; }; - opt = mkOption { - type = attrsOf anything; - default = { }; - description = '' - A special interface |vim.opt| exists for conveniently interacting with list- - and map-style option from Lua: It allows accessing them as Lua tables and - offers object-oriented method for adding and removing entries. - - `:help vim.opt` - ''; - }; + opt = options.all; # TODO: think more about vim.cmd namedCmd = mkOption {