From 54dfb194d9db781555d550533d4bd022b720ddfb Mon Sep 17 00:00:00 2001 From: Git E2E Dev Test Username Date: Tue, 18 Oct 2022 10:37:18 -0400 Subject: [PATCH] git subrepo clone https://github.com/junegunn/fzf.vim.git ./dotfiles/.vim/plugged/fzf.vim subrepo: subdir: "dotfiles/.vim/plugged/fzf.vim" merged: "9ceac7180" upstream: origin: "https://github.com/junegunn/fzf.vim.git" branch: "master" commit: "9ceac7180" git-subrepo: version: "0.4.3" origin: "???" commit: "???" --- dotfiles/.vim/plugged/fzf.vim/.gitattributes | 1 + .../.vim/plugged/fzf.vim/.github/FUNDING.yml | 1 + .../plugged/fzf.vim/.github/ISSUE_TEMPLATE.md | 25 + dotfiles/.vim/plugged/fzf.vim/.gitignore | 1 + dotfiles/.vim/plugged/fzf.vim/.gitrepo | 12 + dotfiles/.vim/plugged/fzf.vim/LICENSE | 21 + dotfiles/.vim/plugged/fzf.vim/README.md | 431 +++++ .../.vim/plugged/fzf.vim/autoload/fzf/vim.vim | 1455 +++++++++++++++++ .../fzf.vim/autoload/fzf/vim/complete.vim | 164 ++ dotfiles/.vim/plugged/fzf.vim/bin/preview.rb | 3 + dotfiles/.vim/plugged/fzf.vim/bin/preview.sh | 83 + .../.vim/plugged/fzf.vim/bin/tagpreview.sh | 73 + dotfiles/.vim/plugged/fzf.vim/bin/tags.pl | 15 + dotfiles/.vim/plugged/fzf.vim/doc/fzf-vim.txt | 497 ++++++ dotfiles/.vim/plugged/fzf.vim/plugin/fzf.vim | 154 ++ 15 files changed, 2936 insertions(+) create mode 100644 dotfiles/.vim/plugged/fzf.vim/.gitattributes create mode 100644 dotfiles/.vim/plugged/fzf.vim/.github/FUNDING.yml create mode 100644 dotfiles/.vim/plugged/fzf.vim/.github/ISSUE_TEMPLATE.md create mode 100644 dotfiles/.vim/plugged/fzf.vim/.gitignore create mode 100644 dotfiles/.vim/plugged/fzf.vim/.gitrepo create mode 100644 dotfiles/.vim/plugged/fzf.vim/LICENSE create mode 100644 dotfiles/.vim/plugged/fzf.vim/README.md create mode 100644 dotfiles/.vim/plugged/fzf.vim/autoload/fzf/vim.vim create mode 100644 dotfiles/.vim/plugged/fzf.vim/autoload/fzf/vim/complete.vim create mode 100755 dotfiles/.vim/plugged/fzf.vim/bin/preview.rb create mode 100755 dotfiles/.vim/plugged/fzf.vim/bin/preview.sh create mode 100755 dotfiles/.vim/plugged/fzf.vim/bin/tagpreview.sh create mode 100755 dotfiles/.vim/plugged/fzf.vim/bin/tags.pl create mode 100644 dotfiles/.vim/plugged/fzf.vim/doc/fzf-vim.txt create mode 100644 dotfiles/.vim/plugged/fzf.vim/plugin/fzf.vim diff --git a/dotfiles/.vim/plugged/fzf.vim/.gitattributes b/dotfiles/.vim/plugged/fzf.vim/.gitattributes new file mode 100644 index 00000000..dfdb8b77 --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/.gitattributes @@ -0,0 +1 @@ +*.sh text eol=lf diff --git a/dotfiles/.vim/plugged/fzf.vim/.github/FUNDING.yml b/dotfiles/.vim/plugged/fzf.vim/.github/FUNDING.yml new file mode 100644 index 00000000..f2848951 --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/.github/FUNDING.yml @@ -0,0 +1 @@ +github: junegunn diff --git a/dotfiles/.vim/plugged/fzf.vim/.github/ISSUE_TEMPLATE.md b/dotfiles/.vim/plugged/fzf.vim/.github/ISSUE_TEMPLATE.md new file mode 100644 index 00000000..5445de0f --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,25 @@ + + + + +- [ ] I have fzf 0.30.0 or above +- [ ] I have read through https://github.com/junegunn/fzf.vim/blob/master/README.md +- [ ] I have read through https://github.com/junegunn/fzf/blob/master/README-VIM.md +- [ ] I have read through the manual page of fzf (`man fzf`) +- [ ] I have searched through the existing issues + + + diff --git a/dotfiles/.vim/plugged/fzf.vim/.gitignore b/dotfiles/.vim/plugged/fzf.vim/.gitignore new file mode 100644 index 00000000..926ccaaf --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/.gitignore @@ -0,0 +1 @@ +doc/tags diff --git a/dotfiles/.vim/plugged/fzf.vim/.gitrepo b/dotfiles/.vim/plugged/fzf.vim/.gitrepo new file mode 100644 index 00000000..dec02cd4 --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/.gitrepo @@ -0,0 +1,12 @@ +; DO NOT EDIT (unless you know what you are doing) +; +; This subdirectory is a git "subrepo", and this file is maintained by the +; git-subrepo command. See https://github.com/git-commands/git-subrepo#readme +; +[subrepo] + remote = https://github.com/junegunn/fzf.vim.git + branch = master + commit = 9ceac718026fd39498d95ff04fa04d3e40c465d7 + parent = 8c6fca48ea111be175ed5c1eb0ef01bcef60a300 + method = merge + cmdver = 0.4.3 diff --git a/dotfiles/.vim/plugged/fzf.vim/LICENSE b/dotfiles/.vim/plugged/fzf.vim/LICENSE new file mode 100644 index 00000000..8087dea8 --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Junegunn Choi + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/dotfiles/.vim/plugged/fzf.vim/README.md b/dotfiles/.vim/plugged/fzf.vim/README.md new file mode 100644 index 00000000..dbeb9000 --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/README.md @@ -0,0 +1,431 @@ +fzf :heart: vim +=============== + +Things you can do with [fzf][fzf] and Vim. + +Rationale +--------- + +[fzf][fzf] itself is not a Vim plugin, and the official repository only +provides the [basic wrapper function][run] for Vim. It's up to the users to +write their own Vim commands with it. However, I've learned that many users of +fzf are not familiar with Vimscript and are looking for the "default" +implementation of the features they can find in the alternative Vim plugins. + +This repository is a bundle of fzf-based commands and mappings extracted from +my [.vimrc][vimrc] to address such needs. They are *not* designed to be +flexible or configurable, and there's no guarantee of backward-compatibility. + +Why you should use fzf on Vim +----------------------------- + +Because you can and you love fzf. + +fzf runs asynchronously and can be orders of magnitude faster than similar Vim +plugins. However, the benefit may not be noticeable if the size of the input +is small, which is the case for many of the commands provided here. +Nevertheless I wrote them anyway since it's really easy to implement custom +selector with fzf. + +Installation +------------ + +fzf.vim depends on the basic Vim plugin of [the main fzf +repository][fzf-main], which means you need to **set up both "fzf" and +"fzf.vim" on Vim**. To learn more about fzf/Vim integration, see +[README-VIM][README-VIM]. + +[fzf-main]: https://github.com/junegunn/fzf +[README-VIM]: https://github.com/junegunn/fzf/blob/master/README-VIM.md + +### Using [vim-plug](https://github.com/junegunn/vim-plug) + +```vim +Plug 'junegunn/fzf', { 'do': { -> fzf#install() } } +Plug 'junegunn/fzf.vim' +``` + +`fzf#install()` makes sure that you have the latest binary, but it's optional, +so you can omit it if you use a plugin manager that doesn't support hooks. + +### Dependencies + +- [fzf][fzf-main] 0.23.0 or above +- For syntax-highlighted preview, install [bat](https://github.com/sharkdp/bat) +- If [delta](https://github.com/dandavison/delta) is available, `GF?`, + `Commits` and `BCommits` will use it to format `git diff` output. +- `Ag` requires [The Silver Searcher (ag)][ag] +- `Rg` requires [ripgrep (rg)][rg] +- `Tags` and `Helptags` require Perl + +Commands +-------- + +| Command | List | +| --- | --- | +| `:Files [PATH]` | Files (runs `$FZF_DEFAULT_COMMAND` if defined) | +| `:GFiles [OPTS]` | Git files (`git ls-files`) | +| `:GFiles?` | Git files (`git status`) | +| `:Buffers` | Open buffers | +| `:Colors` | Color schemes | +| `:Ag [PATTERN]` | [ag][ag] search result (`ALT-A` to select all, `ALT-D` to deselect all) | +| `:Rg [PATTERN]` | [rg][rg] search result (`ALT-A` to select all, `ALT-D` to deselect all) | +| `:Lines [QUERY]` | Lines in loaded buffers | +| `:BLines [QUERY]` | Lines in the current buffer | +| `:Tags [QUERY]` | Tags in the project (`ctags -R`) | +| `:BTags [QUERY]` | Tags in the current buffer | +| `:Marks` | Marks | +| `:Windows` | Windows | +| `:Locate PATTERN` | `locate` command output | +| `:History` | `v:oldfiles` and open buffers | +| `:History:` | Command history | +| `:History/` | Search history | +| `:Snippets` | Snippets ([UltiSnips][us]) | +| `:Commits` | Git commits (requires [fugitive.vim][f]) | +| `:BCommits` | Git commits for the current buffer; visual-select lines to track changes in the range | +| `:Commands` | Commands | +| `:Maps` | Normal mode mappings | +| `:Helptags` | Help tags [1](#helptags) | +| `:Filetypes` | File types + +- Most commands support `CTRL-T` / `CTRL-X` / `CTRL-V` key + bindings to open in a new tab, a new split, or in a new vertical split +- Bang-versions of the commands (e.g. `Ag!`) will open fzf in fullscreen +- You can set `g:fzf_command_prefix` to give the same prefix to the commands + - e.g. `let g:fzf_command_prefix = 'Fzf'` and you have `FzfFiles`, etc. + +(1: `Helptags` will shadow the command of the same name +from [pathogen][pat]. But its functionality is still available via `call +pathogen#helptags()`. [↩](#a1)) + +[pat]: https://github.com/tpope/vim-pathogen +[f]: https://github.com/tpope/vim-fugitive + +Customization +------------- + +### Global options + +Every command in fzf.vim internally calls `fzf#wrap` function of the main +repository which supports a set of global option variables. So please read +through [README-VIM][README-VIM] to learn more about them. + +#### Preview window + +Some commands will show the preview window on the right. You can customize the +behavior with `g:fzf_preview_window`. Here are some examples: + +```vim +" This is the default option: +" - Preview window on the right with 50% width +" - CTRL-/ will toggle preview window. +" - Note that this array is passed as arguments to fzf#vim#with_preview function. +" - To learn more about preview window options, see `--preview-window` section of `man fzf`. +let g:fzf_preview_window = ['right,50%', 'ctrl-/'] + +" Preview window is hidden by default. You can toggle it with ctrl-/. +" It will show on the right with 50% width, but if the width is smaller +" than 70 columns, it will show above the candidate list +let g:fzf_preview_window = ['hidden,right,50%,<70(up,40%)', 'ctrl-/'] + +" Empty value to disable preview window altogether +let g:fzf_preview_window = [] +``` + +### Command-local options + +A few commands in fzf.vim can be customized with global option variables shown +below. + +```vim +" [Buffers] Jump to the existing window if possible +let g:fzf_buffers_jump = 1 + +" [[B]Commits] Customize the options used by 'git log': +let g:fzf_commits_log_options = '--graph --color=always --format="%C(auto)%h%d %s %C(black)%C(bold)%cr"' + +" [Tags] Command to generate tags file +let g:fzf_tags_command = 'ctags -R' + +" [Commands] --expect expression for directly executing the command +let g:fzf_commands_expect = 'alt-enter,ctrl-x' +``` + +### Advanced customization + +#### Vim functions + +Each command in fzf.vim is backed by a Vim function. You can override +a command or define a variation of it by calling its corresponding function. + +| Command | Vim function | +| --- | --- | +| `Files` | `fzf#vim#files(dir, [spec dict], [fullscreen bool])` | +| `GFiles` | `fzf#vim#gitfiles(git_options, [spec dict], [fullscreen bool])` | +| `GFiles?` | `fzf#vim#gitfiles('?', [spec dict], [fullscreen bool])` | +| `Buffers` | `fzf#vim#buffers([spec dict], [fullscreen bool])` | +| `Colors` | `fzf#vim#colors([spec dict], [fullscreen bool])` | +| `Rg` | `fzf#vim#grep(command, [has_column bool], [spec dict], [fullscreen bool])` | +| ... | ... | + +(We can see that the last two optional arguments of each function are +identical. They are directly passed to `fzf#wrap` function. If you haven't +read [README-VIM][README-VIM] already, please read it before proceeding.) + +#### Example: Customizing `Files` command + +This is the default definition of `Files` command: + +```vim +command! -bang -nargs=? -complete=dir Files call fzf#vim#files(, 0) +``` + +Let's say you want to a variation of it called `ProjectFiles` that only +searches inside `~/projects` directory. Then you can do it like this: + +```vim +command! -bang ProjectFiles call fzf#vim#files('~/projects', 0) +``` + +Or, if you want to override the command with different fzf options, just pass +a custom spec to the function. + +```vim +command! -bang -nargs=? -complete=dir Files + \ call fzf#vim#files(, {'options': ['--layout=reverse', '--info=inline']}, 0) +``` + +Want a preview window? + +```vim +command! -bang -nargs=? -complete=dir Files + \ call fzf#vim#files(, {'options': ['--layout=reverse', '--info=inline', '--preview', 'cat {}']}, 0) +``` + +It kind of works, but you probably want a nicer previewer program than `cat`. +fzf.vim ships [a versatile preview script](bin/preview.sh) you can readily +use. It internally executes [bat](https://github.com/sharkdp/bat) for syntax +highlighting, so make sure to install it. + +```vim +command! -bang -nargs=? -complete=dir Files + \ call fzf#vim#files(, {'options': ['--layout=reverse', '--info=inline', '--preview', '~/.vim/plugged/fzf.vim/bin/preview.sh {}']}, 0) +``` + +However, it's not ideal to hard-code the path to the script which can be +different in different circumstances. So in order to make it easier to set up +the previewer, fzf.vim provides `fzf#vim#with_preview` helper function. +Similarly to `fzf#wrap`, it takes a spec dictionary and returns a copy of it +with additional preview options. + +```vim +command! -bang -nargs=? -complete=dir Files + \ call fzf#vim#files(, fzf#vim#with_preview({'options': ['--layout=reverse', '--info=inline']}), 0) +``` + +You can just omit the spec argument if you only want the previewer. + +```vim +command! -bang -nargs=? -complete=dir Files + \ call fzf#vim#files(, fzf#vim#with_preview(), 0) +``` + +#### Example: `git grep` wrapper + +The following example implements `GGrep` command that works similarly to +predefined `Ag` or `Rg` using `fzf#vim#grep`. + +- The second argument to `fzf#vim#grep` is 0 (false), because `git grep` does + not print column numbers. +- We set the base directory to git root by setting `dir` attribute in spec + dictionary. +- [The preview script](bin/preview.sh) supports `grep` format + (`FILE_PATH:LINE_NO:...`), so we can just wrap the spec with + `fzf#vim#with_preview` as before to enable previewer. + +```vim +command! -bang -nargs=* GGrep + \ call fzf#vim#grep( + \ 'git grep --line-number -- '.shellescape(), 0, + \ fzf#vim#with_preview({'dir': systemlist('git rev-parse --show-toplevel')[0]}), 0) +``` + +#### Example: `Rg` command with preview window + +You can see the definition of `Rg` command with `:command Rg`. With the +information, you can redefine it with the preview window enabled. In this +case, we're only interested in setting up the preview window, so we will omit +the spec argument to `fzf#vim#preview`. + +```vim +command! -bang -nargs=* Rg + \ call fzf#vim#grep( + \ 'rg --column --line-number --no-heading --color=always --smart-case -- '.shellescape(), 1, + \ fzf#vim#with_preview(), 0) +``` + +#### Example: Advanced ripgrep integration + +In the default implementation of `Rg`, ripgrep process starts only once with +the initial query (e.g. `:Rg foo`) and fzf filters the output of the process. + +This is okay in most cases because fzf is quite performant even with millions +of lines, but we can make fzf completely delegate its search responsibliity to +ripgrep process by making it restart ripgrep whenever the query string is +updated. In this scenario, fzf becomes a simple selector interface rather than +a "fuzzy finder". + +- We will name the new command all-uppercase `RG` so we can still access the + default version. +- `--bind 'change:reload:rg ... {q}'` will make fzf restart ripgrep process + whenever the query string, denoted by `{q}`, is changed. +- With `--phony` option, fzf will no longer perform search. The query string + you type on fzf prompt is only used for restarting ripgrep process. +- Also note that we enabled previewer with `fzf#vim#with_preview`. + +```vim +function! RipgrepFzf(query, fullscreen) + let command_fmt = 'rg --column --line-number --no-heading --color=always --smart-case -- %s || true' + let initial_command = printf(command_fmt, shellescape(a:query)) + let reload_command = printf(command_fmt, '{q}') + let spec = {'options': ['--phony', '--query', a:query, '--bind', 'change:reload:'.reload_command]} + call fzf#vim#grep(initial_command, 1, fzf#vim#with_preview(spec), a:fullscreen) +endfunction + +command! -nargs=* -bang RG call RipgrepFzf(, 0) +``` + +Mappings +-------- + +| Mapping | Description | +| --- | --- | +| `(fzf-maps-n)` | Normal mode mappings | +| `(fzf-maps-i)` | Insert mode mappings | +| `(fzf-maps-x)` | Visual mode mappings | +| `(fzf-maps-o)` | Operator-pending mappings | +| `(fzf-complete-word)` | `cat /usr/share/dict/words` | +| `(fzf-complete-path)` | Path completion using `find` (file + dir) | +| `(fzf-complete-file)` | File completion using `find` | +| `(fzf-complete-line)` | Line completion (all open buffers) | +| `(fzf-complete-buffer-line)` | Line completion (current buffer only) | + +```vim +" Mapping selecting mappings +nmap (fzf-maps-n) +xmap (fzf-maps-x) +omap (fzf-maps-o) + +" Insert mode completion +imap (fzf-complete-word) +imap (fzf-complete-path) +imap (fzf-complete-line) +``` + +Completion functions +-------------------- + +| Function | Description | +| --- | --- | +| `fzf#vim#complete#path(command, [spec])` | Path completion | +| `fzf#vim#complete#word([spec])` | Word completion | +| `fzf#vim#complete#line([spec])` | Line completion (all open buffers) | +| `fzf#vim#complete#buffer_line([spec])` | Line completion (current buffer only) | + +```vim +" Path completion with custom source command +inoremap fzf#vim#complete#path('fd') +inoremap fzf#vim#complete#path('rg --files') + +" Word completion with custom spec with popup layout option +inoremap fzf#vim#complete#word({'window': { 'width': 0.2, 'height': 0.9, 'xoffset': 1 }}) +``` + +Custom completion +----------------- + +`fzf#vim#complete` is a helper function for creating custom fuzzy completion +using fzf. If the first parameter is a command string or a Vim list, it will +be used as the source. + +```vim +" Replace the default dictionary completion with fzf-based fuzzy completion +inoremap fzf#vim#complete('cat /usr/share/dict/words') +``` + +For advanced uses, you can pass an options dictionary to the function. The set +of options is pretty much identical to that for `fzf#run` only with the +following exceptions: + +- `reducer` (funcref) + - Reducer transforms the output lines of fzf into a single string value +- `prefix` (string or funcref; default: `\k*$`) + - Regular expression pattern to extract the completion prefix + - Or a function to extract completion prefix +- Both `source` and `options` can be given as funcrefs that take the + completion prefix as the argument and return the final value +- `sink` or `sink*` are ignored + +```vim +" Global line completion (not just open buffers. ripgrep required.) +inoremap fzf#vim#complete(fzf#wrap({ + \ 'prefix': '^.*$', + \ 'source': 'rg -n ^ --color always', + \ 'options': '--ansi --delimiter : --nth 3..', + \ 'reducer': { lines -> join(split(lines[0], ':\zs')[2:], '') }})) +``` + +### Reducer example + +```vim +function! s:make_sentence(lines) + return substitute(join(a:lines), '^.', '\=toupper(submatch(0))', '').'.' +endfunction + +inoremap fzf#vim#complete({ + \ 'source': 'cat /usr/share/dict/words', + \ 'reducer': function('make_sentence'), + \ 'options': '--multi --reverse --margin 15%,0', + \ 'left': 20}) +``` + +Status line of terminal buffer +------------------------------ + +When fzf starts in a terminal buffer (see [fzf/README-VIM.md][termbuf]), you +may want to customize the statusline of the containing buffer. + +[termbuf]: https://github.com/junegunn/fzf/blob/master/README-VIM.md#fzf-inside-terminal-buffer + +### Hide statusline + +```vim +autocmd! FileType fzf set laststatus=0 noshowmode noruler + \| autocmd BufLeave set laststatus=2 showmode ruler +``` + +### Custom statusline + +```vim +function! s:fzf_statusline() + " Override statusline as you like + highlight fzf1 ctermfg=161 ctermbg=251 + highlight fzf2 ctermfg=23 ctermbg=251 + highlight fzf3 ctermfg=237 ctermbg=251 + setlocal statusline=%#fzf1#\ >\ %#fzf2#fz%#fzf3#f +endfunction + +autocmd! User FzfStatusLine call fzf_statusline() +``` + +License +------- + +MIT + +[fzf]: https://github.com/junegunn/fzf +[run]: https://github.com/junegunn/fzf/blob/master/README-VIM.md#fzfrun +[vimrc]: https://github.com/junegunn/dotfiles/blob/master/vimrc +[ag]: https://github.com/ggreer/the_silver_searcher +[rg]: https://github.com/BurntSushi/ripgrep +[us]: https://github.com/SirVer/ultisnips diff --git a/dotfiles/.vim/plugged/fzf.vim/autoload/fzf/vim.vim b/dotfiles/.vim/plugged/fzf.vim/autoload/fzf/vim.vim new file mode 100644 index 00000000..44a17f6d --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/autoload/fzf/vim.vim @@ -0,0 +1,1455 @@ +" Copyright (c) 2017 Junegunn Choi +" +" MIT License +" +" Permission is hereby granted, free of charge, to any person obtaining +" a copy of this software and associated documentation files (the +" "Software"), to deal in the Software without restriction, including +" without limitation the rights to use, copy, modify, merge, publish, +" distribute, sublicense, and/or sell copies of the Software, and to +" permit persons to whom the Software is furnished to do so, subject to +" the following conditions: +" +" The above copyright notice and this permission notice shall be +" included in all copies or substantial portions of the Software. +" +" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +" EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +" NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +" LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +" OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +" WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +let s:cpo_save = &cpo +set cpo&vim + +" ------------------------------------------------------------------ +" Common +" ------------------------------------------------------------------ + +let s:min_version = '0.23.0' +let s:is_win = has('win32') || has('win64') +let s:is_wsl_bash = s:is_win && (exepath('bash') =~? 'Windows[/\\]system32[/\\]bash.exe$') +let s:layout_keys = ['window', 'up', 'down', 'left', 'right'] +let s:bin_dir = expand(':p:h:h:h').'/bin/' +let s:bin = { +\ 'preview': s:bin_dir.'preview.sh', +\ 'tags': s:bin_dir.'tags.pl' } +let s:TYPE = {'dict': type({}), 'funcref': type(function('call')), 'string': type(''), 'list': type([])} +if s:is_win + if has('nvim') + let s:bin.preview = split(system('for %A in ("'.s:bin.preview.'") do @echo %~sA'), "\n")[0] + else + let preview_path = s:is_wsl_bash + \ ? substitute(s:bin.preview, '^\([A-Z]\):', '/mnt/\L\1', '') + \ : fnamemodify(s:bin.preview, ':8') + let s:bin.preview = substitute(preview_path, '\', '/', 'g') + endif +endif + +let s:wide = 120 +let s:warned = 0 +let s:checked = 0 + +function! s:check_requirements() + if s:checked + return + endif + + if !exists('*fzf#run') + throw "fzf#run function not found. You also need Vim plugin from the main fzf repository (i.e. junegunn/fzf *and* junegunn/fzf.vim)" + endif + if !exists('*fzf#exec') + throw "fzf#exec function not found. You need to upgrade Vim plugin from the main fzf repository ('junegunn/fzf')" + endif + let s:checked = !empty(fzf#exec(s:min_version)) +endfunction + +function! s:extend_opts(dict, eopts, prepend) + if empty(a:eopts) + return + endif + if has_key(a:dict, 'options') + if type(a:dict.options) == s:TYPE.list && type(a:eopts) == s:TYPE.list + if a:prepend + let a:dict.options = extend(copy(a:eopts), a:dict.options) + else + call extend(a:dict.options, a:eopts) + endif + else + let all_opts = a:prepend ? [a:eopts, a:dict.options] : [a:dict.options, a:eopts] + let a:dict.options = join(map(all_opts, 'type(v:val) == s:TYPE.list ? join(map(copy(v:val), "fzf#shellescape(v:val)")) : v:val')) + endif + else + let a:dict.options = a:eopts + endif +endfunction + +function! s:merge_opts(dict, eopts) + return s:extend_opts(a:dict, a:eopts, 0) +endfunction + +function! s:prepend_opts(dict, eopts) + return s:extend_opts(a:dict, a:eopts, 1) +endfunction + +" [[spec to wrap], [preview window expression], [toggle-preview keys...]] +function! fzf#vim#with_preview(...) + " Default spec + let spec = {} + let window = '' + + let args = copy(a:000) + + " Spec to wrap + if len(args) && type(args[0]) == s:TYPE.dict + let spec = copy(args[0]) + call remove(args, 0) + endif + + if !executable('bash') + if !s:warned + call s:warn('Preview window not supported (bash not found in PATH)') + let s:warned = 1 + endif + return spec + endif + + " Placeholder expression (TODO/TBD: undocumented) + let placeholder = get(spec, 'placeholder', '{}') + + " g:fzf_preview_window + if empty(args) + let preview_args = get(g:, 'fzf_preview_window', ['', 'ctrl-/']) + if empty(preview_args) + let args = ['hidden'] + else + " For backward-compatiblity + let args = type(preview_args) == type('') ? [preview_args] : copy(preview_args) + endif + endif + + if len(args) && type(args[0]) == s:TYPE.string + if len(args[0]) && args[0] !~# '^\(up\|down\|left\|right\|hidden\)' + throw 'invalid preview window: '.args[0] + endif + let window = args[0] + call remove(args, 0) + endif + + let preview = [] + if len(window) + let preview += ['--preview-window', window] + endif + if s:is_win + if empty($MSWINHOME) + let $MSWINHOME = $HOME + endif + if s:is_wsl_bash && $WSLENV !~# '[:]\?MSWINHOME\(\/[^:]*\)\?\(:\|$\)' + let $WSLENV = 'MSWINHOME/u:'.$WSLENV + endif + let preview_cmd = 'bash '.(s:is_wsl_bash + \ ? s:bin.preview + \ : escape(s:bin.preview, '\')) + else + let preview_cmd = fzf#shellescape(s:bin.preview) + endif + if len(placeholder) + let preview += ['--preview', preview_cmd.' '.placeholder] + end + if &ambiwidth ==# 'double' + let preview += ['--no-unicode'] + end + + if len(args) + call extend(preview, ['--bind', join(map(args, 'v:val.":toggle-preview"'), ',')]) + endif + call s:merge_opts(spec, preview) + return spec +endfunction + +function! s:remove_layout(opts) + for key in s:layout_keys + if has_key(a:opts, key) + call remove(a:opts, key) + endif + endfor + return a:opts +endfunction + +function! s:reverse_list(opts) + let tokens = map(split($FZF_DEFAULT_OPTS, '[^a-z-]'), 'substitute(v:val, "^--", "", "")') + if index(tokens, 'reverse') < 0 + return extend(['--layout=reverse-list'], a:opts) + endif + return a:opts +endfunction + +function! s:wrap(name, opts, bang) + " fzf#wrap does not append --expect if sink or sink* is found + let opts = copy(a:opts) + let options = '' + if has_key(opts, 'options') + let options = type(opts.options) == s:TYPE.list ? join(opts.options) : opts.options + endif + if options !~ '--expect' && has_key(opts, 'sink*') + let Sink = remove(opts, 'sink*') + let wrapped = fzf#wrap(a:name, opts, a:bang) + let wrapped['sink*'] = Sink + else + let wrapped = fzf#wrap(a:name, opts, a:bang) + endif + return wrapped +endfunction + +function! s:strip(str) + return substitute(a:str, '^\s*\|\s*$', '', 'g') +endfunction + +function! s:chomp(str) + return substitute(a:str, '\n*$', '', 'g') +endfunction + +function! s:escape(path) + let path = fnameescape(a:path) + return s:is_win ? escape(path, '$') : path +endfunction + +if v:version >= 704 + function! s:function(name) + return function(a:name) + endfunction +else + function! s:function(name) + " By Ingo Karkat + return function(substitute(a:name, '^s:', matchstr(expand(''), '\d\+_\zefunction$'), '')) + endfunction +endif + +function! s:get_color(attr, ...) + let gui = has('termguicolors') && &termguicolors + let fam = gui ? 'gui' : 'cterm' + let pat = gui ? '^#[a-f0-9]\+' : '^[0-9]\+$' + for group in a:000 + let code = synIDattr(synIDtrans(hlID(group)), a:attr, fam) + if code =~? pat + return code + endif + endfor + return '' +endfunction + +let s:ansi = {'black': 30, 'red': 31, 'green': 32, 'yellow': 33, 'blue': 34, 'magenta': 35, 'cyan': 36} + +function! s:csi(color, fg) + let prefix = a:fg ? '38;' : '48;' + if a:color[0] == '#' + return prefix.'2;'.join(map([a:color[1:2], a:color[3:4], a:color[5:6]], 'str2nr(v:val, 16)'), ';') + endif + return prefix.'5;'.a:color +endfunction + +function! s:ansi(str, group, default, ...) + let fg = s:get_color('fg', a:group) + let bg = s:get_color('bg', a:group) + let color = (empty(fg) ? s:ansi[a:default] : s:csi(fg, 1)) . + \ (empty(bg) ? '' : ';'.s:csi(bg, 0)) + return printf("\x1b[%s%sm%s\x1b[m", color, a:0 ? ';1' : '', a:str) +endfunction + +for s:color_name in keys(s:ansi) + execute "function! s:".s:color_name."(str, ...)\n" + \ " return s:ansi(a:str, get(a:, 1, ''), '".s:color_name."')\n" + \ "endfunction" +endfor + +function! s:buflisted() + return filter(range(1, bufnr('$')), 'buflisted(v:val) && getbufvar(v:val, "&filetype") != "qf"') +endfunction + +function! s:fzf(name, opts, extra) + call s:check_requirements() + + let [extra, bang] = [{}, 0] + if len(a:extra) <= 1 + let first = get(a:extra, 0, 0) + if type(first) == s:TYPE.dict + let extra = first + else + let bang = first + endif + elseif len(a:extra) == 2 + let [extra, bang] = a:extra + else + throw 'invalid number of arguments' + endif + + let extra = copy(extra) + let eopts = has_key(extra, 'options') ? remove(extra, 'options') : '' + let merged = extend(copy(a:opts), extra) + call s:merge_opts(merged, eopts) + return fzf#run(s:wrap(a:name, merged, bang)) +endfunction + +let s:default_action = { + \ 'ctrl-t': 'tab split', + \ 'ctrl-x': 'split', + \ 'ctrl-v': 'vsplit' } + +function! s:action_for(key, ...) + let default = a:0 ? a:1 : '' + let Cmd = get(get(g:, 'fzf_action', s:default_action), a:key, default) + return type(Cmd) == s:TYPE.string ? Cmd : default +endfunction + +function! s:open(cmd, target) + if stridx('edit', a:cmd) == 0 && fnamemodify(a:target, ':p') ==# expand('%:p') + normal! m' + return + endif + execute a:cmd s:escape(a:target) +endfunction + +function! s:align_lists(lists) + let maxes = {} + for list in a:lists + let i = 0 + while i < len(list) + let maxes[i] = max([get(maxes, i, 0), len(list[i])]) + let i += 1 + endwhile + endfor + for list in a:lists + call map(list, "printf('%-'.maxes[v:key].'s', v:val)") + endfor + return a:lists +endfunction + +function! s:warn(message) + echohl WarningMsg + echom a:message + echohl None + return 0 +endfunction + +function! s:fill_quickfix(list, ...) + if len(a:list) > 1 + call setqflist(a:list) + copen + wincmd p + if a:0 + execute a:1 + endif + endif +endfunction + +function! fzf#vim#_uniq(list) + let visited = {} + let ret = [] + for l in a:list + if !empty(l) && !has_key(visited, l) + call add(ret, l) + let visited[l] = 1 + endif + endfor + return ret +endfunction + +" ------------------------------------------------------------------ +" Files +" ------------------------------------------------------------------ +function! s:shortpath() + let short = fnamemodify(getcwd(), ':~:.') + if !has('win32unix') + let short = pathshorten(short) + endif + let slash = (s:is_win && !&shellslash) ? '\' : '/' + return empty(short) ? '~'.slash : short . (short =~ escape(slash, '\').'$' ? '' : slash) +endfunction + +function! fzf#vim#files(dir, ...) + let args = {} + if !empty(a:dir) + if !isdirectory(expand(a:dir)) + return s:warn('Invalid directory') + endif + let slash = (s:is_win && !&shellslash) ? '\\' : '/' + let dir = substitute(a:dir, '[/\\]*$', slash, '') + let args.dir = dir + else + let dir = s:shortpath() + endif + + let args.options = ['-m', '--prompt', strwidth(dir) < &columns / 2 - 20 ? dir : '> '] + call s:merge_opts(args, get(g:, 'fzf_files_options', [])) + return s:fzf('files', args, a:000) +endfunction + +" ------------------------------------------------------------------ +" Lines +" ------------------------------------------------------------------ +function! s:line_handler(lines) + if len(a:lines) < 2 + return + endif + normal! m' + let cmd = s:action_for(a:lines[0]) + if !empty(cmd) && stridx('edit', cmd) < 0 + execute 'silent' cmd + endif + + let keys = split(a:lines[1], '\t') + execute 'buffer' keys[0] + execute keys[2] + normal! ^zvzz +endfunction + +function! fzf#vim#_lines(all) + let cur = [] + let rest = [] + let buf = bufnr('') + let longest_name = 0 + let display_bufnames = &columns > s:wide + if display_bufnames + let bufnames = {} + for b in s:buflisted() + let bufnames[b] = pathshorten(fnamemodify(bufname(b), ":~:.")) + let longest_name = max([longest_name, len(bufnames[b])]) + endfor + endif + let len_bufnames = min([15, longest_name]) + for b in s:buflisted() + let lines = getbufline(b, 1, "$") + if empty(lines) + let path = fnamemodify(bufname(b), ':p') + let lines = filereadable(path) ? readfile(path) : [] + endif + if display_bufnames + let bufname = bufnames[b] + if len(bufname) > len_bufnames + 1 + let bufname = '…' . bufname[-len_bufnames+1:] + endif + let bufname = printf(s:green("%".len_bufnames."s", "Directory"), bufname) + else + let bufname = '' + endif + let linefmt = s:blue("%2d\t", "TabLine")."%s".s:yellow("\t%4d ", "LineNr")."\t%s" + call extend(b == buf ? cur : rest, + \ filter( + \ map(lines, + \ '(!a:all && empty(v:val)) ? "" : printf(linefmt, b, bufname, v:key + 1, v:val)'), + \ 'a:all || !empty(v:val)')) + endfor + return [display_bufnames, extend(cur, rest)] +endfunction + +function! fzf#vim#lines(...) + let [display_bufnames, lines] = fzf#vim#_lines(1) + let nth = display_bufnames ? 3 : 2 + let [query, args] = (a:0 && type(a:1) == type('')) ? + \ [a:1, a:000[1:]] : ['', a:000] + return s:fzf('lines', { + \ 'source': lines, + \ 'sink*': s:function('s:line_handler'), + \ 'options': s:reverse_list(['+m', '--tiebreak=index', '--prompt', 'Lines> ', '--ansi', '--extended', '--nth='.nth.'..', '--tabstop=1', '--query', query]) + \}, args) +endfunction + +" ------------------------------------------------------------------ +" BLines +" ------------------------------------------------------------------ +function! s:buffer_line_handler(lines) + if len(a:lines) < 2 + return + endif + let qfl = [] + for line in a:lines[1:] + let chunks = split(line, "\t", 1) + let ln = chunks[0] + let ltxt = join(chunks[1:], "\t") + call add(qfl, {'filename': expand('%'), 'lnum': str2nr(ln), 'text': ltxt}) + endfor + call s:fill_quickfix(qfl, 'cfirst') + normal! m' + let cmd = s:action_for(a:lines[0]) + if !empty(cmd) + execute 'silent' cmd + endif + + execute split(a:lines[1], '\t')[0] + normal! ^zvzz +endfunction + +function! s:buffer_lines(query) + let linefmt = s:yellow(" %4d ", "LineNr")."\t%s" + let fmtexpr = 'printf(linefmt, v:key + 1, v:val)' + let lines = getline(1, '$') + if empty(a:query) + return map(lines, fmtexpr) + end + return filter(map(lines, 'v:val =~ a:query ? '.fmtexpr.' : ""'), 'len(v:val)') +endfunction + +function! fzf#vim#buffer_lines(...) + let [query, args] = (a:0 && type(a:1) == type('')) ? + \ [a:1, a:000[1:]] : ['', a:000] + return s:fzf('blines', { + \ 'source': s:buffer_lines(query), + \ 'sink*': s:function('s:buffer_line_handler'), + \ 'options': s:reverse_list(['+m', '--tiebreak=index', '--multi', '--prompt', 'BLines> ', '--ansi', '--extended', '--nth=2..', '--tabstop=1']) + \}, args) +endfunction + +" ------------------------------------------------------------------ +" Colors +" ------------------------------------------------------------------ +function! fzf#vim#colors(...) + let colors = split(globpath(&rtp, "colors/*.vim"), "\n") + if has('packages') + let colors += split(globpath(&packpath, "pack/*/opt/*/colors/*.vim"), "\n") + endif + return s:fzf('colors', { + \ 'source': fzf#vim#_uniq(map(colors, "substitute(fnamemodify(v:val, ':t'), '\\..\\{-}$', '', '')")), + \ 'sink': 'colo', + \ 'options': '+m --prompt="Colors> "' + \}, a:000) +endfunction + +" ------------------------------------------------------------------ +" Locate +" ------------------------------------------------------------------ +function! fzf#vim#locate(query, ...) + return s:fzf('locate', { + \ 'source': 'locate '.a:query, + \ 'options': '-m --prompt "Locate> "' + \}, a:000) +endfunction + +" ------------------------------------------------------------------ +" History[:/] +" ------------------------------------------------------------------ +function! fzf#vim#_recent_files() + return fzf#vim#_uniq(map( + \ filter([expand('%')], 'len(v:val)') + \ + filter(map(fzf#vim#_buflisted_sorted(), 'bufname(v:val)'), 'len(v:val)') + \ + filter(copy(v:oldfiles), "filereadable(fnamemodify(v:val, ':p'))"), + \ 'fnamemodify(v:val, ":~:.")')) +endfunction + +function! s:history_source(type) + let max = histnr(a:type) + let fmt = s:yellow(' %'.len(string(max)).'d ', 'Number') + let list = filter(map(range(1, max), 'histget(a:type, - v:val)'), '!empty(v:val)') + return extend([' :: Press '.s:magenta('CTRL-E', 'Special').' to edit'], + \ map(list, 'printf(fmt, len(list) - v:key)." ".v:val')) +endfunction + +nnoremap (-fzf-vim-do) :execute g:__fzf_command +nnoremap (-fzf-/) / +nnoremap (-fzf-:) : + +function! s:history_sink(type, lines) + if len(a:lines) < 2 + return + endif + + let prefix = "\(-fzf-".a:type.')' + let key = a:lines[0] + let item = matchstr(a:lines[1], ' *[0-9]\+ *\zs.*') + if key == 'ctrl-e' + call histadd(a:type, item) + redraw + call feedkeys(a:type."\", 'n') + else + if a:type == ':' + call histadd(a:type, item) + endif + let g:__fzf_command = "normal ".prefix.item."\" + call feedkeys("\(-fzf-vim-do)") + endif +endfunction + +function! s:cmd_history_sink(lines) + call s:history_sink(':', a:lines) +endfunction + +function! fzf#vim#command_history(...) + return s:fzf('history-command', { + \ 'source': s:history_source(':'), + \ 'sink*': s:function('s:cmd_history_sink'), + \ 'options': '+m --ansi --prompt="Hist:> " --header-lines=1 --expect=ctrl-e --tiebreak=index'}, a:000) +endfunction + +function! s:search_history_sink(lines) + call s:history_sink('/', a:lines) +endfunction + +function! fzf#vim#search_history(...) + return s:fzf('history-search', { + \ 'source': s:history_source('/'), + \ 'sink*': s:function('s:search_history_sink'), + \ 'options': '+m --ansi --prompt="Hist/> " --header-lines=1 --expect=ctrl-e --tiebreak=index'}, a:000) +endfunction + +function! fzf#vim#history(...) + return s:fzf('history-files', { + \ 'source': fzf#vim#_recent_files(), + \ 'options': ['-m', '--header-lines', !empty(expand('%')), '--prompt', 'Hist> '] + \}, a:000) +endfunction + +" ------------------------------------------------------------------ +" GFiles[?] +" ------------------------------------------------------------------ + +function! s:get_git_root(dir) + let dir = len(a:dir) ? a:dir : substitute(split(expand('%:p:h'), '[/\\]\.git\([/\\]\|$\)')[0], '^fugitive://', '', '') + let root = systemlist('git -C ' . fzf#shellescape(dir) . ' rev-parse --show-toplevel')[0] + return v:shell_error ? '' : (len(a:dir) ? fnamemodify(a:dir, ':p') : root) +endfunction + +function! fzf#vim#gitfiles(args, ...) + let dir = get(get(a:, 1, {}), 'dir', '') + let root = s:get_git_root(dir) + if empty(root) + return s:warn('Not in git repo') + endif + let prefix = 'git -C ' . fzf#shellescape(root) . ' ' + if a:args != '?' + return s:fzf('gfiles', { + \ 'source': prefix . 'ls-files '.a:args.(s:is_win ? '' : ' | uniq'), + \ 'dir': root, + \ 'options': '-m --prompt "GitFiles> "' + \}, a:000) + endif + + " Here be dragons! + " We're trying to access the common sink function that fzf#wrap injects to + " the options dictionary. + let bar = s:is_win ? '^|' : '|' + let preview = printf( + \ 'bash -c "if [[ {1} =~ M ]]; then %s; else %s {-1}; fi"', + \ executable('delta') + \ ? prefix . 'diff -- {-1} ' . bar . ' delta --width $FZF_PREVIEW_COLUMNS --file-style=omit ' . bar . ' sed 1d' + \ : prefix . 'diff --color=always -- {-1} ' . bar . ' sed 1,4d', + \ s:bin.preview) + let wrapped = fzf#wrap({ + \ 'source': prefix . '-c color.status=always status --short --untracked-files=all', + \ 'dir': root, + \ 'options': ['--ansi', '--multi', '--nth', '2..,..', '--tiebreak=index', '--prompt', 'GitFiles?> ', '--preview', preview] + \}) + call s:remove_layout(wrapped) + let wrapped.common_sink = remove(wrapped, 'sink*') + function! wrapped.newsink(lines) + let lines = extend(a:lines[0:0], map(a:lines[1:], 'substitute(v:val[3:], ".* -> ", "", "")')) + return self.common_sink(lines) + endfunction + let wrapped['sink*'] = remove(wrapped, 'newsink') + return s:fzf('gfiles-diff', wrapped, a:000) +endfunction + +" ------------------------------------------------------------------ +" Buffers +" ------------------------------------------------------------------ +function! s:find_open_window(b) + let [tcur, tcnt] = [tabpagenr() - 1, tabpagenr('$')] + for toff in range(0, tabpagenr('$') - 1) + let t = (tcur + toff) % tcnt + 1 + let buffers = tabpagebuflist(t) + for w in range(1, len(buffers)) + let b = buffers[w - 1] + if b == a:b + return [t, w] + endif + endfor + endfor + return [0, 0] +endfunction + +function! s:jump(t, w) + execute a:t.'tabnext' + execute a:w.'wincmd w' +endfunction + +function! s:bufopen(lines) + if len(a:lines) < 2 + return + endif + let b = matchstr(a:lines[1], '\[\zs[0-9]*\ze\]') + if empty(a:lines[0]) && get(g:, 'fzf_buffers_jump') + let [t, w] = s:find_open_window(b) + if t + call s:jump(t, w) + return + endif + endif + let cmd = s:action_for(a:lines[0]) + if !empty(cmd) + execute 'silent' cmd + endif + execute 'buffer' b +endfunction + +function! fzf#vim#_format_buffer(b) + let name = bufname(a:b) + let line = exists('*getbufinfo') ? getbufinfo(a:b)[0]['lnum'] : 0 + let name = empty(name) ? '[No Name]' : fnamemodify(name, ":p:~:.") + let flag = a:b == bufnr('') ? s:blue('%', 'Conditional') : + \ (a:b == bufnr('#') ? s:magenta('#', 'Special') : ' ') + let modified = getbufvar(a:b, '&modified') ? s:red(' [+]', 'Exception') : '' + let readonly = getbufvar(a:b, '&modifiable') ? '' : s:green(' [RO]', 'Constant') + let extra = join(filter([modified, readonly], '!empty(v:val)'), '') + let target = line == 0 ? name : name.':'.line + return s:strip(printf("%s\t%d\t[%s] %s\t%s\t%s", target, line, s:yellow(a:b, 'Number'), flag, name, extra)) +endfunction + +function! s:sort_buffers(...) + let [b1, b2] = map(copy(a:000), 'get(g:fzf#vim#buffers, v:val, v:val)') + " Using minus between a float and a number in a sort function causes an error + return b1 < b2 ? 1 : -1 +endfunction + +function! fzf#vim#_buflisted_sorted() + return sort(s:buflisted(), 's:sort_buffers') +endfunction + +function! fzf#vim#buffers(...) + let [query, args] = (a:0 && type(a:1) == type('')) ? + \ [a:1, a:000[1:]] : ['', a:000] + let sorted = fzf#vim#_buflisted_sorted() + let header_lines = '--header-lines=' . (bufnr('') == get(sorted, 0, 0) ? 1 : 0) + let tabstop = len(max(sorted)) >= 4 ? 9 : 8 + return s:fzf('buffers', { + \ 'source': map(sorted, 'fzf#vim#_format_buffer(v:val)'), + \ 'sink*': s:function('s:bufopen'), + \ 'options': ['+m', '-x', '--tiebreak=index', header_lines, '--ansi', '-d', '\t', '--with-nth', '3..', '-n', '2,1..2', '--prompt', 'Buf> ', '--query', query, '--preview-window', '+{2}-/2', '--tabstop', tabstop] + \}, args) +endfunction + +" ------------------------------------------------------------------ +" Ag / Rg +" ------------------------------------------------------------------ +function! s:ag_to_qf(line, has_column) + let parts = matchlist(a:line, '\(.\{-}\)\s*:\s*\(\d\+\)\%(\s*:\s*\(\d\+\)\)\?\%(\s*:\(.*\)\)\?') + let dict = {'filename': &acd ? fnamemodify(parts[1], ':p') : parts[1], 'lnum': parts[2], 'text': parts[4]} + if a:has_column + let dict.col = parts[3] + endif + return dict +endfunction + +function! s:ag_handler(lines, has_column) + if len(a:lines) < 2 + return + endif + + let cmd = s:action_for(a:lines[0], 'e') + let list = map(filter(a:lines[1:], 'len(v:val)'), 's:ag_to_qf(v:val, a:has_column)') + if empty(list) + return + endif + + let first = list[0] + try + call s:open(cmd, first.filename) + execute first.lnum + if a:has_column + call cursor(0, first.col) + endif + normal! zvzz + catch + endtry + + call s:fill_quickfix(list) +endfunction + +" query, [[ag options], options] +function! fzf#vim#ag(query, ...) + if type(a:query) != s:TYPE.string + return s:warn('Invalid query argument') + endif + let query = empty(a:query) ? '^(?=.)' : a:query + let args = copy(a:000) + let ag_opts = len(args) > 1 && type(args[0]) == s:TYPE.string ? remove(args, 0) : '' + let command = ag_opts . ' -- ' . fzf#shellescape(query) + return call('fzf#vim#ag_raw', insert(args, command, 0)) +endfunction + +" ag command suffix, [options] +function! fzf#vim#ag_raw(command_suffix, ...) + if !executable('ag') + return s:warn('ag is not found') + endif + return call('fzf#vim#grep', extend(['ag --nogroup --column --color '.a:command_suffix, 1], a:000)) +endfunction + +" command (string), has_column (0/1), [options (dict)], [fullscreen (0/1)] +function! fzf#vim#grep(grep_command, has_column, ...) + let words = [] + for word in split(a:grep_command) + if word !~# '^[a-z]' + break + endif + call add(words, word) + endfor + let words = empty(words) ? ['grep'] : words + let name = join(words, '-') + let capname = join(map(words, 'toupper(v:val[0]).v:val[1:]'), '') + let opts = { + \ 'column': a:has_column, + \ 'options': ['--ansi', '--prompt', capname.'> ', + \ '--multi', '--bind', 'alt-a:select-all,alt-d:deselect-all', + \ '--delimiter', ':', '--preview-window', '+{2}-/2'] + \} + function! opts.sink(lines) + return s:ag_handler(a:lines, self.column) + endfunction + let opts['sink*'] = remove(opts, 'sink') + try + let prev_default_command = $FZF_DEFAULT_COMMAND + let $FZF_DEFAULT_COMMAND = a:grep_command + return s:fzf(name, opts, a:000) + finally + let $FZF_DEFAULT_COMMAND = prev_default_command + endtry +endfunction + +" ------------------------------------------------------------------ +" BTags +" ------------------------------------------------------------------ +function! s:btags_source(tag_cmds) + if !filereadable(expand('%')) + throw 'Save the file first' + endif + + for cmd in a:tag_cmds + let lines = split(system(cmd), "\n") + if !v:shell_error && len(lines) + break + endif + endfor + if v:shell_error + throw get(lines, 0, 'Failed to extract tags') + elseif empty(lines) + throw 'No tags found' + endif + return map(s:align_lists(map(lines, 'split(v:val, "\t")')), 'join(v:val, "\t")') +endfunction + +function! s:btags_sink(lines) + if len(a:lines) < 2 + return + endif + normal! m' + let cmd = s:action_for(a:lines[0]) + if !empty(cmd) + execute 'silent' cmd '%' + endif + let qfl = [] + for line in a:lines[1:] + execute split(line, "\t")[2] + call add(qfl, {'filename': expand('%'), 'lnum': line('.'), 'text': getline('.')}) + endfor + call s:fill_quickfix(qfl, 'cfirst') + normal! zvzz +endfunction + +" query, [[tag commands], options] +function! fzf#vim#buffer_tags(query, ...) + let args = copy(a:000) + let escaped = fzf#shellescape(expand('%')) + let null = s:is_win ? 'nul' : '/dev/null' + let sort = has('unix') && !has('win32unix') && executable('sort') ? '| sort -s -k 5' : '' + let tag_cmds = (len(args) > 1 && type(args[0]) != type({})) ? remove(args, 0) : [ + \ printf('ctags -f - --sort=yes --excmd=number --language-force=%s %s 2> %s %s', get({ 'cpp': 'c++' }, &filetype, &filetype), escaped, null, sort), + \ printf('ctags -f - --sort=yes --excmd=number %s 2> %s %s', escaped, null, sort)] + if type(tag_cmds) != type([]) + let tag_cmds = [tag_cmds] + endif + try + return s:fzf('btags', { + \ 'source': s:btags_source(tag_cmds), + \ 'sink*': s:function('s:btags_sink'), + \ 'options': s:reverse_list(['-m', '-d', '\t', '--with-nth', '1,4..', '-n', '1', '--prompt', 'BTags> ', '--query', a:query, '--preview-window', '+{3}-/2'])}, args) + catch + return s:warn(v:exception) + endtry +endfunction + +" ------------------------------------------------------------------ +" Tags +" ------------------------------------------------------------------ +function! s:tags_sink(lines) + if len(a:lines) < 2 + return + endif + normal! m' + let qfl = [] + let cmd = s:action_for(a:lines[0], 'e') + try + let [magic, &magic, wrapscan, &wrapscan, acd, &acd] = [&magic, 0, &wrapscan, 1, &acd, 0] + for line in a:lines[1:] + try + let parts = split(line, '\t\zs') + let excmd = matchstr(join(parts[2:-2], '')[:-2], '^.\{-}\ze;\?"\t') + let base = fnamemodify(parts[-1], ':h') + let relpath = parts[1][:-2] + let abspath = relpath =~ (s:is_win ? '^[A-Z]:\' : '^/') ? relpath : join([base, relpath], '/') + call s:open(cmd, expand(abspath, 1)) + silent execute excmd + call add(qfl, {'filename': expand('%'), 'lnum': line('.'), 'text': getline('.')}) + catch /^Vim:Interrupt$/ + break + catch + call s:warn(v:exception) + endtry + endfor + finally + let [&magic, &wrapscan, &acd] = [magic, wrapscan, acd] + endtry + call s:fill_quickfix(qfl, 'clast') + normal! zvzz +endfunction + +function! fzf#vim#tags(query, ...) + if !executable('perl') + return s:warn('Tags command requires perl') + endif + if empty(tagfiles()) + call inputsave() + echohl WarningMsg + let gen = input('tags not found. Generate? (y/N) ') + echohl None + call inputrestore() + redraw + if gen =~? '^y' + call s:warn('Preparing tags') + call system(get(g:, 'fzf_tags_command', 'ctags -R'.(s:is_win ? ' --output-format=e-ctags' : ''))) + if empty(tagfiles()) + return s:warn('Failed to create tags') + endif + else + return s:warn('No tags found') + endif + endif + + let tagfiles = tagfiles() + let v2_limit = 1024 * 1024 * 200 + for tagfile in tagfiles + let v2_limit -= getfsize(tagfile) + if v2_limit < 0 + break + endif + endfor + let opts = v2_limit < 0 ? ['--algo=v1'] : [] + + return s:fzf('tags', { + \ 'source': 'perl '.fzf#shellescape(s:bin.tags).' '.join(map(tagfiles, 'fzf#shellescape(fnamemodify(v:val, ":p"))')), + \ 'sink*': s:function('s:tags_sink'), + \ 'options': extend(opts, ['--nth', '1..2', '-m', '-d', '\t', '--tiebreak=begin', '--prompt', 'Tags> ', '--query', a:query])}, a:000) +endfunction + +" ------------------------------------------------------------------ +" Snippets (UltiSnips) +" ------------------------------------------------------------------ +function! s:inject_snippet(line) + let snip = split(a:line, "\t")[0] + execute 'normal! a'.s:strip(snip)."\=UltiSnips#ExpandSnippet()\" +endfunction + +function! fzf#vim#snippets(...) + if !exists(':UltiSnipsEdit') + return s:warn('UltiSnips not found') + endif + let list = UltiSnips#SnippetsInCurrentScope() + if empty(list) + return s:warn('No snippets available here') + endif + let aligned = sort(s:align_lists(items(list))) + let colored = map(aligned, 's:yellow(v:val[0])."\t".v:val[1]') + return s:fzf('snippets', { + \ 'source': colored, + \ 'options': '--ansi --tiebreak=index +m -n 1,.. -d "\t"', + \ 'sink': s:function('s:inject_snippet')}, a:000) +endfunction + +" ------------------------------------------------------------------ +" Commands +" ------------------------------------------------------------------ +let s:nbs = nr2char(0xa0) + +function! s:format_cmd(line) + return substitute(a:line, '\C \([A-Z]\S*\) ', + \ '\=s:nbs.s:yellow(submatch(1), "Function").s:nbs', '') +endfunction + +function! s:command_sink(lines) + if len(a:lines) < 2 + return + endif + let cmd = matchstr(a:lines[1], s:nbs.'\zs\S*\ze'.s:nbs) + if empty(a:lines[0]) + call feedkeys(':'.cmd.(a:lines[1][0] == '!' ? '' : ' '), 'n') + else + call feedkeys(':'.cmd."\", 'n') + endif +endfunction + +let s:fmt_excmd = ' '.s:blue('%-38s', 'Statement').'%s' + +function! s:format_excmd(ex) + let match = matchlist(a:ex, '^|:\(\S\+\)|\s*\S*\(.*\)') + return printf(s:fmt_excmd, s:nbs.match[1].s:nbs, s:strip(match[2])) +endfunction + +function! s:excmds() + let help = globpath($VIMRUNTIME, 'doc/index.txt') + if empty(help) + return [] + endif + + let commands = [] + let command = '' + for line in readfile(help) + if line =~ '^|:[^|]' + if !empty(command) + call add(commands, s:format_excmd(command)) + endif + let command = line + elseif line =~ '^\s\+\S' && !empty(command) + let command .= substitute(line, '^\s*', ' ', '') + elseif !empty(commands) && line =~ '^\s*$' + break + endif + endfor + if !empty(command) + call add(commands, s:format_excmd(command)) + endif + return commands +endfunction + +function! fzf#vim#commands(...) + redir => cout + silent command + redir END + let list = split(cout, "\n") + return s:fzf('commands', { + \ 'source': extend(extend(list[0:0], map(list[1:], 's:format_cmd(v:val)')), s:excmds()), + \ 'sink*': s:function('s:command_sink'), + \ 'options': '--ansi --expect '.get(g:, 'fzf_commands_expect', 'ctrl-x'). + \ ' --tiebreak=index --header-lines 1 -x --prompt "Commands> " -n2,3,2..3 -d'.s:nbs}, a:000) +endfunction + +" ------------------------------------------------------------------ +" Marks +" ------------------------------------------------------------------ +function! s:format_mark(line) + return substitute(a:line, '\S', '\=s:yellow(submatch(0), "Number")', '') +endfunction + +function! s:mark_sink(lines) + if len(a:lines) < 2 + return + endif + let cmd = s:action_for(a:lines[0]) + if !empty(cmd) + execute 'silent' cmd + endif + execute 'normal! `'.matchstr(a:lines[1], '\S').'zz' +endfunction + +function! fzf#vim#marks(...) + redir => cout + silent marks + redir END + let list = split(cout, "\n") + return s:fzf('marks', { + \ 'source': extend(list[0:0], map(list[1:], 's:format_mark(v:val)')), + \ 'sink*': s:function('s:mark_sink'), + \ 'options': '+m -x --ansi --tiebreak=index --header-lines 1 --tiebreak=begin --prompt "Marks> "'}, a:000) +endfunction + +" ------------------------------------------------------------------ +" Help tags +" ------------------------------------------------------------------ +function! s:helptag_sink(line) + let [tag, file, path] = split(a:line, "\t")[0:2] + let rtp = fnamemodify(path, ':p:h:h') + if stridx(&rtp, rtp) < 0 + execute 'set rtp+='.s:escape(rtp) + endif + execute 'help' tag +endfunction + +function! fzf#vim#helptags(...) + if !executable('grep') || !executable('perl') + return s:warn('Helptags command requires grep and perl') + endif + let sorted = sort(split(globpath(&runtimepath, 'doc/tags', 1), '\n')) + let tags = exists('*uniq') ? uniq(sorted) : fzf#vim#_uniq(sorted) + + if exists('s:helptags_script') + silent! call delete(s:helptags_script) + endif + let s:helptags_script = tempname() + + call writefile(['/('.(s:is_win ? '^[A-Z]:[\/\\].*?[^:]' : '.*?').'):(.*?)\t(.*?)\t(.*)/; printf(qq('.s:green('%-40s', 'Label').'\t%s\t%s\t%s\n), $2, $3, $1, $4)'], s:helptags_script) + return s:fzf('helptags', { + \ 'source': 'grep --with-filename ".*" '.join(map(tags, 'fzf#shellescape(v:val)')). + \ ' | perl -n '.fzf#shellescape(s:helptags_script).' | sort', + \ 'sink': s:function('s:helptag_sink'), + \ 'options': ['--ansi', '+m', '--tiebreak=begin', '--with-nth', '..3']}, a:000) +endfunction + +" ------------------------------------------------------------------ +" File types +" ------------------------------------------------------------------ +function! fzf#vim#filetypes(...) + return s:fzf('filetypes', { + \ 'source': fzf#vim#_uniq(sort(map(split(globpath(&rtp, 'syntax/*.vim'), '\n'), + \ 'fnamemodify(v:val, ":t:r")'))), + \ 'sink': 'setf', + \ 'options': '+m --prompt="File types> "' + \}, a:000) +endfunction + +" ------------------------------------------------------------------ +" Windows +" ------------------------------------------------------------------ +function! s:format_win(tab, win, buf) + let modified = getbufvar(a:buf, '&modified') + let name = bufname(a:buf) + let name = empty(name) ? '[No Name]' : name + let active = tabpagewinnr(a:tab) == a:win + return (active? s:blue('> ', 'Operator') : ' ') . name . (modified? s:red(' [+]', 'Exception') : '') +endfunction + +function! s:windows_sink(line) + let list = matchlist(a:line, '^ *\([0-9]\+\) *\([0-9]\+\)') + call s:jump(list[1], list[2]) +endfunction + +function! fzf#vim#windows(...) + let lines = [] + for t in range(1, tabpagenr('$')) + let buffers = tabpagebuflist(t) + for w in range(1, len(buffers)) + call add(lines, + \ printf('%s %s %s', + \ s:yellow(printf('%3d', t), 'Number'), + \ s:cyan(printf('%3d', w), 'String'), + \ s:format_win(t, w, buffers[w-1]))) + endfor + endfor + return s:fzf('windows', { + \ 'source': extend(['Tab Win Name'], lines), + \ 'sink': s:function('s:windows_sink'), + \ 'options': '+m --ansi --tiebreak=begin --header-lines=1'}, a:000) +endfunction + +" ------------------------------------------------------------------ +" Commits / BCommits +" ------------------------------------------------------------------ +function! s:yank_to_register(data) + let @" = a:data + silent! let @* = a:data + silent! let @+ = a:data +endfunction + +function! s:commits_sink(lines) + if len(a:lines) < 2 + return + endif + + let pat = '[0-9a-f]\{7,9}' + + if a:lines[0] == 'ctrl-y' + let hashes = join(filter(map(a:lines[1:], 'matchstr(v:val, pat)'), 'len(v:val)')) + return s:yank_to_register(hashes) + end + + let diff = a:lines[0] == 'ctrl-d' + let cmd = s:action_for(a:lines[0], 'e') + let buf = bufnr('') + for idx in range(1, len(a:lines) - 1) + let sha = matchstr(a:lines[idx], pat) + if !empty(sha) + if diff + if idx > 1 + execute 'tab sb' buf + endif + execute 'Gdiff' sha + else + " Since fugitive buffers are unlisted, we can't keep using 'e' + let c = (cmd == 'e' && idx > 1) ? 'tab split' : cmd + execute c FugitiveFind(sha) + endif + endif + endfor +endfunction + +function! s:commits(range, buffer_local, args) + let s:git_root = s:get_git_root('') + if empty(s:git_root) + return s:warn('Not in git repository') + endif + + let prefix = 'git -C ' . fzf#shellescape(s:git_root) . ' ' + let source = prefix . 'log '.get(g:, 'fzf_commits_log_options', '--color=always '.fzf#shellescape('--format=%C(auto)%h%d %s %C(green)%cr')) + let current = expand('%:p') + let managed = 0 + if !empty(current) + call system(prefix . 'show '.fzf#shellescape(current).' 2> '.(s:is_win ? 'nul' : '/dev/null')) + let managed = !v:shell_error + endif + + if len(a:range) || a:buffer_local + if !managed + return s:warn('The current buffer is not in the working tree') + endif + let source .= len(a:range) + \ ? printf(' -L %d,%d:%s --no-patch', a:range[0], a:range[1], fzf#shellescape(current)) + \ : (' --follow '.fzf#shellescape(current)) + let command = 'BCommits' + else + let source .= ' --graph' + let command = 'Commits' + endif + + let expect_keys = join(keys(get(g:, 'fzf_action', s:default_action)), ',') + let options = { + \ 'source': source, + \ 'sink*': s:function('s:commits_sink'), + \ 'options': s:reverse_list(['--ansi', '--multi', '--tiebreak=index', + \ '--inline-info', '--prompt', command.'> ', '--bind=ctrl-s:toggle-sort', + \ '--header', ':: Press '.s:magenta('CTRL-S', 'Special').' to toggle sort, '.s:magenta('CTRL-Y', 'Special').' to yank commit hashes', + \ '--expect=ctrl-y,'.expect_keys]) + \ } + + if a:buffer_local + let options.options[-2] .= ', '.s:magenta('CTRL-D', 'Special').' to diff' + let options.options[-1] .= ',ctrl-d' + endif + + if !s:is_win && &columns > s:wide + let suffix = executable('delta') ? '| delta --width $FZF_PREVIEW_COLUMNS' : '' + let orderfile = tempname() + call writefile([current[len(s:git_root)+1:]], orderfile) + call extend(options.options, + \ ['--preview', 'echo {} | grep -o "[a-f0-9]\{7,\}" | head -1 | xargs ' . prefix . 'show -O'.fzf#shellescape(orderfile).' --format=format: --color=always ' . suffix]) + endif + + return s:fzf(a:buffer_local ? 'bcommits' : 'commits', options, a:args) +endfunction + +" Heuristically determine if the user specified a range +function! s:given_range(line1, line2) + " 1. From visual mode + " :'<,'>Commits + " 2. From command-line + " :10,20Commits + if a:line1 == line("'<") && a:line2 == line("'>") || + \ (a:line1 != 1 || a:line2 != line('$')) + return [a:line1, a:line2] + endif + + return [] +endfunction + +function! fzf#vim#commits(...) range + if exists('b:fzf_winview') + call winrestview(b:fzf_winview) + unlet b:fzf_winview + endif + return s:commits(s:given_range(a:firstline, a:lastline), 0, a:000) +endfunction + +function! fzf#vim#buffer_commits(...) range + if exists('b:fzf_winview') + call winrestview(b:fzf_winview) + unlet b:fzf_winview + endif + return s:commits(s:given_range(a:firstline, a:lastline), 1, a:000) +endfunction + +" ------------------------------------------------------------------ +" fzf#vim#maps(mode, opts[with count and op]) +" ------------------------------------------------------------------ +function! s:align_pairs(list) + let maxlen = 0 + let pairs = [] + for elem in a:list + let match = matchlist(elem, '^\(\S*\)\s*\(.*\)$') + let [_, k, v] = match[0:2] + let maxlen = max([maxlen, len(k)]) + call add(pairs, [k, substitute(v, '^\*\?[@ ]\?', '', '')]) + endfor + let maxlen = min([maxlen, 35]) + return map(pairs, "printf('%-'.maxlen.'s', v:val[0]).' '.v:val[1]") +endfunction + +function! s:highlight_keys(str) + return substitute( + \ substitute(a:str, '<[^ >]\+>', s:yellow('\0', 'Special'), 'g'), + \ '', s:blue('', 'SpecialKey'), 'g') +endfunction + +function! s:key_sink(line) + let key = matchstr(a:line, '^\S*') + redraw + call feedkeys(s:map_gv.s:map_cnt.s:map_reg, 'n') + call feedkeys(s:map_op. + \ substitute(key, '<[^ >]\+>', '\=eval("\"\\".submatch(0)."\"")', 'g')) +endfunction + +function! fzf#vim#maps(mode, ...) + let s:map_gv = a:mode == 'x' ? 'gv' : '' + let s:map_cnt = v:count == 0 ? '' : v:count + let s:map_reg = empty(v:register) ? '' : ('"'.v:register) + let s:map_op = a:mode == 'o' ? v:operator : '' + + redir => cout + silent execute 'verbose' a:mode.'map' + redir END + let list = [] + let curr = '' + for line in split(cout, "\n") + if line =~ "^\t" + let src = "\t".substitute(matchstr(line, '/\zs[^/\\]*\ze$'), ' [^ ]* ', ':', '') + call add(list, printf('%s %s', curr, s:green(src, 'Comment'))) + let curr = '' + else + if !empty(curr) + call add(list, curr) + endif + let curr = line[3:] + endif + endfor + if !empty(curr) + call add(list, curr) + endif + let aligned = s:align_pairs(list) + let sorted = sort(aligned) + let colored = map(sorted, 's:highlight_keys(v:val)') + let pcolor = a:mode == 'x' ? 9 : a:mode == 'o' ? 10 : 12 + return s:fzf('maps', { + \ 'source': colored, + \ 'sink': s:function('s:key_sink'), + \ 'options': '--prompt "Maps ('.a:mode.')> " --ansi --no-hscroll --nth 1,.. --color prompt:'.pcolor}, a:000) +endfunction + +" ---------------------------------------------------------------------------- +" fzf#vim#complete - completion helper +" ---------------------------------------------------------------------------- +inoremap (-fzf-complete-trigger) :call complete_trigger() + +function! s:pluck(dict, key, default) + return has_key(a:dict, a:key) ? remove(a:dict, a:key) : a:default +endfunction + +function! s:complete_trigger() + let opts = copy(s:opts) + call s:prepend_opts(opts, ['+m', '-q', s:query]) + let opts['sink*'] = s:function('s:complete_insert') + let s:reducer = s:pluck(opts, 'reducer', s:function('s:first_line')) + call fzf#run(opts) +endfunction + +" The default reducer +function! s:first_line(lines) + return a:lines[0] +endfunction + +function! s:complete_insert(lines) + if empty(a:lines) + return + endif + + let chars = strchars(s:query) + if chars == 0 | let del = '' + elseif chars == 1 | let del = '"_x' + else | let del = (chars - 1).'"_dvh' + endif + + let data = call(s:reducer, [a:lines]) + let ve = &ve + set ve= + execute 'normal!' ((s:eol || empty(chars)) ? '' : 'h').del.(s:eol ? 'a': 'i').data + let &ve = ve + if mode() =~ 't' + call feedkeys('a', 'n') + elseif has('nvim') + execute "normal! \la" + else + call feedkeys("\(-fzf-complete-finish)") + endif +endfunction + +nnoremap (-fzf-complete-finish) a +inoremap (-fzf-complete-finish) l + +function! s:eval(dict, key, arg) + if has_key(a:dict, a:key) && type(a:dict[a:key]) == s:TYPE.funcref + let ret = copy(a:dict) + let ret[a:key] = call(a:dict[a:key], [a:arg]) + return ret + endif + return a:dict +endfunction + +function! fzf#vim#complete(...) + if a:0 == 0 + let s:opts = fzf#wrap() + elseif type(a:1) == s:TYPE.dict + let s:opts = copy(a:1) + elseif type(a:1) == s:TYPE.string + let s:opts = extend({'source': a:1}, get(a:000, 1, fzf#wrap())) + else + echoerr 'Invalid argument: '.string(a:000) + return '' + endif + for s in ['sink', 'sink*'] + if has_key(s:opts, s) + call remove(s:opts, s) + endif + endfor + + let eol = col('$') + let ve = &ve + set ve=all + let s:eol = col('.') == eol + let &ve = ve + + let Prefix = s:pluck(s:opts, 'prefix', '\k*$') + if col('.') == 1 + let s:query = '' + else + let full_prefix = getline('.')[0 : col('.')-2] + if type(Prefix) == s:TYPE.funcref + let s:query = call(Prefix, [full_prefix]) + else + let s:query = matchstr(full_prefix, Prefix) + endif + endif + let s:opts = s:eval(s:opts, 'source', s:query) + let s:opts = s:eval(s:opts, 'options', s:query) + let s:opts = s:eval(s:opts, 'extra_options', s:query) + if has_key(s:opts, 'extra_options') + call s:merge_opts(s:opts, remove(s:opts, 'extra_options')) + endif + if has_key(s:opts, 'options') + if type(s:opts.options) == s:TYPE.list + call add(s:opts.options, '--no-expect') + else + let s:opts.options .= ' --no-expect' + endif + endif + + call feedkeys("\(-fzf-complete-trigger)") + return '' +endfunction + +" ------------------------------------------------------------------ +let &cpo = s:cpo_save +unlet s:cpo_save diff --git a/dotfiles/.vim/plugged/fzf.vim/autoload/fzf/vim/complete.vim b/dotfiles/.vim/plugged/fzf.vim/autoload/fzf/vim/complete.vim new file mode 100644 index 00000000..8944b19d --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/autoload/fzf/vim/complete.vim @@ -0,0 +1,164 @@ +" Copyright (c) 2015 Junegunn Choi +" +" MIT License +" +" Permission is hereby granted, free of charge, to any person obtaining +" a copy of this software and associated documentation files (the +" "Software"), to deal in the Software without restriction, including +" without limitation the rights to use, copy, modify, merge, publish, +" distribute, sublicense, and/or sell copies of the Software, and to +" permit persons to whom the Software is furnished to do so, subject to +" the following conditions: +" +" The above copyright notice and this permission notice shall be +" included in all copies or substantial portions of the Software. +" +" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +" EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +" NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +" LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +" OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +" WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +let s:cpo_save = &cpo +set cpo&vim +let s:is_win = has('win32') || has('win64') + +function! s:extend(base, extra) + let base = copy(a:base) + if has_key(a:extra, 'options') + let extra = copy(a:extra) + let extra.extra_options = remove(extra, 'options') + return extend(base, extra) + endif + return extend(base, a:extra) +endfunction + +if v:version >= 704 + function! s:function(name) + return function(a:name) + endfunction +else + function! s:function(name) + " By Ingo Karkat + return function(substitute(a:name, '^s:', matchstr(expand(''), '\d\+_\zefunction$'), '')) + endfunction +endif + +function! fzf#vim#complete#word(...) + let sources = empty(&dictionary) ? ['/usr/share/dict/words'] : split(&dictionary, ',') + return fzf#vim#complete(s:extend({ + \ 'source': 'cat ' . join(map(sources, 'shellescape(v:val)'))}, + \ get(a:000, 0, fzf#wrap()))) +endfunction + +" ---------------------------------------------------------------------------- +" (fzf-complete-path) +" (fzf-complete-file) +" (fzf-complete-file-ag) +" ---------------------------------------------------------------------------- +function! s:file_split_prefix(prefix) + let expanded = expand(a:prefix) + let slash = (s:is_win && !&shellslash) ? '\\' : '/' + return isdirectory(expanded) ? + \ [expanded, + \ substitute(a:prefix, '[/\\]*$', slash, ''), + \ ''] : + \ [fnamemodify(expanded, ':h'), + \ substitute(fnamemodify(a:prefix, ':h'), '[/\\]*$', slash, ''), + \ fnamemodify(expanded, ':t')] +endfunction + +function! s:file_source(prefix) + let [dir, head, tail] = s:file_split_prefix(a:prefix) + return printf( + \ "cd %s && ".s:file_cmd." | sed %s", + \ fzf#shellescape(dir), fzf#shellescape('s:^:'.(empty(a:prefix) || a:prefix == tail ? '' : head).':')) +endfunction + +function! s:file_options(prefix) + let [_, head, tail] = s:file_split_prefix(a:prefix) + return ['--prompt', head, '--query', tail] +endfunction + +function! s:fname_prefix(str) + let isf = &isfname + let white = [] + let black = [] + if isf =~ ',,,' + call add(white, ',') + let isf = substitute(isf, ',,,', ',', 'g') + endif + if isf =~ ',^,,' + call add(black, ',') + let isf = substitute(isf, ',^,,', ',', 'g') + endif + + for token in split(isf, ',') + let target = white + if token[0] == '^' + let target = black + let token = token[1:] + endif + + let ends = matchlist(token, '\(.\+\)-\(.\+\)') + if empty(ends) + call add(target, token) + else + let ends = map(ends[1:2], "len(v:val) == 1 ? char2nr(v:val) : str2nr(v:val)") + for i in range(ends[0], ends[1]) + call add(target, nr2char(i)) + endfor + endif + endfor + + let prefix = a:str + for offset in range(1, len(a:str)) + let char = a:str[len(a:str) - offset] + if (char =~ '\w' || index(white, char) >= 0) && index(black, char) < 0 + continue + endif + let prefix = strpart(a:str, len(a:str) - offset + 1) + break + endfor + + return prefix +endfunction + +function! fzf#vim#complete#path(command, ...) + let s:file_cmd = a:command + return fzf#vim#complete(s:extend({ + \ 'prefix': s:function('s:fname_prefix'), + \ 'source': s:function('s:file_source'), + \ 'options': s:function('s:file_options')}, get(a:000, 0, fzf#wrap()))) +endfunction + +" ---------------------------------------------------------------------------- +" (fzf-complete-line) +" (fzf-complete-buffer-line) +" ---------------------------------------------------------------------------- +function! s:reduce_line(lines) + return join(split(a:lines[0], '\t\zs')[3:], '') +endfunction + + +function! fzf#vim#complete#line(...) + let [display_bufnames, lines] = fzf#vim#_lines(0) + let nth = display_bufnames ? 4 : 3 + return fzf#vim#complete(s:extend({ + \ 'prefix': '^.*$', + \ 'source': lines, + \ 'options': '--tiebreak=index --ansi --nth '.nth.'.. --tabstop=1', + \ 'reducer': s:function('s:reduce_line')}, get(a:000, 0, fzf#wrap()))) +endfunction + +function! fzf#vim#complete#buffer_line(...) + return fzf#vim#complete(s:extend({ + \ 'prefix': '^.*$', + \ 'source': fzf#vim#_uniq(getline(1, '$'))}, get(a:000, 0, fzf#wrap()))) +endfunction + +let &cpo = s:cpo_save +unlet s:cpo_save + diff --git a/dotfiles/.vim/plugged/fzf.vim/bin/preview.rb b/dotfiles/.vim/plugged/fzf.vim/bin/preview.rb new file mode 100755 index 00000000..45324215 --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/bin/preview.rb @@ -0,0 +1,3 @@ +#!/usr/bin/env ruby + +puts 'preview.rb is deprecated. Use preview.sh instead.' diff --git a/dotfiles/.vim/plugged/fzf.vim/bin/preview.sh b/dotfiles/.vim/plugged/fzf.vim/bin/preview.sh new file mode 100755 index 00000000..994f7d6f --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/bin/preview.sh @@ -0,0 +1,83 @@ +#!/usr/bin/env bash + +REVERSE="\x1b[7m" +RESET="\x1b[m" + +if [ -z "$1" ]; then + echo "usage: $0 [--tag] FILENAME[:LINENO][:IGNORED]" + exit 1 +fi + +if [ "$1" = --tag ]; then + shift + "$(dirname "${BASH_SOURCE[0]}")/tagpreview.sh" "$@" + exit $? +fi + +IFS=':' read -r -a INPUT <<< "$1" +FILE=${INPUT[0]} +CENTER=${INPUT[1]} + +if [[ "$1" =~ ^[A-Za-z]:\\ ]]; then + FILE=$FILE:${INPUT[1]} + CENTER=${INPUT[2]} +fi + +if [[ -n "$CENTER" && ! "$CENTER" =~ ^[0-9] ]]; then + exit 1 +fi +CENTER=${CENTER/[^0-9]*/} + +# MS Win support +if [[ "$FILE" =~ '\' ]]; then + if [ -z "$MSWINHOME" ]; then + MSWINHOME="$HOMEDRIVE$HOMEPATH" + fi + if grep -qEi "(Microsoft|WSL)" /proc/version &> /dev/null ; then + MSWINHOME="${MSWINHOME//\\/\\\\}" + FILE="${FILE/#\~\\/$MSWINHOME\\}" + FILE=$(wslpath -u "$FILE") + elif [ -n "$MSWINHOME" ]; then + FILE="${FILE/#\~\\/$MSWINHOME\\}" + fi +fi + +FILE="${FILE/#\~\//$HOME/}" +if [ ! -r "$FILE" ]; then + echo "File not found ${FILE}" + exit 1 +fi + +if [ -z "$CENTER" ]; then + CENTER=0 +fi + +# Sometimes bat is installed as batcat. +if command -v batcat > /dev/null; then + BATNAME="batcat" +elif command -v bat > /dev/null; then + BATNAME="bat" +fi + +if [ -z "$FZF_PREVIEW_COMMAND" ] && [ "${BATNAME:+x}" ]; then + ${BATNAME} --style="${BAT_STYLE:-numbers}" --color=always --pager=never \ + --highlight-line=$CENTER -- "$FILE" + exit $? +fi + +FILE_LENGTH=${#FILE} +MIME=$(file --dereference --mime -- "$FILE") +if [[ "${MIME:FILE_LENGTH}" =~ binary ]]; then + echo "$MIME" + exit 0 +fi + +DEFAULT_COMMAND="highlight -O ansi -l {} || coderay {} || rougify {} || cat {}" +CMD=${FZF_PREVIEW_COMMAND:-$DEFAULT_COMMAND} +CMD=${CMD//{\}/$(printf %q "$FILE")} + +eval "$CMD" 2> /dev/null | awk "{ \ + if (NR == $CENTER) \ + { gsub(/\x1b[[0-9;]*m/, \"&$REVERSE\"); printf(\"$REVERSE%s\n$RESET\", \$0); } \ + else printf(\"$RESET%s\n\", \$0); \ + }" diff --git a/dotfiles/.vim/plugged/fzf.vim/bin/tagpreview.sh b/dotfiles/.vim/plugged/fzf.vim/bin/tagpreview.sh new file mode 100755 index 00000000..e07f87de --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/bin/tagpreview.sh @@ -0,0 +1,73 @@ +#!/usr/bin/env bash + +REVERSE="\x1b[7m" +RESET="\x1b[m" + +if [ -z "$1" ]; then + echo "usage: $0 FILENAME:TAGFILE:EXCMD" + exit 1 +fi + +IFS=':' read -r FILE TAGFILE EXCMD <<< "$*" + +# Complete file paths which are relative to the given tag file +if [ "${FILE:0:1}" != "/" ]; then + FILE="$(dirname "${TAGFILE}")/${FILE}" +fi + +if [ ! -r "$FILE" ]; then + echo "File not found ${FILE}" + exit 1 +fi + +# If users aren't using vim, they are probably using neovim +if command -v vim > /dev/null; then + VIMNAME="vim" +elif command -v nvim > /dev/null; then + VIMNAME="nvim" +else + echo "Cannot preview tag: vim or nvim unavailable" + exit 1 +fi + +CENTER="$("${VIMNAME}" -i NONE -u NONE -e -m -s "${FILE}" \ + -c "set nomagic" \ + -c "${EXCMD}" \ + -c 'let l=line(".") | new | put =l | print | qa!')" || return + +START_LINE="$(( CENTER - FZF_PREVIEW_LINES / 2 ))" +if (( START_LINE <= 0 )); then + START_LINE=1 +fi +END_LINE="$(( START_LINE + FZF_PREVIEW_LINES - 1 ))" + +# Sometimes bat is installed as batcat. +if command -v batcat > /dev/null; then + BATNAME="batcat" +elif command -v bat > /dev/null; then + BATNAME="bat" +fi + +if [ -z "$FZF_PREVIEW_COMMAND" ] && [ "${BATNAME:+x}" ]; then + ${BATNAME} --style="${BAT_STYLE:-numbers}" \ + --color=always \ + --pager=never \ + --wrap=never \ + --terminal-width="${FZF_PREVIEW_COLUMNS}" \ + --line-range="${START_LINE}:${END_LINE}" \ + --highlight-line="${CENTER}" \ + "$FILE" + exit $? +fi + +DEFAULT_COMMAND="highlight -O ansi -l {} || coderay {} || rougify {} || cat {}" +CMD=${FZF_PREVIEW_COMMAND:-$DEFAULT_COMMAND} +CMD=${CMD//{\}/$(printf %q "$FILE")} + +eval "$CMD" 2> /dev/null | awk "{ \ + if (NR >= $START_LINE && NR <= $END_LINE) { \ + if (NR == $CENTER) \ + { gsub(/\x1b[[0-9;]*m/, \"&$REVERSE\"); printf(\"$REVERSE%s\n$RESET\", \$0); } \ + else printf(\"$RESET%s\n\", \$0); \ + } \ + }" diff --git a/dotfiles/.vim/plugged/fzf.vim/bin/tags.pl b/dotfiles/.vim/plugged/fzf.vim/bin/tags.pl new file mode 100755 index 00000000..4208c165 --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/bin/tags.pl @@ -0,0 +1,15 @@ +#!/usr/bin/env perl + +use strict; + +foreach my $file (@ARGV) { + open my $lines, $file; + while (<$lines>) { + unless (/^\!/) { + s/^[^\t]*/sprintf("%-24s", $&)/e; + s/$/\t$file/; + print; + } + } + close $lines; +} diff --git a/dotfiles/.vim/plugged/fzf.vim/doc/fzf-vim.txt b/dotfiles/.vim/plugged/fzf.vim/doc/fzf-vim.txt new file mode 100644 index 00000000..188abd09 --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/doc/fzf-vim.txt @@ -0,0 +1,497 @@ +fzf-vim.txt fzf-vim Last change: May 24 2021 +FZF-VIM - TABLE OF CONTENTS *fzf-vim* *fzf-vim-toc* +============================================================================== + + fzf :heart: vim + Rationale + Why you should use fzf on Vim + Installation + Using vim-plug + Dependencies + Commands + Customization + Global options + Preview window + Command-local options + Advanced customization + Vim functions + Example: Customizing Files command + Example: git grep wrapper + Example: Rg command with preview window + Example: Advanced ripgrep integration + Mappings + Completion functions + Custom completion + Reducer example + Status line of terminal buffer + Hide statusline + Custom statusline + License + +FZF :HEART: VIM *fzf-vim-fzfheart-vim* +============================================================================== + +Things you can do with {fzf}{1} and Vim. + + {1} https://github.com/junegunn/fzf + + +RATIONALE *fzf-vim-rationale* +============================================================================== + +{fzf}{1} in itself is not a Vim plugin, and the official repository only +provides the {basic wrapper function}{2} for Vim and it's up to the users to +write their own Vim commands with it. However, I've learned that many users of +fzf are not familiar with Vimscript and are looking for the "default" +implementation of the features they can find in the alternative Vim plugins. + +This repository is a bundle of fzf-based commands and mappings extracted from +my {.vimrc}{3} to address such needs. They are not designed to be flexible or +configurable, and there's no guarantee of backward-compatibility. + + {1} https://github.com/junegunn/fzf + {2} https://github.com/junegunn/fzf/blob/master/README-VIM.md#fzfrun + {3} https://github.com/junegunn/dotfiles/blob/master/vimrc + + +WHY YOU SHOULD USE FZF ON VIM *fzf-vim-why-you-should-use-fzf-on-vim* +============================================================================== + +Because you can and you love fzf. + +fzf runs asynchronously and can be orders of magnitude faster than similar Vim +plugins. However, the benefit may not be noticeable if the size of the input +is small, which is the case for many of the commands provided here. +Nevertheless I wrote them anyway since it's really easy to implement custom +selector with fzf. + + +INSTALLATION *fzf-vim-installation* +============================================================================== + +fzf.vim depends on the basic Vim plugin of {the main fzf repository}{1}, which +means you need to set up both "fzf" and "fzf.vim" on Vim. To learn more about +fzf/Vim integration, see {README-VIM}{4}. + + {1} https://github.com/junegunn/fzf + {4} https://github.com/junegunn/fzf/blob/master/README-VIM.md + + +< Using vim-plug >____________________________________________________________~ + *fzf-vim-using-vim-plug* +> + Plug 'junegunn/fzf', { 'do': { -> fzf#install() } } + Plug 'junegunn/fzf.vim' +< +`fzf#install()` makes sure that you have the latest binary, but it's optional, +so you can omit it if you use a plugin manager that doesn't support hooks. + + +< Dependencies >______________________________________________________________~ + *fzf-vim-dependencies* + + - {fzf}{1} 0.23.0 or above + - For syntax-highlighted preview, install {bat}{5} + - If {delta}{6} is available, `GF?`, `Commits` and `BCommits` will use it to + format `git diff` output. + - `Ag` requires {The Silver Searcher (ag)}{7} + - `Rg` requires {ripgrep (rg)}{8} + - `Tags` and `Helptags` require Perl + + {1} https://github.com/junegunn/fzf + {5} https://github.com/sharkdp/bat + {6} https://github.com/dandavison/delta + {7} https://github.com/ggreer/the_silver_searcher + {8} https://github.com/BurntSushi/ripgrep + + +COMMANDS *fzf-vim-commands* +============================================================================== + + *:Files* *:GFiles* *:Buffers* *:Colors* *:Ag* *:Rg* *:Lines* *:BLines* *:Tags* *:BTags* *:Marks* + *:Windows* *:Locate* *:History* *:Snippets* *:Commits* *:BCommits* *:Commands* *:Maps* + *:Helptags* *:Filetypes* + + ------------------+----------------------------------------------------------------------- + Command | List ~ + ------------------+----------------------------------------------------------------------- + `:Files [PATH]` | Files (runs `$FZF_DEFAULT_COMMAND` if defined) + `:GFiles [OPTS]` | Git files ( `git ls-files` ) + `:GFiles?` | Git files ( `git status` ) + `:Buffers` | Open buffers + `:Colors` | Color schemes + `:Ag [PATTERN]` | {ag}{7} search result ( `ALT-A` to select all, `ALT-D` to deselect all) + `:Rg [PATTERN]` | {rg}{8} search result ( `ALT-A` to select all, `ALT-D` to deselect all) + `:Lines [QUERY]` | Lines in loaded buffers + `:BLines [QUERY]` | Lines in the current buffer + `:Tags [QUERY]` | Tags in the project ( `ctags -R` ) + `:BTags [QUERY]` | Tags in the current buffer + `:Marks` | Marks + `:Windows` | Windows + `:Locate PATTERN` | `locate` command output + `:History` | `v:oldfiles` and open buffers + `:History:` | Command history + `:History/` | Search history + `:Snippets` | Snippets ({UltiSnips}{9}) + `:Commits` | Git commits (requires {fugitive.vim}{10}) + `:BCommits` | Git commits for the current buffer; visual-select lines to track changes in the range + `:Commands` | Commands + `:Maps` | Normal mode mappings + `:Helptags` | Help tags [1] + `:Filetypes` | File types + ------------------+----------------------------------------------------------------------- + + *g:fzf_command_prefix* + + - Most commands support CTRL-T / CTRL-X / CTRL-V key bindings to open in a new + tab, a new split, or in a new vertical split + - Bang-versions of the commands (e.g. `Ag!`) will open fzf in fullscreen + - You can set `g:fzf_command_prefix` to give the same prefix to the commands + - e.g. `let g:fzf_command_prefix = 'Fzf'` and you have `FzfFiles`, etc. + +(1: `Helptags` will shadow the command of the same name from {pathogen}{11}. +But its functionality is still available via `call pathogen#helptags()`.) + + {7} https://github.com/ggreer/the_silver_searcher + {8} https://github.com/BurntSushi/ripgrep + {9} https://github.com/SirVer/ultisnips + {10} https://github.com/tpope/vim-fugitive + {11} https://github.com/tpope/vim-pathogen + + +CUSTOMIZATION *fzf-vim-customization* +============================================================================== + + +< Global options >____________________________________________________________~ + *fzf-vim-global-options* + +Every command in fzf.vim internally calls `fzf#wrap` function of the main +repository which supports a set of global option variables. So please read +through {README-VIM}{4} to learn more about them. + + {4} https://github.com/junegunn/fzf/blob/master/README-VIM.md + + +Preview window~ + *fzf-vim-preview-window* + + *g:fzf_preview_window* + +Some commands will show the preview window on the right. You can customize the +behavior with `g:fzf_preview_window`. Here are some examples: +> + " This is the default option: + " - Preview window on the right with 50% width + " - CTRL-/ will toggle preview window. + " - Note that this array is passed as arguments to fzf#vim#with_preview function. + " - To learn more about preview window options, see `--preview-window` section of `man fzf`. + let g:fzf_preview_window = ['right,50%', 'ctrl-/'] + + " Preview window is hidden by default. You can toggle it with ctrl-/. + " It will show on the right with 50% width, but if the width is smaller + " than 70 columns, it will show above the candidate list + let g:fzf_preview_window = ['hidden,right,50%,<70(up,40%)', 'ctrl-/'] + + " Empty value to disable preview window altogether + let g:fzf_preview_window = [] +< + +< Command-local options >_____________________________________________________~ + *fzf-vim-command-local-options* + +A few commands in fzf.vim can be customized with global option variables shown +below. + + *g:fzf_buffers_jump* *g:fzf_commits_log_options* *g:fzf_tags_command* + *g:fzf_commands_expect* +> + " [Buffers] Jump to the existing window if possible + let g:fzf_buffers_jump = 1 + + " [[B]Commits] Customize the options used by 'git log': + let g:fzf_commits_log_options = '--graph --color=always --format="%C(auto)%h%d %s %C(black)%C(bold)%cr"' + + " [Tags] Command to generate tags file + let g:fzf_tags_command = 'ctags -R' + + " [Commands] --expect expression for directly executing the command + let g:fzf_commands_expect = 'alt-enter,ctrl-x' +< + +< Advanced customization >____________________________________________________~ + *fzf-vim-advanced-customization* + + +Vim functions~ + *fzf-vim-vim-functions* + +Each command in fzf.vim is backed by a Vim function. You can override a +command or define a variation of it by calling its corresponding function. + + ----------+--------------------------------------------------------------------------- + Command | Vim function ~ + ----------+--------------------------------------------------------------------------- + `Files` | `fzf#vim#files(dir, [spec dict], [fullscreen bool])` + `GFiles` | `fzf#vim#gitfiles(git_options, [spec dict], [fullscreen bool])` + `GFiles?` | `fzf#vim#gitfiles('?', [spec dict], [fullscreen bool])` + `Buffers` | `fzf#vim#buffers([spec dict], [fullscreen bool])` + `Colors` | `fzf#vim#colors([spec dict], [fullscreen bool])` + `Rg` | `fzf#vim#grep(command, [has_column bool], [spec dict], [fullscreen bool])` + ... | ... + ----------+--------------------------------------------------------------------------- + +(We can see that the last two optional arguments of each function are +identical. They are directly passed to `fzf#wrap` function. If you haven't +read {README-VIM}{4} already, please read it before proceeding.) + + {4} https://github.com/junegunn/fzf/blob/master/README-VIM.md + + +Example: Customizing Files command~ + *fzf-vim-example-customizing-files-command* + +This is the default definition of `Files` command: +> + command! -bang -nargs=? -complete=dir Files call fzf#vim#files(, 0) +< +Let's say you want to a variation of it called `ProjectFiles` that only +searches inside `~/projects` directory. Then you can do it like this: +> + command! -bang ProjectFiles call fzf#vim#files('~/projects', 0) +< +Or, if you want to override the command with different fzf options, just pass +a custom spec to the function. +> + command! -bang -nargs=? -complete=dir Files + \ call fzf#vim#files(, {'options': ['--layout=reverse', '--info=inline']}, 0) +< +Want a preview window? +> + command! -bang -nargs=? -complete=dir Files + \ call fzf#vim#files(, {'options': ['--layout=reverse', '--info=inline', '--preview', 'cat {}']}, 0) +< +It kind of works, but you probably want a nicer previewer program than `cat`. +fzf.vim ships {a versatile preview script}{12} you can readily use. It +internally executes {bat}{5} for syntax highlighting, so make sure to install +it. +> + command! -bang -nargs=? -complete=dir Files + \ call fzf#vim#files(, {'options': ['--layout=reverse', '--info=inline', '--preview', '~/.vim/plugged/fzf.vim/bin/preview.sh {}']}, 0) +< +However, it's not ideal to hard-code the path to the script which can be +different in different circumstances. So in order to make it easier to set up +the previewer, fzf.vim provides `fzf#vim#with_preview` helper function. +Similarly to `fzf#wrap`, it takes a spec dictionary and returns a copy of it +with additional preview options. +> + command! -bang -nargs=? -complete=dir Files + \ call fzf#vim#files(, fzf#vim#with_preview({'options': ['--layout=reverse', '--info=inline']}), 0) +< +You can just omit the spec argument if you only want the previewer. +> + command! -bang -nargs=? -complete=dir Files + \ call fzf#vim#files(, fzf#vim#with_preview(), 0) +< + {12} bin/preview.sh + {5} https://github.com/sharkdp/bat + + +Example: git grep wrapper~ + *fzf-vim-example-git-grep-wrapper* + +The following example implements `GGrep` command that works similarly to +predefined `Ag` or `Rg` using `fzf#vim#grep`. + + - The second argument to `fzf#vim#grep` is 0 (false), because `git grep` does + not print column numbers. + - We set the base directory to git root by setting `dir` attribute in spec + dictionary. + - {The preview script}{12} supports `grep` format (`FILE_PATH:LINE_NO:...`), so + we can just wrap the spec with `fzf#vim#with_preview` as before to enable + previewer. +> + command! -bang -nargs=* GGrep + \ call fzf#vim#grep( + \ 'git grep --line-number -- '.shellescape(), 0, + \ fzf#vim#with_preview({'dir': systemlist('git rev-parse --show-toplevel')[0]}), 0) +< + {12} bin/preview.sh + + +Example: Rg command with preview window~ + *fzf-vim-example-rg-command-with-preview-window* + +You can see the definition of `Rg` command with `:command Rg`. With the +information, you can redefine it with the preview window enabled. In this +case, we're only interested in setting up the preview window, so we will omit +the spec argument to `fzf#vim#preview`. +> + command! -bang -nargs=* Rg + \ call fzf#vim#grep( + \ 'rg --column --line-number --no-heading --color=always --smart-case -- '.shellescape(), 1, + \ fzf#vim#with_preview(), 0) +< + +Example: Advanced ripgrep integration~ + *fzf-vim-example-advanced-ripgrep-integration* + +In the default implementation of `Rg`, ripgrep process starts only once with +the initial query (e.g. `:Rg foo`) and fzf filters the output of the process. + +This is okay in most cases because fzf is quite performant even with millions +of lines, but we can make fzf completely delegate its search responsibliity to +ripgrep process by making it restart ripgrep whenever the query string is +updated. In this scenario, fzf becomes a simple selector interface rather than +a "fuzzy finder". + + - We will name the new command all-uppercase `RG` so we can still access the + default version. + - `--bind 'change:reload:rg ... {q}'` will make fzf restart ripgrep process + whenever the query string, denoted by `{q}`, is changed. + - With `--phony` option, fzf will no longer perform search. The query string you + type on fzf prompt is only used for restarting ripgrep process. + - Also note that we enabled previewer with `fzf#vim#with_preview`. +> + function! RipgrepFzf(query, fullscreen) + let command_fmt = 'rg --column --line-number --no-heading --color=always --smart-case -- %s || true' + let initial_command = printf(command_fmt, shellescape(a:query)) + let reload_command = printf(command_fmt, '{q}') + let spec = {'options': ['--phony', '--query', a:query, '--bind', 'change:reload:'.reload_command]} + call fzf#vim#grep(initial_command, 1, fzf#vim#with_preview(spec), a:fullscreen) + endfunction + + command! -nargs=* -bang RG call RipgrepFzf(, 0) +< + +MAPPINGS *fzf-vim-mappings* +============================================================================== + + ---------------------------------+------------------------------------------ + Mapping | Description ~ + ---------------------------------+------------------------------------------ + (fzf-maps-n) | Normal mode mappings + (fzf-maps-i) | Insert mode mappings + (fzf-maps-x) | Visual mode mappings + (fzf-maps-o) | Operator-pending mappings + (fzf-complete-word) | `cat /usr/share/dict/words` + (fzf-complete-path) | Path completion using `find` (file + dir) + (fzf-complete-file) | File completion using `find` + (fzf-complete-line) | Line completion (all open buffers) + (fzf-complete-buffer-line) | Line completion (current buffer only) + ---------------------------------+------------------------------------------ +> + " Mapping selecting mappings + nmap (fzf-maps-n) + xmap (fzf-maps-x) + omap (fzf-maps-o) + + " Insert mode completion + imap (fzf-complete-word) + imap (fzf-complete-path) + imap (fzf-complete-line) +< + +COMPLETION FUNCTIONS *fzf-vim-completion-functions* +============================================================================== + + -----------------------------------------+-------------------------------------- + Function | Description ~ + -----------------------------------------+-------------------------------------- + `fzf#vim#complete#path(command, [spec])` | Path completion + `fzf#vim#complete#word([spec])` | Word completion + `fzf#vim#complete#line([spec])` | Line completion (all open buffers) + `fzf#vim#complete#buffer_line([spec])` | Line completion (current buffer only) + -----------------------------------------+-------------------------------------- +> + " Path completion with custom source command + inoremap fzf#vim#complete#path('fd') + inoremap fzf#vim#complete#path('rg --files') + + " Word completion with custom spec with popup layout option + inoremap fzf#vim#complete#word({'window': { 'width': 0.2, 'height': 0.9, 'xoffset': 1 }}) +< + +CUSTOM COMPLETION *fzf-vim-custom-completion* +============================================================================== + +`fzf#vim#complete` is a helper function for creating custom fuzzy completion +using fzf. If the first parameter is a command string or a Vim list, it will +be used as the source. +> + " Replace the default dictionary completion with fzf-based fuzzy completion + inoremap fzf#vim#complete('cat /usr/share/dict/words') +< +For advanced uses, you can pass an options dictionary to the function. The set +of options is pretty much identical to that for `fzf#run` only with the +following exceptions: + + - `reducer` (funcref) + - Reducer transforms the output lines of fzf into a single string value + - `prefix` (string or funcref; default: `\k*$`) + - Regular expression pattern to extract the completion prefix + - Or a function to extract completion prefix + - Both `source` and `options` can be given as funcrefs that take the completion + prefix as the argument and return the final value + - `sink` or `sink*` are ignored +> + " Global line completion (not just open buffers. ripgrep required.) + inoremap fzf#vim#complete(fzf#wrap({ + \ 'prefix': '^.*$', + \ 'source': 'rg -n ^ --color always', + \ 'options': '--ansi --delimiter : --nth 3..', + \ 'reducer': { lines -> join(split(lines[0], ':\zs')[2:], '') }})) +< + +< Reducer example >___________________________________________________________~ + *fzf-vim-reducer-example* +> + function! s:make_sentence(lines) + return substitute(join(a:lines), '^.', '\=toupper(submatch(0))', '').'.' + endfunction + + inoremap fzf#vim#complete({ + \ 'source': 'cat /usr/share/dict/words', + \ 'reducer': function('make_sentence'), + \ 'options': '--multi --reverse --margin 15%,0', + \ 'left': 20}) +< + +STATUS LINE OF TERMINAL BUFFER *fzf-vim-status-line-of-terminal-buffer* +============================================================================== + +When fzf starts in a terminal buffer (see {fzf/README-VIM.md}{13}), you may +want to customize the statusline of the containing buffer. + +{13} https://github.com/junegunn/fzf/blob/master/README-VIM.md#fzf-inside-terminal-buffer + + +< Hide statusline >___________________________________________________________~ + *fzf-vim-hide-statusline* +> + autocmd! FileType fzf set laststatus=0 noshowmode noruler + \| autocmd BufLeave set laststatus=2 showmode ruler +< + +< Custom statusline >_________________________________________________________~ + *fzf-vim-custom-statusline* +> + function! s:fzf_statusline() + " Override statusline as you like + highlight fzf1 ctermfg=161 ctermbg=251 + highlight fzf2 ctermfg=23 ctermbg=251 + highlight fzf3 ctermfg=237 ctermbg=251 + setlocal statusline=%#fzf1#\ >\ %#fzf2#fz%#fzf3#f + endfunction + + autocmd! User FzfStatusLine call fzf_statusline() +< + +LICENSE *fzf-vim-license* +============================================================================== + +MIT + + +============================================================================== +vim:tw=78:sw=2:ts=2:ft=help:norl:nowrap: diff --git a/dotfiles/.vim/plugged/fzf.vim/plugin/fzf.vim b/dotfiles/.vim/plugged/fzf.vim/plugin/fzf.vim new file mode 100644 index 00000000..f7ae7d11 --- /dev/null +++ b/dotfiles/.vim/plugged/fzf.vim/plugin/fzf.vim @@ -0,0 +1,154 @@ +" Copyright (c) 2015 Junegunn Choi +" +" MIT License +" +" Permission is hereby granted, free of charge, to any person obtaining +" a copy of this software and associated documentation files (the +" "Software"), to deal in the Software without restriction, including +" without limitation the rights to use, copy, modify, merge, publish, +" distribute, sublicense, and/or sell copies of the Software, and to +" permit persons to whom the Software is furnished to do so, subject to +" the following conditions: +" +" The above copyright notice and this permission notice shall be +" included in all copies or substantial portions of the Software. +" +" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +" EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +" NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +" LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +" OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +" WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +if exists('g:loaded_fzf_vim') + finish +endif +let g:loaded_fzf_vim = 1 + +let s:cpo_save = &cpo +set cpo&vim +let s:is_win = has('win32') || has('win64') + +function! s:defs(commands) + let prefix = get(g:, 'fzf_command_prefix', '') + if prefix =~# '^[^A-Z]' + echoerr 'g:fzf_command_prefix must start with an uppercase letter' + return + endif + for command in a:commands + let name = ':'.prefix.matchstr(command, '\C[A-Z]\S\+') + if 2 != exists(name) + execute substitute(command, '\ze\C[A-Z]', prefix, '') + endif + endfor +endfunction + +call s:defs([ +\'command! -bang -nargs=? -complete=dir Files call fzf#vim#files(, fzf#vim#with_preview(), 0)', +\'command! -bang -nargs=? GitFiles call fzf#vim#gitfiles(, fzf#vim#with_preview( == "?" ? { "placeholder": "" } : {}), 0)', +\'command! -bang -nargs=? GFiles call fzf#vim#gitfiles(, fzf#vim#with_preview( == "?" ? { "placeholder": "" } : {}), 0)', +\'command! -bar -bang -nargs=? -complete=buffer Buffers call fzf#vim#buffers(, fzf#vim#with_preview({ "placeholder": "{1}" }), 0)', +\'command! -bang -nargs=* Lines call fzf#vim#lines(, 0)', +\'command! -bang -nargs=* BLines call fzf#vim#buffer_lines(, 0)', +\'command! -bar -bang Colors call fzf#vim#colors(0)', +\'command! -bang -nargs=+ -complete=dir Locate call fzf#vim#locate(, fzf#vim#with_preview(), 0)', +\'command! -bang -nargs=* Ag call fzf#vim#ag(, fzf#vim#with_preview(), 0)', +\'command! -bang -nargs=* Rg call fzf#vim#grep("rg --column --line-number --no-heading --color=always --smart-case -- ".shellescape(), 1, fzf#vim#with_preview(), 0)', +\'command! -bang -nargs=* Tags call fzf#vim#tags(, fzf#vim#with_preview({ "placeholder": "--tag {2}:{-1}:{3..}" }), 0)', +\'command! -bang -nargs=* BTags call fzf#vim#buffer_tags(, fzf#vim#with_preview({ "placeholder": "{2}:{3..}" }), 0)', +\'command! -bar -bang Snippets call fzf#vim#snippets(0)', +\'command! -bar -bang Commands call fzf#vim#commands(0)', +\'command! -bar -bang Marks call fzf#vim#marks(0)', +\'command! -bar -bang Helptags call fzf#vim#helptags(fzf#vim#with_preview({ "placeholder": "--tag {2}:{3}:{4}" }), 0)', +\'command! -bar -bang Windows call fzf#vim#windows(0)', +\'command! -bar -bang -range=% Commits let b:fzf_winview = winsaveview() | ,call fzf#vim#commits(fzf#vim#with_preview({ "placeholder": "" }), 0)', +\'command! -bar -bang -range=% BCommits let b:fzf_winview = winsaveview() | ,call fzf#vim#buffer_commits(fzf#vim#with_preview({ "placeholder": "" }), 0)', +\'command! -bar -bang Maps call fzf#vim#maps("n", 0)', +\'command! -bar -bang Filetypes call fzf#vim#filetypes(0)', +\'command! -bang -nargs=* History call s:history(, fzf#vim#with_preview(), 0)']) + +function! s:history(arg, extra, bang) + let bang = a:bang || a:arg[len(a:arg)-1] == '!' + if a:arg[0] == ':' + call fzf#vim#command_history(bang) + elseif a:arg[0] == '/' + call fzf#vim#search_history(bang) + else + call fzf#vim#history(a:extra, bang) + endif +endfunction + +function! fzf#complete(...) + return call('fzf#vim#complete', a:000) +endfunction + +if (has('nvim') || has('terminal') && has('patch-8.0.995')) && (get(g:, 'fzf_statusline', 1) || get(g:, 'fzf_nvim_statusline', 1)) + function! s:fzf_restore_colors() + if exists('#User#FzfStatusLine') + doautocmd User FzfStatusLine + else + if $TERM !~ "256color" + highlight default fzf1 ctermfg=1 ctermbg=8 guifg=#E12672 guibg=#565656 + highlight default fzf2 ctermfg=2 ctermbg=8 guifg=#BCDDBD guibg=#565656 + highlight default fzf3 ctermfg=7 ctermbg=8 guifg=#D9D9D9 guibg=#565656 + else + highlight default fzf1 ctermfg=161 ctermbg=238 guifg=#E12672 guibg=#565656 + highlight default fzf2 ctermfg=151 ctermbg=238 guifg=#BCDDBD guibg=#565656 + highlight default fzf3 ctermfg=252 ctermbg=238 guifg=#D9D9D9 guibg=#565656 + endif + setlocal statusline=%#fzf1#\ >\ %#fzf2#fz%#fzf3#f + endif + endfunction + + function! s:fzf_vim_term() + if get(w:, 'airline_active', 0) + let w:airline_disabled = 1 + autocmd BufWinLeave let w:airline_disabled = 0 + endif + autocmd WinEnter,ColorScheme call s:fzf_restore_colors() + + setlocal nospell + call s:fzf_restore_colors() + endfunction + + augroup _fzf_statusline + autocmd! + autocmd FileType fzf call s:fzf_vim_term() + augroup END +endif + +if !exists('g:fzf#vim#buffers') + let g:fzf#vim#buffers = {} +endif + +augroup fzf_buffers + autocmd! + if exists('*reltimefloat') + autocmd BufWinEnter,WinEnter * let g:fzf#vim#buffers[bufnr('')] = reltimefloat(reltime()) + else + autocmd BufWinEnter,WinEnter * let g:fzf#vim#buffers[bufnr('')] = localtime() + endif + autocmd BufDelete * silent! call remove(g:fzf#vim#buffers, expand('')) +augroup END + +inoremap (fzf-complete-word) fzf#vim#complete#word() +if s:is_win + inoremap (fzf-complete-path) fzf#vim#complete#path('dir /s/b') + inoremap (fzf-complete-file) fzf#vim#complete#path('dir /s/b/a:-d') +else + inoremap (fzf-complete-path) fzf#vim#complete#path("find . -path '*/\.*' -prune -o -print \| sed '1d;s:^..::'") + inoremap (fzf-complete-file) fzf#vim#complete#path("find . -path '*/\.*' -prune -o -type f -print -o -type l -print \| sed 's:^..::'") +endif +inoremap (fzf-complete-file-ag) fzf#vim#complete#path('ag -l -g ""') +inoremap (fzf-complete-line) fzf#vim#complete#line() +inoremap (fzf-complete-buffer-line) fzf#vim#complete#buffer_line() + +nnoremap (fzf-maps-n) :call fzf#vim#maps('n', 0) +inoremap (fzf-maps-i) :call fzf#vim#maps('i', 0) +xnoremap (fzf-maps-x) :call fzf#vim#maps('x', 0) +onoremap (fzf-maps-o) :call fzf#vim#maps('o', 0) + +let &cpo = s:cpo_save +unlet s:cpo_save +