Yggdroot (Yggdroot)

用 C++14 写了个模糊查找命令行工具

Yggdroot — Thu, 30 Dec 2021 17:21:02 +0800

https://github.com/Yggdroot/Yoyo-leaf

速度快
查找准确
持续更新中

欢迎批评指正。

Vim 的模糊查找插件 LeaderF 新功能介绍 (二)

Yggdroot — Mon, 28 Oct 2019 18:05:07 +0800

前言

本文介绍自《vim 的模糊查找插件 LeaderF 新功能介绍》以后，LeaderF 增加的一些新的功能。

异步 grep `Leaderf rg`

此功能已经在《vim 的 grep 插件 Leaderf rg：grep 和模糊匹配的完美结合》做了介绍。 补充一点：应很多用户的要求，现在支持使用Leaderf rg {pattern}来搜索了，不必使用Leaderf rg -e {pattern}了。当然，如果想指定多个 pattern，还是需要加上-e, 比如：Leaderf rg -e foo -e bar。

使用 gtags 导航 `Leaderf gtags`

此功能已经在《Leaderf gtags：模糊匹配与最强静态符号索引工具的完美结合》做了介绍。

增强使用 vimL 给 LeaderF 写扩展的功能

此前只可以为 vim 写，现在也可以为 neovim 写了。具体内容参见：https://github.com/Yggdroot/LeaderF/issues/144#issuecomment-540008950

`Leaderf {cmd} --recall`

这个命令是在 LeaderF 窗口关闭的情况下，召回最后的搜索结果，{cmd}可以是 LeaderF 目前支持的所有命令，像 file, mru, rg, gtags 等。例如：使用 Leaderf file --recall

Leaderf --recall 是召回上一个命令的最后搜索结果。例如，刚使用完Leaderf file，执行Leaderf --recall 相当于执行Leaderf file --recall, 刚使用完Leaderf rg -e foo, 执行Leaderf --recall 相当于执行Leaderf rg --recall。

`Leaderf file` 根据当前 buffer 名字查询文件

打开Leaderf file时，如果没有输入任何查询字符，文件列表会按照最匹配当前 buffer 路径名字来排序。这在某些场景比较有用，比如当前 buffer 名字是foo.go，想切换到foo_test.go。

`Leaderf file` 在搜索结果中不显示当前 buffer 的名字

只要 let g:Lf_IgnoreCurrentBufferName = 1，缺省会显示。

使用 popup window / floating window 预览

let g:Lf_PreviewInPopup = 1 就可以启用这个功能，缺省未启用。 g:Lf_PreviewHorizontalPosition 指定 popup window / floating window 的位置。 g:Lf_PreviewPopupWidth 指定 popup window / floating window 的宽度。

`Leaderf gtags`：模糊匹配与最强静态符号索引工具的完美结合

Yggdroot — Mon, 06 May 2019 17:50:15 +0800

Gtags

Gtags 也就是GNU GLOBAL，是一个非常强大的源码符号索引工具。它通过建立索引数据库，不但可以查找函数的定义，还可以查找函数的所有引用（被调用的地方）；而且它还可以增量地更新索引数据库，当代码有所改变时，它可以在很短的时间内更新索引数据库，保持索引数据库和代码同步。
韦大的 Vim 8 中 C/C++ 符号索引：GTags 篇对 gtags 有比较详细的介绍，本文再做一些补充。

GLOBAL-6.6.3 released Gtags 的最新版本已经是 6.6.3，该版本 fix 了韦大文中提到的 Windows 下面文件名大小写的 bug。
在 Linux 上，不配置let $GTAGSCONF = '/path/to/share/gtags/gtags.conf'也可以正常工作。
当项目文件的路径包含非 ASCII 字符时，使用 pygments 会报UnicodeEncodeError: 'latin-1' codec can't encode characters in position 5-8: ordinal not in range(256)

自动生成 Gtags 索引数据库

LeaderF 可以自己管理 gtags 数据库（GTAGS，GRTAGS，GPATH），它不会在你的项目目录下生成任何额外的文件或目录。gtags 数据库文件存储在$HOME/.LfCache/gtags/%PATH%OF%YOUR%PROJECT/下面， %PATH%OF%YOUR%PROJECT 是把你项目路径中的 \ 或 / 替换成 %。
只要设置let g:Lf_GtagsAutoGenerate = 1，LeaderF 就会在打开第一个文件时自动生成 gtags 数据库。当代码有更改并且已经有 gtags 数据库生成时，更改的代码会自动同步到 gtags 数据库（即使g:Lf_GtagsAutoGenerate是 0）。
只有在项目根目录下有g:Lf_RootMarkers（默认值是['.git', '.hg', '.svn']）里面指定的文件或目录时，LeaderF 才会自动生成 gtags 数据库；否则只能手动生成 gtags 数据库：Leaderf gtags --update，但是当代码有更改时，gtags 数据库依然可以自动更新。

Leaderf gtags 使用介绍

具体使用方法可以用:Leaderf gtags -h来查看。

usage:
Leaderf[!] gtags [-h] [--remove] [--recall]
Leaderf[!] gtags --update [--gtagsconf <FILE>] [--gtagslabel <LABEL>] [--accept-dotfiles]
                 [--skip-unreadable] [--skip-symlink [<TYPE>]] [--gtagslibpath <PATH> [<PATH> ...]]
Leaderf[!] gtags [--current-buffer | --all-buffers | --all] [--result <FORMAT>] [COMMON_OPTIONS]
Leaderf[!] gtags -d <PATTERN> [--auto-jump [<TYPE>]] [-i] [--literal] [--path-style <FORMAT>] [-S <DIR>]
                 [--append] [--match-path] [--gtagsconf <FILE>] [--gtagslabel <LABEL>] [COMMON_OPTIONS]
Leaderf[!] gtags -r <PATTERN> [--auto-jump [<TYPE>]] [-i] [--literal] [--path-style <FORMAT>] [-S <DIR>]
                 [--append] [--match-path] [--gtagsconf <FILE>] [--gtagslabel <LABEL>] [COMMON_OPTIONS]
Leaderf[!] gtags -s <PATTERN> [-i] [--literal] [--path-style <FORMAT>] [-S <DIR>] [--append]
                 [--match-path] [--gtagsconf <FILE>] [--gtagslabel <LABEL>] [COMMON_OPTIONS]
Leaderf[!] gtags -g <PATTERN> [-i] [--literal] [--path-style <FORMAT>] [-S <DIR>] [--append]
                 [--match-path] [--gtagsconf <FILE>] [--gtagslabel <LABEL>] [COMMON_OPTIONS]
Leaderf[!] gtags --by-context [-i] [--literal] [--path-style <FORMAT>] [-S <DIR>] [--append]
                 [--match-path] [--gtagsconf <FILE>] [--gtagslabel <LABEL>] [COMMON_OPTIONS]

[COMMON_OPTIONS]: [--reverse] [--stayOpen] [--input <INPUT> | --cword]
                  [--top | --bottom | --left | --right | --belowright | --aboveleft | --fullScreen]
                  [--nameOnly | --fullPath | --fuzzy | --regexMode] [--nowrap]


optional arguments:
  -h, --help            show this help message and exit

specific arguments:
  --update              Create tag files if tag files do not exist, update the tag files otherwise.
  --remove              Remove the tag files generated.
  --accept-dotfiles     Accept files and directories whose names begin with a dot. By default, gtags
                        ignores them.
  --skip-unreadable     Skip unreadable files.
  --gtagsconf <FILE>    Set environment variable GTAGSCONF to <FILE>.
  --gtagslabel <LABEL>  Set environment variable GTAGSLABEL to <LABEL>.
  --skip-symlink [<TYPE>]
                        Skip symbolic links. If type is 'f' then skip only symbolic links for file, else
                        if 'd' then skip only symbolic links for directory. The default value of type is
                        'a' (all symbolic links).
  --gtagslibpath <PATH> [<PATH> ...]
                        Specify the paths to search for library functions.
  -d <PATTERN>, --definition <PATTERN>
                        Show locations of definitions.
  -r <PATTERN>, --reference <PATTERN>
                        Show reference to a symbol which has definitions.
  -s <PATTERN>, --symbol <PATTERN>
                        Show reference to a symbol which has no definition.
  -g <PATTERN>, --grep <PATTERN>
                        Show all lines which match to the <PATTERN>.
  --by-context          Decide tag type by context at cursor position. If the context is a definition of
                        the pattern then use -r, else if there is at least one definition of the pattern
                        then use -d, else use -s. Regular expression is not allowed for pattern.
  -i, --ignore-case     Ignore case distinctions in the pattern.
  --literal             Execute literal search instead of regular expression search.
  --path-style <FORMAT>
                        Show path names using <FORMAT>, which may be one of: `relative`, `absolute`,
                        `shorter`, `abslib` or `through`. `relative` means relative path. `absolute`
                        means absolute path. `shorter` means the shorter one of relative and absolute
                        path. `abslib` means absolute path for libraries (GTAGSLIBPATH) and relative path
                        for the rest. `through` means the relative path from the project root directory
                        (internal format of GPATH). The default is `relative`.
  -S <DIR>, --scope <DIR>
                        Show only tags which exist under <DIR> directory.
  --recall              Recall last search. If the result window is closed, reopen it.
  --match-path          Match the file path when fuzzy searching.
  --append              Append to the previous search results.
  --current-buffer      Show tags in current buffer.
  --all-buffers         Show tags in all listed buffers.
  --all                 Show tags in the whole project.
  --result <FORMAT>     Show result using format, which may be one of: `ctags`(default), `ctags-x`,
                        `ctags-mod`.
  --auto-jump [<TYPE>]  Jump to the tag directly when there is only one match. <TYPE> can be 'h', 'v' or
                        't', which mean jump to a horizontally, vertically split window, or a new tabpage
                        respectively. If <TYPE> is omitted, jump to a position in current window.

common arguments:
  --reverse             show results in bottom-up order
  --stayOpen            don't quit LeaderF after accepting an entry
  --input <INPUT>       specifies INPUT as the pattern inputted in advance
  --cword               current word under cursor is inputted in advance
  --top                 the LeaderF window is at the top of the screen
  --bottom              the LeaderF window is at the bottom of the screen
  --left                the LeaderF window is at the left of the screen
  --right               the LeaderF window is at the right of the screen
  --belowright          the LeaderF window is at the belowright of the screen
  --aboveleft           the LeaderF window is at the aboveleft of the screen
  --fullScreen          the LeaderF window takes up the full screen
  --nameOnly            LeaderF is in NameOnly mode by default
  --fullPath            LeaderF is in FullPath mode by default
  --fuzzy               LeaderF is in Fuzzy mode by default
  --regexMode           LeaderF is in Regex mode by default
  --nowrap              long lines in the LeaderF window won't wrap
  --next                Jump to the next result.
  --previous            Jump to the previous result.

If [!] is given, enter normal mode directly.

注意：如果:Leaderf后面有感叹号，会直接进入 normal 模式；如果没有感叹号，则是输入模式，此时可以输入字符来进行模糊匹配过滤。可以用 tab 键在两个模式间来回切换。

手动生成 gtags 数据库

Leaderf[!] gtags --update [--gtagsconf <FILE>] [--gtagslabel <LABEL>] [--accept-dotfiles]
                 [--skip-unreadable] [--skip-symlink [<TYPE>]] [--gtagslibpath <PATH> [<PATH> ...]]

此命令完全异步，不会卡住你的 UI。

--gtagsconf <FILE>

用来指定 gtags.conf 文件的路径，一般情况下不需要指定，默认值就可以很好地工作。对于 Windows 上，如果相对于gtags.exe所在路径有../share/gtags/gtags.conf，也不需要指定该选项。如果需要用户自己特有的针对 gtags 的配置，可以指定用户的配置文件。

也可以在vimrc里设置g:Lf_Gtagsconf达到同样的目的。
--gtagslabel <LABEL>

用来指定 gtagslabel，如果不指定，默认值是 'default'。<LABEL>是 gtags.conf 中的：
- default
  使用内置 parser，只支持 6 种语言（C，C++，Java，PHP4，Yacc，汇编）。
- ctags
  使用 exuberant-ctags 作为语言 parser，支持 40+ 种语言，只能生成定义索引不能生成引用索引。
- new-ctags
  使用 universal-ctags 作为语言 parser，支持 100+ 种语言，只能生成定义索引不能生成引用索引。虽然貌似 universal-ctags 已经支持生成引用 tags，但是依然不能配合 gtags 工作（见这里），我也试了各种操作都没成功，也许是因为这个 PR没有被 merge。
- pygments
  使用pygments作为语言 parser，号称支持 300+ 种语言。
- native-pygments
  对于原生支持的 6 种语言使用内置 parser，其他语言使用 pygments 作为 parser。
- 等等
也可以在vimrc里设置g:Lf_Gtagslabel达到同样的目的。
--gtagslibpath <PATH> [<PATH> ...]

用来指定项目所用 library 的 Paths，这样就可以生成 library 的索引，查找定义或引用时可以跳转到 library 代码中去。后面指定的路径还可以是一个或多个其他项目路径，跳转时可以跳到其他项目中的文件。

查找 tags

Leaderf[!] gtags [--current-buffer | --all-buffers | --all] [--result <FORMAT>] [COMMON_OPTIONS]

此命令可以列出当前 buffer、所有打开的 buffer 或者整个项目的 tags。

Leaderf[!] gtags等同于Leaderf[!] gtags --all，列出整个项目的 tags。
--result <FORMAT> 指定显示格式，可以是ctags(default), ctags-x或者ctags-mod。
- ctags 格式
- ctags-x 格式
- ctags-mod 格式

查找定义、引用

Leaderf[!] gtags -d <PATTERN> [--auto-jump [<TYPE>]] [-i] [--literal] [--path-style <FORMAT>] [-S <DIR>]
                 [--append] [--match-path] [--gtagsconf <FILE>] [--gtagslabel <LABEL>] [COMMON_OPTIONS]
Leaderf[!] gtags -r <PATTERN> [--auto-jump [<TYPE>]] [-i] [--literal] [--path-style <FORMAT>] [-S <DIR>]
                 [--append] [--match-path] [--gtagsconf <FILE>] [--gtagslabel <LABEL>] [COMMON_OPTIONS]

<PATTERN>可以是正则表达式。
--auto-jump [<TYPE>] 意思是如果只有一个结果直接跳过去。

其他

Leaderf[!] gtags -g <PATTERN>功能已被Leaderf rg包含。
Leaderf gtags --next 和 Leaderf gtags --previous相当于 quickfix 的:cnext和:cprevious命令，在 LeaderF 结果窗口关闭的情况下也可以使用。
更多内容请参考:Leaderf gtags -h 和 doc。

使用示例

let g:Lf_GtagsAutoGenerate = 1
let g:Lf_Gtagslabel = 'native-pygments'
noremap <leader>fr :<C-U><C-R>=printf("Leaderf! gtags -r %s --auto-jump", expand("<cword>"))<CR><CR>
noremap <leader>fd :<C-U><C-R>=printf("Leaderf! gtags -d %s --auto-jump", expand("<cword>"))<CR><CR>
noremap <leader>fo :<C-U><C-R>=printf("Leaderf! gtags --recall %s", "")<CR><CR>
noremap <leader>fn :<C-U><C-R>=printf("Leaderf gtags --next %s", "")<CR><CR>
noremap <leader>fp :<C-U><C-R>=printf("Leaderf gtags --previous %s", "")<CR><CR>

Vim 的 grep 插件`Leaderf rg`：grep 和模糊匹配的完美结合

Yggdroot — Mon, 14 Jan 2019 22:07:21 +0800

前言

vim 有很多著名的 grep 插件，我使用过的有 ack.vim，ag.vim 和 ctrlsf.vim，它们应该也是目前用户最多的几个了。

ack.vim
起步比较早，早期后端 grep 工具是 ack，后来也支持 ag(the_silver_searcher)，pt(the_platinum_searcher)，rg(ripgrep) 等工具了。它是一个比较传统的 grep 插件，不支持异步，要等到 grep 结束后才能显示结果，在大的项目中 grep 会卡好一阵子。它貌似也不再维护，我 N 久前提交的 pull request 还挂在那，它最近的代码更新在 11 个月前。
ag.vim
它其实是抄袭 ack.vim，没错，是抄袭。在早期 ack.vim 还不支持 ag 时，它的作者在 ack.vim 代码的基础上稍微改了改，支持了 ag。后来被 ack.vim 的作者给怼了，就放弃了对 ag.vim 的维护。目前功能上小于 ack.vim。
ctrlsf.vim
这是国人开发的一个插件，后端 grep 工具支持 ack/ag/pt/rg，同时也支持异步，不过需要 Vim 8.0.1039+ 或者 NeoVim 才支持异步。这个插件很好用，在我开发Leaderf rg之前一直使用的是它。

Leaderf rg顾名思义，后端基于 rg，由于是LeaderF的子功能，基因上就决定它完美支持异步。同时 LeaderF 又是一个非著名的模糊查找插件，这使它可以在 grep 结果的基础上再通过模糊匹配的方式进行二次过滤，来帮助用户更快地锁定目标，这是目前上面提到的插件所不具备的。

为什么选择 rg(ripgrep)

快速 grep 工具目前有 ag, rg, pt, sift, ucg 等。
我选择 rg 有以下几点原因：

速度比较快，rg 的 README 上有作者的对比，我实测也是 rg 快点。
Windows 上 bug 少（bug 到目前还没发现），ag 和 pt 都遇到过 bug。
作者很活跃，提的 issue 能很快得到回复。
rg 功能相对多些，可以从rg --help 看出来。

`Leaderf rg` 使用介绍

Leaderf rg的使用也比较简单，只要Leaderf[!] + rg命令和选项（同命令行上一样）就可以了。具体使用方法可以用:Leaderf rg -h来查看。

usage: Leaderf[!] rg [-h] [-e <PATTERN>...] [-F] [-i] [-L] [-P] [-S] [-s] [-v]
                     [-w] [-x] [--hidden] [--no-config] [--no-ignore]
                     [--no-ignore-global] [--no-ignore-parent]
                     [--no-ignore-vcs] [--no-pcre2-unicode] [-E <ENCODING>]
                     [-M <NUM>] [-m <NUM>] [--max-depth <NUM>]
                     [--max-filesize <NUM+SUFFIX?>]
                     [--path-separator <SEPARATOR>] [--sort <SORTBY>]
                     [--sortr <SORTBY>] [-f <PATTERNFILE>...] [-g <GLOB>...]
                     [--iglob <GLOB>...] [--ignore-file <PATH>...]
                     [--type-add <TYPE_SPEC>...] [-t <TYPE>...] [-T <TYPE>...]
                     [--current-buffer | --all-buffers] [--recall] [--append]
                     [--reverse] [--stayOpen] [--input <INPUT> | --cword]
                     [--top | --bottom | --left | --right | --belowright | --aboveleft | --fullScreen]
                     [--nameOnly | --fullPath | --fuzzy | --regexMode] [--nowrap]
                     [<PATH> [<PATH> ...]]

optional arguments:
  -h, --help            show this help message and exit

specific arguments:
  -e <PATTERN>..., --regexp <PATTERN>...
                        A pattern to search for. This option can be provided multiple times, where all
                        patterns given are searched.
  -F, --fixed-strings   Treat the pattern as a literal string instead of a regular expression.
  -i, --ignore-case     Searches case insensitively.
  -L, --follow          Follow symbolic links while traversing directories.
  -P, --pcre2           When this flag is present, rg will use the PCRE2 regex engine instead of its
                        default regex engine.
  -S, --smart-case      Searches case insensitively if the pattern is all lowercase, case sensitively
                        otherwise.
  -s, --case-sensitive  Searches case sensitively.
  -v, --invert-match    Invert matching. Show lines that do not match the given patterns.
  -w, --word-regexp     Only show matches surrounded by word boundaries. This is roughly equivalent to
                        putting \b before and after all of the search patterns.
  -x, --line-regexp     Only show matches surrounded by line boundaries.
  --hidden              Search hidden files and directories. By default, hidden files and directories
                        are skipped.
  --no-config           Never read configuration files. When this flag is present, rg will not respect
                        the RIPGREP_CONFIG_PATH environment variable.
  --no-ignore           Don't respect ignore files (.gitignore, .ignore, etc.). This implies
                        --no-ignore-parent and --no-ignore-vcs.
  --no-ignore-global    Don't respect ignore files that come from 'global' sources such as git's
                        `core.excludesFile` configuration option (which defaults to
                        `$HOME/.config/git/ignore`).
  --no-ignore-parent    Don't respect ignore files (.gitignore, .ignore, etc.) in parent directories.
  --no-ignore-vcs       Don't respect version control ignore files (.gitignore, etc.).
  --no-pcre2-unicode    When PCRE2 matching is enabled, this flag will disable
                        Unicode mode, which is otherwise enabled by default.
  -E <ENCODING>, --encoding <ENCODING>
                        Specify the text encoding that rg will use on all files searched.
  -M <NUM>, --max-columns <NUM>
                        Don't print lines longer than this limit in bytes.
  -m <NUM>, --max-count <NUM>
                        Limit the number of matching lines per file searched to NUM.
  --max-depth <NUM>     Limit the depth of directory traversal to NUM levels beyond the paths given.
  --max-filesize <NUM+SUFFIX?>
                        Ignore files larger than NUM in size. This does not apply to directories.
  --path-separator <SEPARATOR>
                        Set the path separator to use when printing file paths.
  --sort <SORTBY>       This flag enables sorting of results in ascending order.
  --sortr <SORTBY>      This flag enables sorting of results in descending order.
  -f <PATTERNFILE>..., --file <PATTERNFILE>...
                        Search for patterns from the given file, with one pattern per line.
                        (This option can be provided multiple times.)
  -g <GLOB>..., --glob <GLOB>...
                        Include or exclude files and directories for searching that match the given
                        glob.(This option can be provided multiple times.)
  --iglob <GLOB>...     Include or exclude files and directories for searching that match the given glob.
                        Globs are matched case insensitively.(This option can be provided multiple times.)
  --ignore-file <PATH>...
                        Specifies a path to one or more .gitignore format rules files.
  --type-add <TYPE_SPEC>...
                        Add a new glob for a particular file type.
  -t <TYPE>..., --type <TYPE>...
                        Only search files matching TYPE. Multiple type flags may be provided.
  -T <TYPE>..., --type-not <TYPE>...
                        Do not search files matching TYPE. Multiple type-not flags may be provided.
  <PATH>                A file or directory to search. Directories are searched recursively. Paths
                        specified on the command line override glob and ignore rules.
  --current-buffer      Searches in current buffer.
  --all-buffers         Searches in all listed buffers.
  --recall              Recall last search. If the result window is closed, reopen it.
  --append              Append to the previous search results.

common arguments:
  --reverse             show results in bottom-up order
  --stayOpen            don't quit LeaderF after accepting an entry
  --input <INPUT>       specifies INPUT as the pattern inputted in advance
  --cword               current word under cursor is inputted in advance
  --top                 the LeaderF window is at the top of the screen
  --bottom              the LeaderF window is at the bottom of the screen
  --left                the LeaderF window is at the left of the screen
  --right               the LeaderF window is at the right of the screen
  --belowright          the LeaderF window is at the belowright of the screen
  --aboveleft           the LeaderF window is at the aboveleft of the screen
  --fullScreen          the LeaderF window takes up the full screen
  --nameOnly            LeaderF is in NameOnly mode by default
  --fullPath            LeaderF is in FullPath mode by default
  --fuzzy               LeaderF is in Fuzzy mode by default
  --regexMode           LeaderF is in Regex mode by default
  --nowrap              long lines in the LeaderF window won't wrap

If [!] is given, enter normal mode directly.

Leaderf rg基本支持 rg 所有的必要选项，用户如果对 rg 命令比较熟悉，可以在 vim 命令行内输入:Leaderf, 然后手敲 rg 命令，命令选项还可以通过 tab 来补全。当然，更聪明的做法是定义一些快捷键。例如：

" search word under cursor, the pattern is treated as regex, and enter normal mode directly
noremap <C-F> :<C-U><C-R>=printf("Leaderf! rg -e %s ", expand("<cword>"))<CR>

" search word under cursor, the pattern is treated as regex,
" append the result to previous search results.
noremap <C-G> :<C-U><C-R>=printf("Leaderf! rg --append -e %s ", expand("<cword>"))<CR>

" search word under cursor literally only in current buffer
noremap <C-B> :<C-U><C-R>=printf("Leaderf! rg -F --current-buffer -e %s ", expand("<cword>"))<CR>

" search word under cursor literally in all listed buffers
noremap <C-D> :<C-U><C-R>=printf("Leaderf! rg -F --all-buffers -e %s ", expand("<cword>"))<CR>

" search visually selected text literally, don't quit LeaderF after accepting an entry
xnoremap gf :<C-U><C-R>=printf("Leaderf! rg -F --stayOpen -e %s ", leaderf#Rg#visual())<CR>

" recall last search. If the result window is closed, reopen it.
noremap go :<C-U>Leaderf! rg --recall<CR>


" search word under cursor in *.h and *.cpp files.
noremap <Leader>a :<C-U><C-R>=printf("Leaderf! rg -e %s -g *.h -g *.cpp", expand("<cword>"))<CR>
" the same as above
noremap <Leader>a :<C-U><C-R>=printf("Leaderf! rg -e %s -g *.{h,cpp}", expand("<cword>"))<CR>

" search word under cursor in cpp and java files.
noremap <Leader>b :<C-U><C-R>=printf("Leaderf! rg -e %s -t cpp -t java", expand("<cword>"))<CR>

" search word under cursor in cpp files, exclude the *.hpp files
noremap <Leader>c :<C-U><C-R>=printf("Leaderf! rg -e %s -t cpp -g !*.hpp", expand("<cword>"))<CR>

参考：rg 的glob 语法。

顺便说一下，直接在 vim 命令行敲:Leaderf rg，就会有传说中的"grep on the fly"的功能哦，同时支持 fuzzy 和 regex 两种模式。

会不会支持 ag 等其他 grep 工具

不会。
首先，ripgrep 已经足够强大，基本不存在别的工具有而 ripgrep 没有的功能。其次，ripgrep 有编译好的 Windows、Linux 和 MacOS 上的binary，可以在这些平台上很容易安装。再者，由于作者比较懒，不想再实现重复的功能。

vim 的模糊查找插件 LeaderF 新功能介绍

Yggdroot — Sun, 30 Dec 2018 17:26:36 +0800

前言

上一篇文章《让人相见恨晚的 vim 插件：模糊查找神器 LeaderF》概括性的介绍了LeaderF的基本功能，本篇对 LeaderF 的新功能做一下介绍。

统一的命令接口

随着 LeaderF 功能的不断增多，LeaderF 的命令也在不断的增加，给开发和使用都带来一些不便。于是，LeaderF 提供了一个统一的命令接口，就像 shell 命令一样，不同的命令选项组合，带来不同的功能。
可以通过:Leaderf -h来查看具体使用方法。

usage: Leaderf[!] [-h] [--reverse] [--stayOpen] [--input <INPUT> | --cword]
                  [--top | --bottom | --left | --right | --belowright | --aboveleft | --fullScreen]
                  [--nameOnly | --fullPath | --fuzzy | --regexMode] [--nowrap]
                  {file,tag,function,mru,searchHistory,cmdHistory,help,line,colorscheme,self,bufTag,buffer,rg}
                  ...

optional arguments:
  -h, --help            show this help message and exit
  --reverse             show results in bottom-up order
  --stayOpen            don't quit LeaderF after accepting an entry
  --input <INPUT>       specifies INPUT as the pattern inputted in advance
  --cword               current word under cursor is inputted in advance
  --top                 the LeaderF window is at the top of the screen
  --bottom              the LeaderF window is at the bottom of the screen
  --left                the LeaderF window is at the left of the screen
  --right               the LeaderF window is at the right of the screen
  --belowright          the LeaderF window is at the belowright of the screen
  --aboveleft           the LeaderF window is at the aboveleft of the screen
  --fullScreen          the LeaderF window takes up the full screen
  --nameOnly            LeaderF is in NameOnly mode by default
  --fullPath            LeaderF is in FullPath mode by default
  --fuzzy               LeaderF is in Fuzzy mode by default
  --regexMode           LeaderF is in Regex mode by default
  --nowrap              long lines in the LeaderF window won't wrap

subcommands:

  {file,tag,function,mru,searchHistory,cmdHistory,help,line,colorscheme,self,bufTag,buffer,rg}
    file                search files
    tag                 navigate tags using the tags file
    function            navigate functions or methods in the buffer
    mru                 search most recently used files
    searchHistory       execute the search command in the history
    cmdHistory          execute the command in the history
    help                navigate the help tags
    line                search a line in the buffer
    colorscheme         switch between colorschemes
    self                execute the commands of itself
    bufTag              navigate tags in the buffer
    buffer              search buffers
    rg                  grep using rg

If [!] is given, enter normal mode directly.

这样就可以用:Leaderf <subcommand> [options]来执行 LeaderF 的命令了。例如：

Before		Now
`:LeaderfFile`	<=>	`:Leaderf file`
`:LeaderfBuffer`	<=>	`:Leaderf buffer`
`:LeaderfMru`	<=>	`:Leaderf mru`
`:LeaderfMruCwd`	<=>	`:Leaderf mru --cwd`
...

每个子命令都有专有的命令选项，可以用:Leaderf <subcommand> -h来查看。例如，Leaderf mru -h:

usage: Leaderf[!] mru [-h] [--cwd] [--no-split-path] [--reverse] [--stayOpen]
                      [--input <INPUT> | --cword]
                      [--top | --bottom | --left | --right | --belowright | --aboveleft | --fullScreen]
                      [--nameOnly | --fullPath | --fuzzy | --regexMode]
                      [--nowrap]

optional arguments:
  -h, --help       show this help message and exit

specific arguments:
  --cwd            search MRU in current working directory
  --no-split-path  do not split the path

common arguments:
  --reverse        show results in bottom-up order
  --stayOpen       don't quit LeaderF after accepting an entry
  --input <INPUT>  specifies INPUT as the pattern inputted in advance
  --cword          current word under cursor is inputted in advance
  --top            the LeaderF window is at the top of the screen
  --bottom         the LeaderF window is at the bottom of the screen
  --left           the LeaderF window is at the left of the screen
  --right          the LeaderF window is at the right of the screen
  --belowright     the LeaderF window is at the belowright of the screen
  --aboveleft      the LeaderF window is at the aboveleft of the screen
  --fullScreen     the LeaderF window takes up the full screen
  --nameOnly       LeaderF is in NameOnly mode by default
  --fullPath       LeaderF is in FullPath mode by default
  --fuzzy          LeaderF is in Fuzzy mode by default
  --regexMode      LeaderF is in Regex mode by default
  --nowrap         long lines in the LeaderF window won't wrap

If [!] is given, enter normal mode directly.

自下而上显示结果

好多从 ctrlp.vim 转过来的朋友说不习惯 LeaderF 自上而下显示结果的方式，想要 LeaderF 也能像 ctrlp 一样自下而上（最优结果在最下面）显示结果，为了回馈各位朋友对 LeaderF 的支持，现在 LeaderF 也添加了自下而上显示搜索结果的功能：

只需要在命令后面加上--reverse即可，或者也可以一劳永逸，在 vimrc 里面加上 let g:Lf_ReverseOrder = 1 。

And 模式

LeaderF 支持用空格（可以用g:Lf_AndDelimiter来修改）作为 And 操作符来进行模糊匹配。当匹配已经匹配到字符串末尾时，可以通过敲空格和一个子串来匹配字符串的前面部分，进行快速过滤。
NOTE: 空格分隔的每个子串都是对整个字符串的模糊匹配，而不是精确匹配。

模糊匹配历史

可以通过上下键来翻看模糊匹配历史：

总结

LeaderF 精益求精，永无止境。

LeaderF 支持自下而上显示搜索结果了！

Yggdroot — Wed, 03 Oct 2018 12:22:38 +0800

只需要在命令后面加上--reverse即可，或者也可以一劳永逸，在 vimrc 里面加上 let g:Lf_ReverseOrder = 1 。

如何使用 Python 编写 vim 插件

Yggdroot — Tue, 28 Nov 2017 12:39:58 +0800

前言

vim 是个伟大的编辑器，不仅在于她特立独行的编辑方式，还在于她强大的扩展能力。然而，vim 自身用于写插件的语言 vimL 功能有很大的局限性，实现功能复杂的插件往往力不从心，而且运行效率也不高。幸好，vim 早就想到了这一点，她提供了很多外部语言接口，比如 Python，ruby，lua，Perl 等，可以很方便的编写 vim 插件。本文主要介绍如何使用 Python 编写 vim 插件。

准备工作

1. 编译 vim，使 vim 支持 Python

在编译之前，configure的时候加上--enable-pythoninterp和--enable-python3interp选项，使之分别支持 Python2 和 Python3 编译好之后，可以通过vim --version | grep +python来查看是否已经支持 Python，结果中应该包含+python和 +python3，当然也可以编译成只支持 Python2 或 Python3。

现在好多平台都有直接编译好的版本，已经包含 Python 支持，直接下载就可以了：

Windows：可以在这里下载。
Mac OS：可以直接brew install vim来安装。
Linux：也有快捷的安装方式，就不赘言了。

2. 如何让 Python 能正常工作

虽然 vim 已经支持 Python，但是可能:echo has("python")或:echo has("python3")的结果仍是0，说明 Python 还不能正常工作。
此时需要检查：

系统上是否装了 Python?
Python 是 32 位还是 64 位跟 vim 是否匹配？
Python 的版本跟编译时的版本是否一致（编译时的版本可以使用:version查看）
通过pythondll和pythonthreedll来分别指定 Python2 和 Python3 所使用的动态库。例如，可以在 vimrc 里添加 set pythondll=/Users/yggdroot/.python2.7.6/lib/libpython2.7.so

经此 4 步，99% 能让 Python 工作起来，剩下的 1% 就看人品了。

补充一点：对于 neovim，执行

pip2 install --user --upgrade neovim
pip3 install --user --upgrade neovim

就可以添加 Python2 和 Python3 的支持，具体参见:h provider-python。

从 hello world 开始

在命令行窗口执行:pyx print("hello world!")，输出“hello world！”，说明 Python 工作正常，此时我们已经可以使用 Python 来作为 vim 的EX命令了。

操作 vim 像 vimL 一样容易

怎么用 Python 来访问 vim 的信息以及操作 vim 呢？很简单，vim 的 Python 接口提供了一个叫 vim 的模块（module）。vim 模块是 Python 和 vim 沟通的桥梁，通过它，Python 可以访问 vim 的一切信息以及操作 vim，就像使用 vimL 一样。所以写脚本，首先要import vim。

vim 模块

vim 模块提供了两个非常有用的函数接口：

vim.command(str) 执行 vim 中的命令str(ex-mode)，返回值为 None，例如：

:py vim.command("%s/\s\+$//g")
:py vim.command("set shiftwidth=4")
:py vim.command("normal! dd")

vim.eval(str) 求 vim 表达式str的值，（什么是 vim 表达式，参见:h expr），返回结果类型为：
- string: 如果 vim 表达式的值的类型是string或number
- list：如果 vim 表达式的值的类型是一个 vim list（:h list）
- dictionary：如果 vim 表达式的值的类型是一个 vim dictionary（:h dict）
例如：
```
:py sw = vim.eval("&shiftwidth")
:py print vim.eval("expand('%:p')")
:py print vim.eval("@a")
```

vim 模块还提供了一些有用的对象：

Tabpage对象（:h python-tabpage）
一个Tabpage对象对应 vim 的一个 Tabpage。
Window对象（:h python-window）
一个Window对象对应 vim 的一个 Window。

Buffer对象（:h python-buffer）
一个Buffer对象对应 vim 的一个 buffer，Buffer 对象提供了一些属性和方法，可以很方便操作 buffer。
例如 (假定b是当前的 buffer) :

:py print b.name            # write the buffer file name
:py b[0] = "hello!!!"       # replace the top line
:py b[:] = None             # delete the whole buffer
:py del b[:]                # delete the whole buffer
:py b[0:0] = [ "a line" ]   # add a line at the top
:py del b[2]                # delete a line (the third)
:py b.append("bottom")      # add a line at the bottom
:py n = len(b)              # number of lines
:py (row,col) = b.mark('a') # named mark
:py r = b.range(1,5)        # a sub-range of the buffer
:py b.vars["foo"] = "bar"   # assign b:foo variable
:py b.options["ff"] = "dos" # set fileformat
:py del b.options["ar"]     # same as :set autoread<

vim.current对象（:h python-current）
vim.current对象提供了一些属性，可以方便的访问“当前”的 vim 对象

属性	含义	类型
vim.current.line	The current line (RW)	String
vim.current.buffer	The current buffer (RW)	Buffer
vim.current.window	The current window (RW)	Window
vim.current.tabpage	The current tab page (RW)	TabPage
vim.current.range	The current line range (RO)	Range

python 访问 vim 中的变量

访问 vim 中的变量，可以通过前面介绍的vim.eval(str)来访问，例如：

:py print vim.eval("v:version")

但是，还有更pythonic的方法：

预定义 vim 变量（v:var）
可以通过vim.vvars来访问预定义 vim 变量，vim.vvars是个类似Dictionary的对象。
例如，访问v:version：
```
:py print vim.vvars["version"]
```
全局变量（g:var）
可以通过vim.vars来访问全局变量，vim.vars也是个类似Dictionary的对象。
例如，改变全局变量g:global_var的值：
```
:py vim.vars["global_var"] = 123
```

tabpage 变量（t:var）
例如：

:py vim.current.tabpage.vars["var"] = "Tabpage"

window 变量（w:var）
例如：

:py vim.current.window.vars["var"] = "Window"

buffer 变量（b:var）
例如：

:py vim.current.buffer.vars["var"] = "Buffer"

python 访问 vim 中的选项（`options`）

访问 vim 中的选项，可以通过前面介绍的vim.command(str)和vim.eval(str)来访问，例如：

:py vim.command("set shiftwidth=4")
:py print vim.eval("&shiftwidth")

当然，还有更pythonic的方法：

全局选项设置（:h python-options）
例如：
```
:py vim.options["autochdir"] = True
```
注意：如果是window-local或者buffer-local选项，此种方法会报KeyError异常。对于window-local和buffer-local选项，请往下看。

window-local选项设置
例如：

:py vim.current.window.options["number"] = True

buffer-local选项设置
例如：

:py vim.current.buffer.options["shiftwidth"] = 4

两种方式写 vim 插件

内嵌式
```
py[thon] << {endmarker}
{script}
{endmarker}
```
{script}中的内容为 Python 代码，{endmarker}是一个标记符号，可以是任何字符串，不过{endmarker}前面不能有任何的空白字符，也就是要顶格写。例如，写一个函数，打印出当前 buffer 所有的行 (Demo.vim)：
```
function! Demo()
py << EOF
import vim
for line in vim.current.buffer:
print line
EOF
endfunction
call Demo()
```
运行:source %查看结果。
独立式
把 Python 代码写到*.py中，vimL 只用来定义全局变量、map、command 等，LeaderF就是采用这种方式。个人更喜欢这种方式，可以把全部精力集中在写 Python 代码上。

异步

多线程
可以通过 Python 的threading模块来实现多线程。但是，线程里面只能实现与 vim 无关的逻辑，任何试图在线程里面操作 vim 的行为都可能（也许用“肯定会”更合适）导致 vim 崩溃，甚至包括只读一个 vim 选项。虽然如此，也比 vimL 好多了，毕竟聊胜于无。
subprocess
可以通过 Python 的subprocess模块来调用外部命令。
例如：
```
:py import subprocess
:py print subprocess.Popen("ls -l", shell=True, stdout=subprocess.PIPE).stdout.read()
```
也就是说，从支持 Python 起，vim 就已经支持异步了（虽然直到 vim7.4 才基本没有 bug），Neovim 所增加的异步功能，对用 Python 写插件的小伙伴来说，没有任何吸引力。好多 Neovim 粉竟以引入异步（job）而引以为傲，它什么时候能引入真正的多线程支持我才会服它。

案例

著名的补全插件 YCM 和模糊查找神器LeaderF都是使用 Python 编写的。

缺陷

由于 GIL 的原因，Python 线程无法并行处理；而 vim 又不支持 Python 的进程（https://github.com/vim/vim/issues/906），计算密集型任务想利用多核来提高性能已不可能。

奇技淫巧

把 buffer 中所有单词首字母变为大写字母
```
:%pydo return line.title()
```

把 buffer 中所有的行镜像显示

例如，把

vim is very useful
123 456 789
abc def ghi
who am I

变为

lufesu yrev si miv
987 654 321
ihg fed cba
I ma ohw

可以执行此命令：:%pydo return line[::-1]

总结

以上只是简单的介绍，更详细的资料可以参考:h python。

让人相见恨晚的 vim 插件：模糊查找神器 LeaderF

Yggdroot — Thu, 07 Sep 2017 16:45:08 +0800

提到 vim 的模糊查找插件，很多人第一反应是 ctrlp.vim，ctrlp 知名度很高，但跟其它的同类插件相比，它的唯一优点是用 vimL 编写（这让它的性能是所有同类插件中最差的）。本文向大家推荐一款模糊查找插件——[LeaderF][1]，无论是从性能还是匹配精度上，都远远超越 ctrlp。

[LeaderF][1] 是什么？

LeaderF 是一个用 Python 写的 vim 插件，可以在成千上万数十万个文件中，通过模糊查找的方式，快速找到目标文件。它还有很多衍生功能：快速打开或定位某个 buffer、最近使用的文件（mru）、tags（包括函数、类、变量等）、命令历史、文件中的某一行、vim 的 help、marks 等等。

查找文件

文件查找是 vimer 的常用操作，海量文件中快速定位目标文件是很多 vimer 迫切需要的功能，所以就有了 ctrlp 这样的插件。但 ctrlp 性能不佳，而且有时候把目标文件名都输入进搜索栏还是找不到目标文件，最大的问题是它的模糊匹配算法不佳，经常排在前面的跟所要找的相去甚远。LeaderF 采用异步检索和精心设计的模糊匹配算法完美地解决了这些问题，当你在根目录 (/) 按下搜索命令，再也没有想剁手的冲动了; 查找文件时，用更少的键击次数就可以找到目标文件，延长你的键盘使用寿命 :)

异步检索

模糊查找

正则表达式查找

多字节字符查找（中文查找）

快速定位 tags（包括函数、类、变量等）

有了它，tagbar 可以淘汰掉了：

查找历史命令

切换 Colorscheme

当然还有其他功能就不一一展示了，感兴趣的小伙伴可以查看 [这里][2]。

你不知道的细节

智能大小写（smartcase）

如果输入的搜索字符都是小写字母，则匹配是大小写不敏感的；如果输入大写字母，则只匹配大写字母，小写字母仍然是大小写不敏感的。例如，输入abcDef，可以匹配如下字符串：

abcDef
AbcDef
abcDEf
aBcDeF

但不能匹配：

abcdef
Abcdef

注意：abc和ef仍然是大小写不敏感的这样可以通过大写字母，在搜索过程中快速缩小搜索范围。

同时打开多个文件

细化搜索结果

开箱即用

上面所有的功能都不需要额外的配置，只要装好 LeaderF 插件就可以使用了，不像有的插件，配置就像一门新的脚本语言。

最后

LeaderF 还支持写扩展程序，[这里][3] 是一个样例。

友情链接：[LeaderF，也許是 Vim 最好的模糊查詢插件][4]

[1]: https://github.com/Yggdroot/LeaderF [2]: https://github.com/Yggdroot/LeaderF/blob/master/README.md [3]: https://github.com/Yggdroot/LeaderF-marks [4]: https://0x3f.org/post/leaderf-currently-the-best-fuzzy-finder-of-vim/