-
Notifications
You must be signed in to change notification settings - Fork 7
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Initial commit, including older stuff.
- Loading branch information
0 parents
commit 559e11b
Showing
178 changed files
with
57,855 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Original file line | Diff line number | Diff line change |
---|---|---|---|
@@ -0,0 +1,132 @@ | |||
" pathogen.vim - path option manipulation | |||
" Maintainer: Tim Pope <vimNOSPAM@tpope.org> | |||
" Version: 1.2 | |||
|
|||
" Install in ~/.vim/autoload (or ~\vimfiles\autoload). | |||
" | |||
" API is documented below. | |||
|
|||
if exists("g:loaded_pathogen") || &cp | |||
finish | |||
endif | |||
let g:loaded_pathogen = 1 | |||
|
|||
" Split a path into a list. | |||
function! pathogen#split(path) abort " {{{1 | |||
if type(a:path) == type([]) | return a:path | endif | |||
let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,') | |||
return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")') | |||
endfunction " }}}1 | |||
|
|||
" Convert a list to a path. | |||
function! pathogen#join(...) abort " {{{1 | |||
if type(a:1) == type(1) && a:1 | |||
let i = 1 | |||
let space = ' ' | |||
else | |||
let i = 0 | |||
let space = '' | |||
endif | |||
let path = "" | |||
while i < a:0 | |||
if type(a:000[i]) == type([]) | |||
let list = a:000[i] | |||
let j = 0 | |||
while j < len(list) | |||
let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g') | |||
let path .= ',' . escaped | |||
let j += 1 | |||
endwhile | |||
else | |||
let path .= "," . a:000[i] | |||
endif | |||
let i += 1 | |||
endwhile | |||
return substitute(path,'^,','','') | |||
endfunction " }}}1 | |||
|
|||
" Convert a list to a path with escaped spaces for 'path', 'tag', etc. | |||
function! pathogen#legacyjoin(...) abort " {{{1 | |||
return call('pathogen#join',[1] + a:000) | |||
endfunction " }}}1 | |||
|
|||
" Remove duplicates from a list. | |||
function! pathogen#uniq(list) abort " {{{1 | |||
let i = 0 | |||
let seen = {} | |||
while i < len(a:list) | |||
if has_key(seen,a:list[i]) | |||
call remove(a:list,i) | |||
else | |||
let seen[a:list[i]] = 1 | |||
let i += 1 | |||
endif | |||
endwhile | |||
return a:list | |||
endfunction " }}}1 | |||
|
|||
" \ on Windows unless shellslash is set, / everywhere else. | |||
function! pathogen#separator() abort " {{{1 | |||
return !exists("+shellslash") || &shellslash ? '/' : '\' | |||
endfunction " }}}1 | |||
|
|||
" Convenience wrapper around glob() which returns a list. | |||
function! pathogen#glob(pattern) abort " {{{1 | |||
let files = split(glob(a:pattern),"\n") | |||
return map(files,'substitute(v:val,"[".pathogen#separator()."/]$","","")') | |||
endfunction "}}}1 | |||
|
|||
" Like pathogen#glob(), only limit the results to directories. | |||
function! pathogen#glob_directories(pattern) abort " {{{1 | |||
return filter(pathogen#glob(a:pattern),'isdirectory(v:val)') | |||
endfunction "}}}1 | |||
|
|||
" Prepend all subdirectories of path to the rtp, and append all after | |||
" directories in those subdirectories. | |||
function! pathogen#runtime_prepend_subdirectories(path) " {{{1 | |||
let sep = pathogen#separator() | |||
let before = pathogen#glob_directories(a:path.sep."*[^~]") | |||
let after = pathogen#glob_directories(a:path.sep."*[^~]".sep."after") | |||
let rtp = pathogen#split(&rtp) | |||
let path = expand(a:path) | |||
call filter(rtp,'v:val[0:strlen(path)-1] !=# path') | |||
let &rtp = pathogen#join(pathogen#uniq(before + rtp + after)) | |||
return &rtp | |||
endfunction " }}}1 | |||
|
|||
" For each directory in rtp, check for a subdirectory named dir. If it | |||
" exists, add all subdirectories of that subdirectory to the rtp, immediately | |||
" after the original directory. If no argument is given, 'bundle' is used. | |||
" Repeated calls with the same arguments are ignored. | |||
function! pathogen#runtime_append_all_bundles(...) " {{{1 | |||
let sep = pathogen#separator() | |||
let name = a:0 ? a:1 : 'bundle' | |||
if "\n".s:done_bundles =~# "\\M\n".name."\n" | |||
return "" | |||
endif | |||
let s:done_bundles .= name . "\n" | |||
let list = [] | |||
for dir in pathogen#split(&rtp) | |||
if dir =~# '\<after$' | |||
let list += pathogen#glob_directories(substitute(dir,'after$',name.sep.'*[^~]'.sep.'after','')) + [dir] | |||
else | |||
let list += [dir] + pathogen#glob_directories(dir.sep.name.sep.'*[^~]') | |||
endif | |||
endfor | |||
let &rtp = pathogen#join(pathogen#uniq(list)) | |||
return 1 | |||
endfunction | |||
|
|||
let s:done_bundles = '' | |||
" }}}1 | |||
|
|||
" Invoke :helptags on all non-$VIM doc directories in runtimepath. | |||
function! pathogen#helptags() " {{{1 | |||
for dir in pathogen#split(&rtp) | |||
if dir[0 : strlen($VIM)-1] !=# $VIM && isdirectory(dir.'/doc') && (!filereadable(dir.'/doc/tags') || filewritable(dir.'/doc/tags')) | |||
helptags `=dir.'/doc'` | |||
endif | |||
endfor | |||
endfunction " }}}1 | |||
|
|||
" vim:set ft=vim ts=8 sw=2 sts=2: |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Original file line | Diff line number | Diff line change |
---|---|---|---|
@@ -0,0 +1,42 @@ | |||
*ack.txt* Plugin that integrates ack with Vim | |||
|
|||
============================================================================== | |||
Author: Antoine Imbert <antoine.imbert+ackvim@gmail.com> *ack-author* | |||
License: Same terms as Vim itself (see |license|) | |||
|
|||
============================================================================== | |||
INTRODUCTION *ack* | |||
|
|||
This plugin is a front for the Perl module App::Ack. Ack can be used as a | |||
replacement for grep. This plugin will allow you to run ack from vim, and | |||
shows the results in a split window. | |||
|
|||
:Ack [options] {pattern} [{directory}] *:Ack* | |||
|
|||
Search recursively in {directory} (which defaults to the current | |||
directory) for the {pattern}. Behaves just like the |:grep| command, but | |||
will open the |Quickfix| window for you. | |||
|
|||
:AckAdd [options] {pattern} [{directory}] *:AckAdd* | |||
|
|||
Just like |:Ack| + |:grepadd|. Appends the |quickfix| with the results | |||
|
|||
:AckFromSearch [{directory}] *:AckFromSearch* | |||
|
|||
Just like |:Ack| but the pattern is from previous search. | |||
|
|||
:LAck [options] {pattern} [{directory}] *:LAck* | |||
|
|||
Just like |:Ack| + |:lgrep|. Searches, but opens in |location-list| | |||
|
|||
:LAckAdd [options] {pattern} [{directory}] *:LAckAdd* | |||
|
|||
Just like |:Ack| + |:lgrepadd|. Searches, but appends results to | |||
|location-list| | |||
|
|||
Files containing the search term will be listed in the split window, along | |||
with the line number of the occurrence, once for each occurrence. <Enter> on | |||
a line in this window will open the file, and place the cursor on the matching | |||
line. | |||
|
|||
See http://search.cpan.org/~petdance/ack/ack for more information. |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Original file line | Diff line number | Diff line change |
---|---|---|---|
@@ -0,0 +1,8 @@ | |||
:Ack ack.txt /*:Ack* | |||
:AckAdd ack.txt /*:AckAdd* | |||
:AckFromSearch ack.txt /*:AckFromSearch* | |||
:LAck ack.txt /*:LAck* | |||
:LAckAdd ack.txt /*:LAckAdd* | |||
ack ack.txt /*ack* | |||
ack-author ack.txt /*ack-author* | |||
ack.txt ack.txt /*ack.txt* |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Original file line | Diff line number | Diff line change |
---|---|---|---|
@@ -0,0 +1,42 @@ | |||
" NOTE: You must, of course, install the ack script | |||
" in your path. | |||
" On Ubuntu: | |||
" sudo apt-get install ack-grep | |||
" ln -s /usr/bin/ack-grep /usr/bin/ack | |||
" With MacPorts: | |||
" sudo port install p5-app-ack | |||
|
|||
let g:ackprg="ack -H --nocolor --nogroup" | |||
|
|||
function! s:Ack(cmd, args) | |||
redraw | |||
echo "Searching ..." | |||
|
|||
let grepprg_bak=&grepprg | |||
try | |||
let &grepprg=g:ackprg | |||
silent execute a:cmd . " " . a:args | |||
finally | |||
let &grepprg=grepprg_bak | |||
endtry | |||
|
|||
if a:cmd =~# '^l' | |||
botright lopen | |||
else | |||
botright copen | |||
endif | |||
redraw! | |||
endfunction | |||
|
|||
function! s:AckFromSearch(cmd, args) | |||
let search = getreg('/') | |||
" translate vim regular expression to perl regular expression. | |||
let search = substitute(search,'\(\\<\|\\>\)','\\b','g') | |||
call s:Ack(a:cmd, '"' . search .'" '. a:args) | |||
endfunction | |||
|
|||
command! -bang -nargs=* -complete=file Ack call s:Ack('grep<bang>',<q-args>) | |||
command! -bang -nargs=* -complete=file AckAdd call s:Ack('grepadd<bang>', <q-args>) | |||
command! -bang -nargs=* -complete=file AckFromSearch call s:AckFromSearch('grep<bang>', <q-args>) | |||
command! -bang -nargs=* -complete=file LAck call s:Ack('lgrep<bang>', <q-args>) | |||
command! -bang -nargs=* -complete=file LAckAdd call s:Ack('lgrepadd<bang>', <q-args>) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Original file line | Diff line number | Diff line change |
---|---|---|---|
@@ -0,0 +1,132 @@ | |||
" endwise.vim - EndWise | |||
" Author: Tim Pope <vimNOSPAM@tpope.info> | |||
" Version: 1.0 | |||
|
|||
" Distributable under the same terms as Vim itself (see :help license) | |||
|
|||
" Exit quickly when: | |||
" - this plugin was already loaded (or disabled) | |||
" - when 'compatible' is set | |||
if (exists("g:loaded_endwise") && g:loaded_endwise) || &cp | |||
finish | |||
endif | |||
let g:loaded_endwise = 1 | |||
|
|||
|
|||
let s:cpo_save = &cpo | |||
set cpo&vim | |||
|
|||
augroup endwise " {{{1 | |||
au! | |||
autocmd FileType ruby | |||
\ let b:endwise_addition = '\=submatch(0)=="{" ? "}" : "end"' | | |||
\ let b:endwise_words = 'module,class,def,if,unless,case,while,until,begin,do' | | |||
\ let b:endwise_pattern = '^\s*\zs\%(module\|class\|def\|if\|unless\|case\|while\|until\|for\|\|begin\)\>\%(.*[^.:@$]\<end\>\)\@!\|\<do\ze\%(\s*|.*|\)\=\s*$' | | |||
\ let b:endwise_syngroups = 'rubyModule,rubyClass,rubyDefine,rubyControl,rubyConditional,rubyRepeat' | |||
autocmd FileType vb,vbnet,aspvbs | |||
\ let b:endwise_addition = 'End &' | | |||
\ let b:endwise_words = 'Function,Sub,Class,Module,Enum,Namespace' | | |||
\ let b:endwise_pattern = '\%(\<End\>.*\)\@<!\<&\>' | | |||
\ let b:endwise_syngroups = 'vbStatement,vbnetStorage,vbnetProcedure,vbnet.*Words,AspVBSStatement' | |||
autocmd FileType vim | |||
\ let b:endwise_addition = 'end&' | | |||
\ let b:endwise_words = 'fu\%[nction],wh\%[ile],if,for,try' | | |||
\ let b:endwise_syngroups = 'vimFuncKey,vimNotFunc,vimCommand' | |||
augroup END " }}}1 | |||
|
|||
" Maps {{{1 | |||
|
|||
|
|||
if maparg("<Plug>DiscretionaryEnd") == "" | |||
inoremap <silent> <SID>DiscretionaryEnd <C-R>=<SID>crend(0)<CR> | |||
inoremap <silent> <SID>AlwaysEnd <C-R>=<SID>crend(1)<CR> | |||
imap <script> <Plug>DiscretionaryEnd <SID>DiscretionaryEnd | |||
imap <script> <Plug>AlwaysEnd <SID>AlwaysEnd | |||
endif | |||
if maparg('<CR>','i') =~# '<C-R>=.*crend(.)<CR>\|<\%(Plug\|SID\)>.*End' | |||
" Already mapped | |||
elseif maparg('<CR>','i') =~ '<CR>' | |||
exe "imap <script> <C-X><CR> ".maparg('<CR>','i')."<SID>AlwaysEnd" | |||
exe "imap <script> <CR> ".maparg('<CR>','i')."<SID>DiscretionaryEnd" | |||
else | |||
imap <C-X><CR> <CR><Plug>AlwaysEnd | |||
imap <CR> <CR><Plug>DiscretionaryEnd | |||
endif | |||
|
|||
if maparg('<M-o>','i') == '' | |||
inoremap <M-o> <C-O>o | |||
endif | |||
|
|||
" }}}1 | |||
|
|||
" Code {{{1 | |||
|
|||
function! s:mysearchpair(beginpat,endpat,synpat) | |||
let g:endwise_syntaxes = "" | |||
let s:lastline = line('.') | |||
call s:synname() | |||
let line = searchpair(a:beginpat,'',a:endpat,'Wn','<SID>synname() !~# "^'.substitute(a:synpat,'\\','\\\\','g').'$"',line('.')+50) | |||
return line | |||
endfunction | |||
|
|||
function! s:crend(always) | |||
let n = "" | |||
if !exists("b:endwise_addition") || !exists("b:endwise_words") || !exists("b:endwise_syngroups") | |||
return n | |||
end | |||
let synpat = '\%('.substitute(b:endwise_syngroups,',','\\|','g').'\)' | |||
let wordchoice = '\%('.substitute(b:endwise_words,',','\\|','g').'\)' | |||
if exists("b:endwise_pattern") | |||
let beginpat = substitute(b:endwise_pattern,'&',substitute(wordchoice,'\\','\\&','g'),'g') | |||
else | |||
let beginpat = '\<'.wordchoice.'\>' | |||
endif | |||
let lnum = line('.') - 1 | |||
let space = matchstr(getline(lnum),'^\s*') | |||
let col = match(getline(lnum),beginpat) + 1 | |||
let word = matchstr(getline(lnum),beginpat) | |||
let endpat = substitute(word,'.*',b:endwise_addition,'') | |||
let y = n.endpat."\<C-O>O" | |||
let endpat = '\<'.substitute(wordchoice,'.*',b:endwise_addition,'').'\>' | |||
if a:always | |||
return y | |||
elseif col <= 0 || synIDattr(synID(lnum,col,1),'name') !~ '^'.synpat.'$' | |||
return n | |||
elseif getline('.') !~ '^\s*#\=$' | |||
return n | |||
endif | |||
let line = s:mysearchpair(beginpat,endpat,synpat) | |||
" even is false if no end was found, or if the end found was less | |||
" indented than the current line | |||
let even = strlen(matchstr(getline(line),'^\s*')) >= strlen(space) | |||
if line == 0 | |||
let even = 0 | |||
endif | |||
let g:endwise_debug = line . "(" . even . ")" | |||
if !even && line == line('.') + 1 | |||
return y | |||
endif | |||
if even | |||
return n | |||
endif | |||
return y | |||
endfunction | |||
|
|||
function! s:synname() | |||
" Checking this helps to force things to stay in sync | |||
while s:lastline < line('.') | |||
let s = synIDattr(synID(s:lastline,indent(s:lastline)+1,1),'name') | |||
let s:lastline = nextnonblank(s:lastline + 1) | |||
endwhile | |||
|
|||
let s = synIDattr(synID(line('.'),col('.'),1),'name') | |||
let g:endwise_syntaxes = g:endwise_syntaxes . line('.').','.col('.')."=".s."\n" | |||
let s:lastline = line('.') | |||
return s | |||
endfunction | |||
|
|||
" }}}1 | |||
|
|||
let &cpo = s:cpo_save | |||
|
|||
" vim:set ft=vim ff=unix ts=8 sw=4 sts=4: |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Original file line | Diff line number | Diff line change |
---|---|---|---|
@@ -0,0 +1,5 @@ | |||
Quickly install with: | |||
|
|||
git clone git://github.com/msanders/snipmate.vim.git | |||
cd snipmate.vim | |||
cp -R * ~/.vim |
Oops, something went wrong.