Created Examples - Vim (markdown)

Examples---Vim.md

@@ -0,0 +1,183 @@
+### `locate` command integration
+
+```vim
+command! -nargs=1 Locate call fzf#run(
+      \ {'source': 'locate <q-args>', 'sink': 'e', 'options': '-m'})
+```
+
+`:Locate /` will list every file on the system. So make sure that you're using Go version of fzf which is significantly faster than the old Ruby version.
+
+### Open files in splits
+
+```vim
+" Open files in horizontal split
+nnoremap <silent> <Leader>s :call fzf#run({
+\   'tmux_height': '40%',
+\   'sink':        'botright split' })<CR>
+
+" Open files in vertical horizontal split
+nnoremap <silent> <Leader>v :call fzf#run({
+\   'tmux_width': winwidth('.') / 2,
+\   'sink':       'vertical botright split' })<CR>
+```
+
+### Choose color scheme
+
+```vim
+nnoremap <silent> <Leader>C :call fzf#run({
+\   'source':
+\     map(split(globpath(&rtp, "colors/*.vim"), "\n"),
+\         "substitute(fnamemodify(v:val, ':t'), '\\..\\{-}$', '', '')"),
+\   'sink':       'colo',
+\   'options':    '+m',
+\   'tmux_width': 20
+\ })<CR>
+```
+
+### Select buffer
+
+```vim
+function! s:buflist()
+  redir => ls
+  silent ls
+  redir END
+  return split(ls, '\n')
+endfunction
+
+function! s:bufopen(e)
+  execute 'buffer' matchstr(a:e, '^[ 0-9]*')
+endfunction
+
+nnoremap <silent> <Leader><Enter> :call fzf#run({
+\   'source':      reverse(<sid>buflist()),
+\   'sink':        function('<sid>bufopen'),
+\   'options':     '+m',
+\   'tmux_height': '40%'
+\ })<CR>
+```
+
+### Simple MRU search
+
+```vim
+command! FZFMru call fzf#run({
+            \'source': v:oldfiles,
+            \'sink' : 'e ',
+            \'options' : '-m',
+            \})
+```
+
+### Jump to tags (@atn34)
+
+```vimL
+function! TagCommand()
+  return substitute('awk _!/^!/ { print \$1 }_ ', '_', "'", 'g')
+              \ . join(tagfiles(), ' ')
+endfunction
+
+command! FZFTag call fzf#run({
+\   'source'     : TagCommand(),
+\   'sink'       : 'tag',
+\   })
+```
+
+### Search lines in all open vim buffers
+
+```vimL
+function! s:line_handler(l)
+  let keys = split(a:l, ':\t')
+  exec 'buf ' . keys[0]
+  exec keys[1]
+  normal! ^zz
+endfunction
+
+function! s:buffer_lines()
+  let res = []
+  for b in filter(range(1, bufnr('$')), 'buflisted(v:val)')
+    call extend(res, map(getbufline(b,0,"$"), 'b . ":\t" . (v:key + 1) . ":\t" . v:val '))
+  endfor
+  return res
+endfunction
+
+command! FZFLines call fzf#run({
+\   'source':  <sid>buffer_lines(),
+\   'sink':    function('<sid>line_handler'),
+\   'options': '--extended --nth=3..',
+\   'tmux_height': '60%'
+\})
+```
+
+### Narrow ag results within vim
+
+Add this to your .vimrc
+
+```vimL
+command! -nargs=1 AgFZF call fzf#run({
+            \'source': Arghandler(<f-args>),
+            \'sink' : function('AgHandler'),
+            \'options' : '-m'
+            \})
+
+function! AgHandler(l)
+    let keys = split(a:l,':')
+    execute 'tabe +' . keys[-2] . ' ' . escape(keys[-1], ' ')
+endfunction 
+
+function! Arghandler(l)
+    return "ag -i " . a:l . " | sed 's@\\(.[^:]*\\):\\(.[^:]*\\):\\(.*\\)@\\3:\\2:\\1@' "
+endfunction
+```
+
+Then use `:AgFZF` followed by an ag-recogizable regex to pipe ag results into fzf for narrowing. Selected results are opened in new tabs so that you can open multiple positions within the same file (perhaps there's a better way of doing this).
+
+
+### Fuzzy cmdline completion
+
+```vimL
+cnoremap <silent> <c-l> <c-\>eGetCompletions()<cr>
+"add an extra <cr> at the end of this line to automatically accept the fzf-selected completions.
+
+function! Lister()
+    call extend(g:FZF_Cmd_Completion_Pre_List,split(getcmdline(),'\(\\\zs\)\@<!\& '))
+endfunction
+
+function! CmdLineDirComplete(prefix, options, rawdir)
+    let l:dirprefix = matchstr(a:rawdir,"^.*/")
+    if isdirectory(expand(l:dirprefix))
+        return join(a:prefix + map(fzf#run({
+                    \'options': a:options . ' --select-1  --query=' .
+                    \ a:rawdir[matchend(a:rawdir,"^.*/"):len(a:rawdir)], 
+                    \'dir': expand(l:dirprefix)
+                    \}), 
+                    \'"' . escape(l:dirprefix, " ") . '" . escape(v:val, " ")'))
+    else
+        return join(a:prefix + map(fzf#run({
+                    \'options': a:options . ' --query='. a:rawdir }),
+                    \'escape(v:val, " ")')) 
+        "dropped --select-1 to speed things up on a long query
+endfunction
+
+function! GetCompletions()
+    let g:FZF_Cmd_Completion_Pre_List = []
+    let l:cmdline_list = split(getcmdline(), '\(\\\zs\)\@<!\& ', 1)
+    let l:Prefix = l:cmdline_list[0:-2]
+    execute "silent normal! :" . getcmdline() . "\<c-a>\<c-\>eLister()\<cr>\<c-c>"
+    let l:FZF_Cmd_Completion_List = g:FZF_Cmd_Completion_Pre_List[len(l:Prefix):-1]
+    unlet g:FZF_Cmd_Completion_Pre_List
+    if len(l:Prefix) > 0 && l:Prefix[0] =~
+                \ '^ed\=i\=t\=$\|^spl\=i\=t\=$\|^tabed\=i\=t\=$\|^arged\=i\=t\=$\|^vsp\=l\=i\=t\=$'
+                "single-argument file commands
+        return CmdLineDirComplete(l:Prefix, "",l:cmdline_list[-1])
+    elseif len(l:Prefix) > 0 && l:Prefix[0] =~ 
+                \ '^arg\=s\=$\|^ne\=x\=t\=$\|^sne\=x\=t\=$\|^argad\=d\=$'  
+                "multi-argument file commands
+        return CmdLineDirComplete(l:Prefix, '--multi', l:cmdline_list[-1])
+    else 
+        return join(l:Prefix + fzf#run({
+                    \'source':l:FZF_Cmd_Completion_List, 
+                    \'options': '--select-1 --query='.shellescape(l:cmdline_list[-1])
+                    \})) 
+    endif
+endfunction
+```
+
+hit `<c-l>` while in the ex commandline (i.e. after pressing `:`) to have fzf filter a list of vim's commandline auto-completions. Try `:colo␣<c-l>` (be sure to include the space) or `:b␣<c-l>`. There are special cases for handling file-searches, so that you can go deeper into the path than just one directory at a time, and so that you can add multiple files to the arglist at once. More special cases could be added. Some limitations: the auto-complete for `:help` and `:tag` are limited to 300 entries, so you may need to narrow it a bit.