removed bundles and bash magic, start on install script
This commit is contained in:
Submodule bash/bash_magic deleted from c289364fbe
50
install.sh
Normal file → Executable file
50
install.sh
Normal file → Executable file
@@ -1,3 +1,53 @@
|
||||
#!/bin/bash
|
||||
|
||||
#configure vim bundles
|
||||
VIM_BUNDLES=(
|
||||
'https://github.com/vim-scripts/phpfolding.vim.git'
|
||||
'https://github.com/msanders/snipmate.vim.git'
|
||||
'https://github.com/scrooloose/syntastic.git'
|
||||
'https://github.com/kchmck/vim-coffee-script.git'
|
||||
'https://github.com/altercation/vim-colors-solarized.git'
|
||||
'https://github.com/digitaltoad/vim-jade.git'
|
||||
'https://github.com/wavded/vim-stylus.git'
|
||||
'https://github.com/tpope/vim-surround.git'
|
||||
)
|
||||
|
||||
#check for git
|
||||
GIT=$(which git)
|
||||
if [ ! $? == 0 ]; then
|
||||
echo "You must install git and add it to you PATH"
|
||||
exit 1
|
||||
fi
|
||||
ROOT=`pwd`
|
||||
|
||||
###
|
||||
# bash_magic
|
||||
###
|
||||
#clone repo
|
||||
$GIT clone https://github.com/Knewton/bash_magic.git bash/bash_magic
|
||||
|
||||
#install
|
||||
cd "bash/bash_magic"
|
||||
mkdir "${HOME}/.bash_aliases.d" "${HOME}/.bash_completion.d" "${HOME}/.bash_functions.d"
|
||||
cd "bash_aliases.d"
|
||||
ln -s color.sh refresh.sh "${HOME}/.bash_aliases.d"
|
||||
cd "../bash_completion.d"
|
||||
ln -s etc.sh "${HOME}/.bash_completion.d"
|
||||
cd "../bash_functions.d"
|
||||
ln -s completion.sh extract.sh lsbytes.sh lsnew.sh vim.sh "${HOME}/.bash_functions.d"
|
||||
cd "${ROOT}"
|
||||
|
||||
###
|
||||
# vim
|
||||
###
|
||||
#clone bundle repos
|
||||
cd "vim/bundle"
|
||||
for b in ${VIM_BUNDLES[@]}; do
|
||||
$GIT clone "${b}"
|
||||
done
|
||||
cd "${ROOT}"
|
||||
|
||||
#install
|
||||
|
||||
|
||||
echo "not finished, check back later"
|
||||
|
||||
@@ -1,65 +0,0 @@
|
||||
This is a mirror of http://www.vim.org/scripts/script.php?script_id=1623
|
||||
|
||||
This script can fold PHP functions and/or classes, properties with their PhpDoc,
|
||||
without manually adding marker style folds ({{{ and }}}). It will generate the following
|
||||
folds when executed:
|
||||
|
||||
<?php
|
||||
/**
|
||||
* This is Foo...
|
||||
* @author Foo
|
||||
*/
|
||||
class Foo {
|
||||
+-- 11 lines: function fooFunction($bar) ** -----------------------------------------
|
||||
+-- 8 lines: function fooFunction2($bar) ** ----------------------------------------
|
||||
+-- 24 lines: function fooFunction3($bar) -------------------------------------------
|
||||
}
|
||||
|
||||
+--112 lines: class Foo2 ** -------------------------------------------------------------
|
||||
?>
|
||||
|
||||
Based on e.g. functions declared like this:
|
||||
|
||||
<?php
|
||||
/**
|
||||
* This is fooFunction...
|
||||
*
|
||||
* @param mixed $bar
|
||||
* @access public
|
||||
* @return void
|
||||
*/
|
||||
function fooFunction($bar) {
|
||||
[...]
|
||||
}
|
||||
?>
|
||||
|
||||
SCREENSHOT
|
||||
You can view a screenshot here: http://www.fighterz.net/trig/folding.gif
|
||||
|
||||
FEATURES
|
||||
- It remembers fold settings. If you add functions and execute the script again,
|
||||
your opened folds will not be closed.
|
||||
- It will not be confused by brackets in comment blocks or string literals.
|
||||
- The folding of class properties with their PhpDoc comments.
|
||||
- The folding of all class properties into one fold.
|
||||
- Folding the original marker style folds too.
|
||||
- An "**" postfixing the fold indicates PhpDoc is inside (configurable).
|
||||
- An "**#@+" postfixing the fold indicates PhpDocBlock is inside (configurable).
|
||||
- Empty lines postfixing the folds can be configured to be included in the fold.
|
||||
- Nested folds are supported (functions inside functions, etc.)
|
||||
|
||||
FUTURE
|
||||
- Better 'configurability' as opposed to editting the PHPCustomFolds() function and
|
||||
some "Script configuration" global variables.
|
||||
|
||||
NOTE
|
||||
If anyone has emailed me and I have not replied, it's probably lost. I just found out
|
||||
hotmail recognizes alot as junk. I now turned off the junk filter..
|
||||
|
||||
NOTE2:
|
||||
I'm currently more active again with this project, so if you have any contributions to
|
||||
this project, please let me know.
|
||||
|
||||
COMPATIBILITY
|
||||
This script is tested successfully with Vim version >= 6.3 on windows and linux
|
||||
(With 6.0 it works *sometimes*, I don't recommend using it in that version)
|
||||
@@ -1,611 +0,0 @@
|
||||
" Plugin for automatic folding of PHP functions (also folds related PHPdoc)
|
||||
"
|
||||
" Maintainer: Ray Burgemeestre
|
||||
" Last Change: 2010 Jan 15
|
||||
"
|
||||
" USAGE
|
||||
" If you enabled the script in your after/ftplugin directory (see install)
|
||||
" then it will be executed after you open a .php file.
|
||||
"
|
||||
" After e.g. adding/moving functions, you can re-execute the script by using
|
||||
" the following key mappings:
|
||||
"
|
||||
" F5 - To fold functions, classes, and other stuff with PHPdoc (depending
|
||||
" on your configuration).
|
||||
" F6 - To do the same with more extensive bracket checking (might work
|
||||
" better if your folds are messed up due to misinterpreted brackets).
|
||||
" F7 - To remove all folds.
|
||||
"
|
||||
" INSTALL
|
||||
" 1. Put phpfolding.vim in your plugin directory (~/.vim/plugin)
|
||||
" 2. You might want to add the following keyboard mappings to your .vimrc:
|
||||
"
|
||||
" map <F5> <Esc>:EnableFastPHPFolds<Cr>
|
||||
" map <F6> <Esc>:EnablePHPFolds<Cr>
|
||||
" map <F7> <Esc>:DisablePHPFolds<Cr>
|
||||
"
|
||||
" 3. You can disable auto folding in your .vimrc with:
|
||||
"
|
||||
" let g:DisableAutoPHPFolding = 1
|
||||
"
|
||||
" By default EnableFastPHPFolds is called. Do these mess up your folds,
|
||||
" you can try to replace EnableFastPHPFolds by EnablePHPFolds. You can
|
||||
" change this in function s:CheckAutocmdEnablePHPFold.
|
||||
"
|
||||
" NOTE
|
||||
" It may be that you need to load the plugin from your .vimrc manually, in
|
||||
" case it doesn't work:
|
||||
"
|
||||
" let php_folding=0
|
||||
" (if you can't use the after directory in step 3)
|
||||
" source ~/path/to/phpfolding.vim
|
||||
" (if you're not using the default plugin directory)
|
||||
"
|
||||
" MORE INFORMATION
|
||||
" - In PHPCustomFolds() you can i.e. comment the PHPFoldPureBlock('class', ...)
|
||||
" call to have the script not fold classes. You can also change the second
|
||||
" parameter passed to that function call, to have it or not have it fold
|
||||
" PhpDoc comments. All other folding you can turn on/off in this function.
|
||||
" - You can tweak the foldtext to your liking in the function PHPFoldText().
|
||||
" - You can set some preferences and default settings a few lines below
|
||||
" at the "Script configuration" part.
|
||||
"
|
||||
" This script is tested with Vim version >= 6.3 on windows and linux.
|
||||
|
||||
" Avoid reloading {{{1
|
||||
if exists('loaded_phpfolding')
|
||||
finish
|
||||
endif
|
||||
|
||||
let loaded_phpfolding = 1
|
||||
" }}}
|
||||
|
||||
" .vimrc variable to disable autofolding for php files {{{1
|
||||
if !exists("g:DisableAutoPHPFolding")
|
||||
let g:DisableAutoPHPFolding = 0
|
||||
endif
|
||||
" }}}
|
||||
|
||||
command! EnableFastPHPFolds call <SID>EnableFastPHPFolds()
|
||||
command! -nargs=* EnablePHPFolds call <SID>EnablePHPFolds(<f-args>)
|
||||
command! DisablePHPFolds call <SID>DisablePHPFolds()
|
||||
|
||||
" {{{ Script configuration
|
||||
" Display the following after the foldtext if a fold contains phpdoc
|
||||
let g:phpDocIncludedPostfix = '**'
|
||||
let g:phpDocBlockIncludedPostfix = '**#@+'
|
||||
|
||||
" Default values
|
||||
" .. search this # of empty lines for PhpDoc comments
|
||||
let g:searchPhpDocLineCount = 1
|
||||
" .. search this # of empty lines that 'trail' the foldmatch
|
||||
let g:searchEmptyLinesPostfixing = 1
|
||||
" }}}
|
||||
" {{{ Script constants
|
||||
let s:synIDattr_exists = exists('*synIDattr')
|
||||
let s:TRUE = 1
|
||||
let s:FALSE = 0
|
||||
let s:MODE_CREATE_FOLDS = 1
|
||||
let s:MODE_REMEMBER_FOLD_SETTINGS = 2
|
||||
let s:FOLD_WITH_PHPDOC = 1
|
||||
let s:FOLD_WITHOUT_PHPDOC = 2
|
||||
let s:SEARCH_PAIR_START_FIRST = 1
|
||||
let s:SEARCH_PAIR_IMMEDIATELY = 2
|
||||
" }}}
|
||||
|
||||
function! s:EnableFastPHPFolds() " {{{
|
||||
call s:EnablePHPFolds(s:FALSE)
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:EnablePHPFolds(...) " {{{
|
||||
let s:extensiveBracketChecking = s:TRUE
|
||||
|
||||
" Check function arguments
|
||||
if a:0 == 1
|
||||
let s:extensiveBracketChecking = a:1
|
||||
endif
|
||||
|
||||
" Remember cursor information if possible
|
||||
let s:savedCursor = line(".")
|
||||
|
||||
" Initialize variables
|
||||
set foldmethod=manual
|
||||
set foldtext=PHPFoldText()
|
||||
let s:openFoldListItems = 0
|
||||
let s:fileLineCount = line('$')
|
||||
|
||||
let s:searchPhpDocLineCount = g:searchPhpDocLineCount
|
||||
let s:searchEmptyLinesPostfixing = g:searchEmptyLinesPostfixing
|
||||
|
||||
|
||||
" Move to end of file
|
||||
exec s:fileLineCount
|
||||
|
||||
" First pass: Look for Folds, remember opened folds
|
||||
let s:foldingMode = s:MODE_REMEMBER_FOLD_SETTINGS
|
||||
call s:PHPCustomFolds()
|
||||
|
||||
" Second pass: Recreate Folds, restore previously opened
|
||||
let s:foldingMode = s:MODE_CREATE_FOLDS
|
||||
" .. Remove all folds first
|
||||
normal zE
|
||||
let s:foldsCreated = 0
|
||||
call s:PHPCustomFolds()
|
||||
" .. Fold all
|
||||
normal zM
|
||||
|
||||
" Restore previously opened folds
|
||||
let currentItem = 0
|
||||
while currentItem < s:openFoldListItems
|
||||
exec s:foldsOpenedList{currentItem}
|
||||
normal zo
|
||||
let currentItem = currentItem + 1
|
||||
endwhile
|
||||
|
||||
:redraw
|
||||
echo s:foldsCreated . " fold(s) created"
|
||||
|
||||
" Restore cursor
|
||||
exec s:savedCursor
|
||||
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:DisablePHPFolds() " {{{
|
||||
"set foldmethod=manual
|
||||
set foldtext=
|
||||
normal zE
|
||||
echo "php fold(s) deleted"
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:PHPCustomFolds() " {{{
|
||||
" NOTE: The two last parameters for functions PHPFoldProperties() and
|
||||
" PHPFoldPureBlock() overwrite: 'g:searchPhpDocLineCount' and
|
||||
" 'g:searchEmptyLinesPostfixing'..
|
||||
|
||||
" Fold function with PhpDoc (function foo() {})
|
||||
call s:PHPFoldPureBlock('function', s:FOLD_WITH_PHPDOC)
|
||||
|
||||
" Fold class properties with PhpDoc (var $foo = NULL;)
|
||||
call s:PHPFoldProperties('^\s*var\s\$', ";", s:FOLD_WITH_PHPDOC, 1, 1)
|
||||
|
||||
" Fold class without PhpDoc (class foo {})
|
||||
call s:PHPFoldPureBlock('^\s*\(abstract\s*\)\?class', s:FOLD_WITH_PHPDOC)
|
||||
|
||||
" Fold define()'s with their PhpDoc
|
||||
call s:PHPFoldProperties('^\s*define\s*(', ";", s:FOLD_WITH_PHPDOC)
|
||||
|
||||
" Fold includes with their PhpDoc
|
||||
call s:PHPFoldProperties('^\s*require\s*', ";", s:FOLD_WITH_PHPDOC)
|
||||
call s:PHPFoldProperties('^\s*include\s*', ";", s:FOLD_WITH_PHPDOC)
|
||||
|
||||
" Fold GLOBAL Arrays with their PhpDoc (some PEAR packages use these)
|
||||
call s:PHPFoldProperties('^\s*\$GLOBALS.*array\s*(', ";", s:FOLD_WITH_PHPDOC)
|
||||
|
||||
" Fold marker style comments ({{{ foo }}})
|
||||
call s:PHPFoldMarkers('{{{', '}}}')
|
||||
|
||||
" Fold PhpDoc "DocBlock" templates (#@+ foo #@-)
|
||||
call s:PHPFoldMarkers('#@+', '#@-')
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:PHPFoldPureBlock(startPattern, ...) " {{{
|
||||
let s:searchPhpDocLineCount = g:searchPhpDocLineCount
|
||||
let s:searchEmptyLinesPostfixing = g:searchEmptyLinesPostfixing
|
||||
let s:currentPhpDocMode = s:FOLD_WITH_PHPDOC
|
||||
|
||||
if a:0 >= 1
|
||||
" Do we also put the PHP doc part in the fold?
|
||||
let s:currentPhpDocMode = a:1
|
||||
endif
|
||||
if a:0 >= 2
|
||||
" How far do we want to look for PhpDoc comments?
|
||||
let s:searchPhpDocLineCount = a:2
|
||||
endif
|
||||
if a:0 == 3
|
||||
" How greedy are we on postfixing empty lines?
|
||||
let s:searchEmptyLinesPostfixing = a:3
|
||||
endif
|
||||
|
||||
" Move to file end
|
||||
exec s:fileLineCount
|
||||
|
||||
" Loop through file, searching for folds
|
||||
while 1
|
||||
let s:lineStart = s:FindPureBlockStart(a:startPattern)
|
||||
|
||||
if s:lineStart != 0
|
||||
|
||||
let s:lineStart = s:FindOptionalPHPDocComment()
|
||||
let s:lineStop = s:FindPureBlockEnd('{', '}', s:SEARCH_PAIR_START_FIRST)
|
||||
|
||||
" Stop on Error
|
||||
if s:lineStop == 0
|
||||
break
|
||||
endif
|
||||
|
||||
" Do something with the potential fold based on the Mode we're in
|
||||
call s:HandleFold()
|
||||
|
||||
else
|
||||
break
|
||||
endif
|
||||
|
||||
" Goto fold start (remember we're searching upwards)
|
||||
exec s:lineStart
|
||||
endwhile
|
||||
|
||||
|
||||
if s:foldingMode != s:MODE_REMEMBER_FOLD_SETTINGS
|
||||
" Remove created folds
|
||||
normal zR
|
||||
endif
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:PHPFoldMarkers(startPattern, endPattern, ...) " {{{
|
||||
let s:currentPhpDocMode = s:FOLD_WITHOUT_PHPDOC
|
||||
|
||||
" Move to file end
|
||||
exec s:fileLineCount
|
||||
|
||||
" Loop through file, searching for folds
|
||||
while 1
|
||||
let s:lineStart = s:FindPatternStart(a:startPattern)
|
||||
|
||||
if s:lineStart != 0
|
||||
let s:lineStart = s:FindOptionalPHPDocComment()
|
||||
" The fourth parameter is for disabling the search for trailing
|
||||
" empty lines..
|
||||
let s:lineStop = s:FindPureBlockEnd(a:startPattern, a:endPattern,
|
||||
\ s:SEARCH_PAIR_IMMEDIATELY, s:FALSE)
|
||||
|
||||
" Stop on Error
|
||||
if s:lineStop == 0
|
||||
break
|
||||
endif
|
||||
|
||||
" Do something with the potential fold based on the Mode we're in
|
||||
call s:HandleFold()
|
||||
else
|
||||
break
|
||||
endif
|
||||
|
||||
" Goto fold start (remember we're searching upwards)
|
||||
exec s:lineStart
|
||||
endwhile
|
||||
|
||||
if s:foldingMode != s:MODE_REMEMBER_FOLD_SETTINGS
|
||||
" Remove created folds
|
||||
normal zR
|
||||
endif
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:PHPFoldProperties(startPattern, endPattern, ...) " {{{
|
||||
let s:searchPhpDocLineCount = g:searchPhpDocLineCount
|
||||
let s:searchEmptyLinesPostfixing = g:searchEmptyLinesPostfixing
|
||||
let s:currentPhpDocMode = s:FOLD_WITH_PHPDOC
|
||||
if a:0 >= 1
|
||||
" Do we also put the PHP doc part in the fold?
|
||||
let s:currentPhpDocMode = a:1
|
||||
endif
|
||||
if a:0 >= 2
|
||||
" How far do we want to look for PhpDoc comments?
|
||||
let s:searchPhpDocLineCount = a:2
|
||||
endif
|
||||
if a:0 == 3
|
||||
" How greedy are we on postfixing empty lines?
|
||||
let s:searchEmptyLinesPostfixing = a:3
|
||||
endif
|
||||
|
||||
" Move to end of file
|
||||
exec s:fileLineCount
|
||||
|
||||
" Loop through file, searching for folds
|
||||
while 1
|
||||
let s:lineStart = s:FindPatternStart(a:startPattern)
|
||||
|
||||
if s:lineStart != 0
|
||||
let s:lineStart = s:FindOptionalPHPDocComment()
|
||||
let s:lineStop = s:FindPatternEnd(a:endPattern)
|
||||
|
||||
" Stop on Error
|
||||
if s:lineStop == 0
|
||||
break
|
||||
endif
|
||||
|
||||
" Do something with the potential fold based on the Mode we're in
|
||||
call s:HandleFold()
|
||||
else
|
||||
break
|
||||
endif
|
||||
|
||||
" Goto fold start (remember we're searching upwards)
|
||||
exec s:lineStart
|
||||
|
||||
endwhile
|
||||
|
||||
if s:foldingMode != s:MODE_REMEMBER_FOLD_SETTINGS
|
||||
" Remove created folds
|
||||
normal zR
|
||||
endif
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:HandleFold() " {{{
|
||||
if s:foldingMode == s:MODE_REMEMBER_FOLD_SETTINGS
|
||||
" If we are in an actual fold..,
|
||||
if foldlevel(s:lineStart) != 0
|
||||
" .. and it is not closed..,
|
||||
if foldclosed(s:lineStart) == -1
|
||||
" .. and it is more then one lines
|
||||
" (it has to be or it will be open by default)
|
||||
if s:lineStop - s:lineStart >= 1
|
||||
" Remember it as an open fold
|
||||
let s:foldsOpenedList{s:openFoldListItems} = s:lineStart
|
||||
let s:openFoldListItems = s:openFoldListItems + 1
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
" If the cursor is inside the fold, it needs to be opened
|
||||
if s:lineStart <= s:savedCursor && s:lineStop >= s:savedCursor
|
||||
" Remember it as an open fold
|
||||
let s:foldsOpenedList{s:openFoldListItems} = s:lineStart
|
||||
let s:openFoldListItems = s:openFoldListItems + 1
|
||||
endif
|
||||
|
||||
elseif s:foldingMode == s:MODE_CREATE_FOLDS
|
||||
" Correct lineStop if needed (the script might have mistaken lines
|
||||
" beyond the file's scope for trailing empty lines)
|
||||
if s:lineStop > s:fileLineCount
|
||||
let s:lineStop = s:fileLineCount
|
||||
endif
|
||||
" Create the actual fold!
|
||||
exec s:lineStart . "," . s:lineStop . "fold"
|
||||
let s:foldsCreated = s:foldsCreated + 1
|
||||
endif
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:FindPureBlockStart(startPattern) " {{{
|
||||
" When the startPattern is 'function', this following search will match:
|
||||
"
|
||||
" function foo($bar) { function foo($bar)
|
||||
" {
|
||||
"
|
||||
" function foo($bar) function foo($bar1,
|
||||
" .. { $bar2)
|
||||
" {
|
||||
"
|
||||
"return search(a:startPattern . '.*\%[\n].*{', 'W')
|
||||
"return search(a:startPattern . '.*\%[\n].*\%[\n].*{', 'bW')
|
||||
|
||||
" This function can match the line its on *again* if the cursor was
|
||||
" restored.. hence we search twice if needed..
|
||||
let currentLine = line('.')
|
||||
let line = search(a:startPattern . '.*\%[\n].*\%[\n].*{', 'bW')
|
||||
if currentLine == line
|
||||
let line = search(a:startPattern . '.*\%[\n].*\%[\n].*{', 'bW')
|
||||
endif
|
||||
return line
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:FindPatternStart(startPattern) " {{{
|
||||
" This function can match the line its on *again* if the cursor was
|
||||
" restored.. hence we search twice if needed..
|
||||
let currentLine = line('.')
|
||||
let line = search(a:startPattern, 'bW')
|
||||
if currentLine == line
|
||||
let line = search(a:startPattern, 'bW')
|
||||
endif
|
||||
return line
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:FindOptionalPHPDocComment() " {{{
|
||||
" Is searching for PHPDoc disabled?
|
||||
if s:currentPhpDocMode == s:FOLD_WITHOUT_PHPDOC
|
||||
" .. Return the original Fold's start
|
||||
return s:lineStart
|
||||
endif
|
||||
|
||||
" Skipover 'empty' lines in search for PhpDoc
|
||||
let s:counter = 0
|
||||
let s:currentLine = s:lineStart - 1
|
||||
while s:counter < s:searchPhpDocLineCount
|
||||
let line = getline(s:currentLine)
|
||||
if (matchstr(line, '^\s*$') == line)
|
||||
let s:currentLine = s:currentLine - 1
|
||||
endif
|
||||
let s:counter = s:counter + 1
|
||||
endwhile
|
||||
|
||||
" Is there a closing C style */ on the above line?
|
||||
let checkLine = s:currentLine
|
||||
if strridx(getline(checkLine), "\*\/") != -1
|
||||
" Then search for the matching C style /* opener
|
||||
while 1
|
||||
if strridx(getline(checkLine), "\/\*") != -1
|
||||
" Only continue adjusting the Fold's start if it really is PHPdoc..
|
||||
" (which is characterized by a double asterisk, like /**)
|
||||
if strridx(getline(checkLine), "\/\*\*") != -1
|
||||
" Also only continue adjusting if the PHPdoc opener does
|
||||
" not contain a '/**#@+'. Those type of comments are
|
||||
" supposed to match with a #@- ..
|
||||
if strridx(getline(checkLine), '#@+') == -1
|
||||
" .. Return this as the Fold's start
|
||||
return checkLine
|
||||
else
|
||||
break
|
||||
endif
|
||||
else
|
||||
break
|
||||
endif
|
||||
endif
|
||||
let checkLine = checkLine - 1
|
||||
endwhile
|
||||
endif
|
||||
" .. Return the original Fold's start
|
||||
return s:lineStart
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:FindPureBlockEnd(startPair, endPair, searchStartPairFirst, ...) " {{{
|
||||
" Place Cursor on the opening pair/brace?
|
||||
if a:searchStartPairFirst == s:SEARCH_PAIR_START_FIRST
|
||||
let line = search(a:startPair, 'W')
|
||||
endif
|
||||
|
||||
" Search for the entangled closing brace
|
||||
" call cursor(line, 1) " set the cursor to the start of the lnum line
|
||||
if s:extensiveBracketChecking == s:TRUE
|
||||
let line = searchpair(a:startPair, a:startPair, a:endPair, 'W', 'SkipMatch()')
|
||||
else
|
||||
let line = searchpair(a:startPair, a:startPair, a:endPair, 'W')
|
||||
endif
|
||||
if line == 0
|
||||
let line = search(a:endPair, 'W')
|
||||
endif
|
||||
if line == 0
|
||||
" Return error
|
||||
return 0
|
||||
endif
|
||||
|
||||
" If the fold exceeds more than one line, and searching for empty lines is
|
||||
" not disabled..
|
||||
let foldExceedsOneLine = line - s:lineStart >= 1
|
||||
if a:0 == 1
|
||||
let emptyLinesNotDisabled = a:1
|
||||
else
|
||||
let emptyLinesNotDisabled = s:TRUE
|
||||
endif
|
||||
if foldExceedsOneLine && emptyLinesNotDisabled
|
||||
" Then be greedy with extra 'trailing' empty line(s)
|
||||
let s:counter = 0
|
||||
while s:counter < s:searchEmptyLinesPostfixing
|
||||
let linestr = getline(line + 1)
|
||||
if (matchstr(linestr, '^\s*$') == linestr)
|
||||
let line = line + 1
|
||||
endif
|
||||
let s:counter = s:counter + 1
|
||||
endwhile
|
||||
endif
|
||||
|
||||
return line
|
||||
endfunction
|
||||
" }}}
|
||||
function! s:FindPatternEnd(endPattern) " {{{
|
||||
let line = search(a:endPattern, 'W')
|
||||
|
||||
" If the fold exceeds more than one line
|
||||
if line - s:lineStart >= 1
|
||||
" Then be greedy with extra 'trailing' empty line(s)
|
||||
let s:counter = 0
|
||||
while s:counter < s:searchEmptyLinesPostfixing
|
||||
let linestr = getline(line + 1)
|
||||
if (matchstr(linestr, '^\s*$') == linestr)
|
||||
let line = line + 1
|
||||
endif
|
||||
let s:counter = s:counter + 1
|
||||
endwhile
|
||||
endif
|
||||
|
||||
return line
|
||||
endfunction
|
||||
" }}}
|
||||
|
||||
function! PHPFoldText() " {{{
|
||||
let currentLine = v:foldstart
|
||||
let lines = (v:foldend - v:foldstart + 1)
|
||||
let lineString = getline(currentLine)
|
||||
" See if we folded a marker
|
||||
if strridx(lineString, "{{{") != -1 " }}}
|
||||
" Is there text after the fold opener?
|
||||
if (matchstr(lineString, '^.*{{{..*$') == lineString) " }}}
|
||||
" Then only show that text
|
||||
let lineString = substitute(lineString, '^.*{{{', '', 'g') " }}}
|
||||
" There is text before the fold opener
|
||||
else
|
||||
" Try to strip away the remainder
|
||||
let lineString = substitute(lineString, '\s*{{{.*$', '', 'g') " }}}
|
||||
endif
|
||||
" See if we folded a DocBlock
|
||||
elseif strridx(lineString, '#@+') != -1
|
||||
" Is there text after the #@+ piece?
|
||||
if (matchstr(lineString, '^.*#@+..*$') == lineString)
|
||||
" Then show that text
|
||||
let lineString = substitute(lineString, '^.*#@+', '', 'g') . ' ' . g:phpDocBlockIncludedPostfix
|
||||
" There is nothing?
|
||||
else
|
||||
" Use the next line..
|
||||
let lineString = getline(currentLine + 1) . ' ' . g:phpDocBlockIncludedPostfix
|
||||
endif
|
||||
" See if we folded an API comment block
|
||||
elseif strridx(lineString, "\/\*\*") != -1
|
||||
" (I can't get search() or searchpair() to work.., therefore the
|
||||
" following loop)
|
||||
let s:state = 0
|
||||
while currentLine < v:foldend
|
||||
let line = getline(currentLine)
|
||||
if s:state == 0 && strridx(line, "\*\/") != -1
|
||||
" Found the end, now we need to find the first not-empty line
|
||||
let s:state = 1
|
||||
elseif s:state == 1 && (matchstr(line, '^\s*$') != line)
|
||||
" Found the line to display in fold!
|
||||
break
|
||||
endif
|
||||
let currentLine = currentLine + 1
|
||||
endwhile
|
||||
let lineString = getline(currentLine)
|
||||
endif
|
||||
|
||||
" Some common replaces...
|
||||
" if currentLine != v:foldend
|
||||
let lineString = substitute(lineString, '/\*\|\*/\d\=', '', 'g')
|
||||
let lineString = substitute(lineString, '^\s*\*\?\s*', '', 'g')
|
||||
let lineString = substitute(lineString, '{$', '', 'g')
|
||||
let lineString = substitute(lineString, '($', '(..);', 'g')
|
||||
" endif
|
||||
|
||||
" Emulates printf("%3d", lines)..
|
||||
if lines < 10
|
||||
let lines = " " . lines
|
||||
elseif lines < 100
|
||||
let lines = " " . lines
|
||||
endif
|
||||
|
||||
" Append an (a) if there is PhpDoc in the fold (a for API)
|
||||
if currentLine != v:foldstart
|
||||
let lineString = lineString . " " . g:phpDocIncludedPostfix . " "
|
||||
endif
|
||||
|
||||
" Return the foldtext
|
||||
return "+--".lines." lines: " . lineString
|
||||
endfunction
|
||||
" }}}
|
||||
function! SkipMatch() " {{{
|
||||
" This function is modified from a PHP indent file by John Wellesz
|
||||
" found here: http://www.vim.org/scripts/script.php?script_id=1120
|
||||
if (!s:synIDattr_exists)
|
||||
return 0
|
||||
endif
|
||||
let synname = synIDattr(synID(line("."), col("."), 0), "name")
|
||||
if synname == "phpParent" || synname == "javaScriptBraces" || synname == "phpComment"
|
||||
return 0
|
||||
else
|
||||
return 1
|
||||
endif
|
||||
endfun
|
||||
" }}}
|
||||
|
||||
" Check filetype == php before automatically creating (fast) folds {{{1
|
||||
function! s:CheckAutocmdEnablePHPFold()
|
||||
if &filetype == "php" && ! g:DisableAutoPHPFolding
|
||||
call s:EnableFastPHPFolds()
|
||||
endif
|
||||
endfunction
|
||||
" }}}
|
||||
|
||||
" Call CheckAutocmdEnablePHPFold on BufReadPost {{{1
|
||||
augroup SetPhpFolds
|
||||
au!
|
||||
au BufReadPost * call s:CheckAutocmdEnablePHPFold()
|
||||
augroup END
|
||||
" }}}
|
||||
|
||||
" vim:ft=vim:foldmethod=marker:nowrap:tabstop=4:shiftwidth=4
|
||||
@@ -1,5 +0,0 @@
|
||||
Quickly install with:
|
||||
|
||||
git clone git://github.com/msanders/snipmate.vim.git
|
||||
cd snipmate.vim
|
||||
cp -R * ~/.vim
|
||||
@@ -1,40 +0,0 @@
|
||||
" These are the mappings for snipMate.vim. Putting it here ensures that it
|
||||
" will be mapped after other plugins such as supertab.vim.
|
||||
if !exists('loaded_snips') || exists('s:did_snips_mappings')
|
||||
finish
|
||||
endif
|
||||
let s:did_snips_mappings = 1
|
||||
|
||||
" This is put here in the 'after' directory in order for snipMate to override
|
||||
" other plugin mappings (e.g., supertab).
|
||||
"
|
||||
" You can safely adjust these mappings to your preferences (as explained in
|
||||
" :help snipMate-remap).
|
||||
ino <silent> <tab> <c-r>=TriggerSnippet()<cr>
|
||||
snor <silent> <tab> <esc>i<right><c-r>=TriggerSnippet()<cr>
|
||||
ino <silent> <s-tab> <c-r>=BackwardsSnippet()<cr>
|
||||
snor <silent> <s-tab> <esc>i<right><c-r>=BackwardsSnippet()<cr>
|
||||
ino <silent> <c-r><tab> <c-r>=ShowAvailableSnips()<cr>
|
||||
|
||||
" The default mappings for these are annoying & sometimes break snipMate.
|
||||
" You can change them back if you want, I've put them here for convenience.
|
||||
snor <bs> b<bs>
|
||||
snor <right> <esc>a
|
||||
snor <left> <esc>bi
|
||||
snor ' b<bs>'
|
||||
snor ` b<bs>`
|
||||
snor % b<bs>%
|
||||
snor U b<bs>U
|
||||
snor ^ b<bs>^
|
||||
snor \ b<bs>\
|
||||
snor <c-x> b<bs><c-x>
|
||||
|
||||
" By default load snippets in snippets_dir
|
||||
if empty(snippets_dir)
|
||||
finish
|
||||
endif
|
||||
|
||||
call GetSnippets(snippets_dir, '_') " Get global snippets
|
||||
|
||||
au FileType * if &ft != 'help' | call GetSnippets(snippets_dir, &ft) | endif
|
||||
" vim:noet:sw=4:ts=4:ft=vim
|
||||
@@ -1,435 +0,0 @@
|
||||
fun! Filename(...)
|
||||
let filename = expand('%:t:r')
|
||||
if filename == '' | return a:0 == 2 ? a:2 : '' | endif
|
||||
return !a:0 || a:1 == '' ? filename : substitute(a:1, '$1', filename, 'g')
|
||||
endf
|
||||
|
||||
fun s:RemoveSnippet()
|
||||
unl! g:snipPos s:curPos s:snipLen s:endCol s:endLine s:prevLen
|
||||
\ s:lastBuf s:oldWord
|
||||
if exists('s:update')
|
||||
unl s:startCol s:origWordLen s:update
|
||||
if exists('s:oldVars') | unl s:oldVars s:oldEndCol | endif
|
||||
endif
|
||||
aug! snipMateAutocmds
|
||||
endf
|
||||
|
||||
fun snipMate#expandSnip(snip, col)
|
||||
let lnum = line('.') | let col = a:col
|
||||
|
||||
let snippet = s:ProcessSnippet(a:snip)
|
||||
" Avoid error if eval evaluates to nothing
|
||||
if snippet == '' | return '' | endif
|
||||
|
||||
" Expand snippet onto current position with the tab stops removed
|
||||
let snipLines = split(substitute(snippet, '$\d\+\|${\d\+.\{-}}', '', 'g'), "\n", 1)
|
||||
|
||||
let line = getline(lnum)
|
||||
let afterCursor = strpart(line, col - 1)
|
||||
" Keep text after the cursor
|
||||
if afterCursor != "\t" && afterCursor != ' '
|
||||
let line = strpart(line, 0, col - 1)
|
||||
let snipLines[-1] .= afterCursor
|
||||
else
|
||||
let afterCursor = ''
|
||||
" For some reason the cursor needs to move one right after this
|
||||
if line != '' && col == 1 && &ve != 'all' && &ve != 'onemore'
|
||||
let col += 1
|
||||
endif
|
||||
endif
|
||||
|
||||
call setline(lnum, line.snipLines[0])
|
||||
|
||||
" Autoindent snippet according to previous indentation
|
||||
let indent = matchend(line, '^.\{-}\ze\(\S\|$\)') + 1
|
||||
call append(lnum, map(snipLines[1:], "'".strpart(line, 0, indent - 1)."'.v:val"))
|
||||
|
||||
" Open any folds snippet expands into
|
||||
if &fen | sil! exe lnum.','.(lnum + len(snipLines) - 1).'foldopen' | endif
|
||||
|
||||
let [g:snipPos, s:snipLen] = s:BuildTabStops(snippet, lnum, col - indent, indent)
|
||||
|
||||
if s:snipLen
|
||||
aug snipMateAutocmds
|
||||
au CursorMovedI * call s:UpdateChangedSnip(0)
|
||||
au InsertEnter * call s:UpdateChangedSnip(1)
|
||||
aug END
|
||||
let s:lastBuf = bufnr(0) " Only expand snippet while in current buffer
|
||||
let s:curPos = 0
|
||||
let s:endCol = g:snipPos[s:curPos][1]
|
||||
let s:endLine = g:snipPos[s:curPos][0]
|
||||
|
||||
call cursor(g:snipPos[s:curPos][0], g:snipPos[s:curPos][1])
|
||||
let s:prevLen = [line('$'), col('$')]
|
||||
if g:snipPos[s:curPos][2] != -1 | return s:SelectWord() | endif
|
||||
else
|
||||
unl g:snipPos s:snipLen
|
||||
" Place cursor at end of snippet if no tab stop is given
|
||||
let newlines = len(snipLines) - 1
|
||||
call cursor(lnum + newlines, indent + len(snipLines[-1]) - len(afterCursor)
|
||||
\ + (newlines ? 0: col - 1))
|
||||
endif
|
||||
return ''
|
||||
endf
|
||||
|
||||
" Prepare snippet to be processed by s:BuildTabStops
|
||||
fun s:ProcessSnippet(snip)
|
||||
let snippet = a:snip
|
||||
" Evaluate eval (`...`) expressions.
|
||||
" Backquotes prefixed with a backslash "\" are ignored.
|
||||
" Using a loop here instead of a regex fixes a bug with nested "\=".
|
||||
if stridx(snippet, '`') != -1
|
||||
while match(snippet, '\(^\|[^\\]\)`.\{-}[^\\]`') != -1
|
||||
let snippet = substitute(snippet, '\(^\|[^\\]\)\zs`.\{-}[^\\]`\ze',
|
||||
\ substitute(eval(matchstr(snippet, '\(^\|[^\\]\)`\zs.\{-}[^\\]\ze`')),
|
||||
\ "\n\\%$", '', ''), '')
|
||||
endw
|
||||
let snippet = substitute(snippet, "\r", "\n", 'g')
|
||||
let snippet = substitute(snippet, '\\`', '`', 'g')
|
||||
endif
|
||||
|
||||
" Place all text after a colon in a tab stop after the tab stop
|
||||
" (e.g. "${#:foo}" becomes "${:foo}foo").
|
||||
" This helps tell the position of the tab stops later.
|
||||
let snippet = substitute(snippet, '${\d\+:\(.\{-}\)}', '&\1', 'g')
|
||||
|
||||
" Update the a:snip so that all the $# become the text after
|
||||
" the colon in their associated ${#}.
|
||||
" (e.g. "${1:foo}" turns all "$1"'s into "foo")
|
||||
let i = 1
|
||||
while stridx(snippet, '${'.i) != -1
|
||||
let s = matchstr(snippet, '${'.i.':\zs.\{-}\ze}')
|
||||
if s != ''
|
||||
let snippet = substitute(snippet, '$'.i, s.'&', 'g')
|
||||
endif
|
||||
let i += 1
|
||||
endw
|
||||
|
||||
if &et " Expand tabs to spaces if 'expandtab' is set.
|
||||
return substitute(snippet, '\t', repeat(' ', &sts ? &sts : &sw), 'g')
|
||||
endif
|
||||
return snippet
|
||||
endf
|
||||
|
||||
" Counts occurences of haystack in needle
|
||||
fun s:Count(haystack, needle)
|
||||
let counter = 0
|
||||
let index = stridx(a:haystack, a:needle)
|
||||
while index != -1
|
||||
let index = stridx(a:haystack, a:needle, index+1)
|
||||
let counter += 1
|
||||
endw
|
||||
return counter
|
||||
endf
|
||||
|
||||
" Builds a list of a list of each tab stop in the snippet containing:
|
||||
" 1.) The tab stop's line number.
|
||||
" 2.) The tab stop's column number
|
||||
" (by getting the length of the string between the last "\n" and the
|
||||
" tab stop).
|
||||
" 3.) The length of the text after the colon for the current tab stop
|
||||
" (e.g. "${1:foo}" would return 3). If there is no text, -1 is returned.
|
||||
" 4.) If the "${#:}" construct is given, another list containing all
|
||||
" the matches of "$#", to be replaced with the placeholder. This list is
|
||||
" composed the same way as the parent; the first item is the line number,
|
||||
" and the second is the column.
|
||||
fun s:BuildTabStops(snip, lnum, col, indent)
|
||||
let snipPos = []
|
||||
let i = 1
|
||||
let withoutVars = substitute(a:snip, '$\d\+', '', 'g')
|
||||
while stridx(a:snip, '${'.i) != -1
|
||||
let beforeTabStop = matchstr(withoutVars, '^.*\ze${'.i.'\D')
|
||||
let withoutOthers = substitute(withoutVars, '${\('.i.'\D\)\@!\d\+.\{-}}', '', 'g')
|
||||
|
||||
let j = i - 1
|
||||
call add(snipPos, [0, 0, -1])
|
||||
let snipPos[j][0] = a:lnum + s:Count(beforeTabStop, "\n")
|
||||
let snipPos[j][1] = a:indent + len(matchstr(withoutOthers, '.*\(\n\|^\)\zs.*\ze${'.i.'\D'))
|
||||
if snipPos[j][0] == a:lnum | let snipPos[j][1] += a:col | endif
|
||||
|
||||
" Get all $# matches in another list, if ${#:name} is given
|
||||
if stridx(withoutVars, '${'.i.':') != -1
|
||||
let snipPos[j][2] = len(matchstr(withoutVars, '${'.i.':\zs.\{-}\ze}'))
|
||||
let dots = repeat('.', snipPos[j][2])
|
||||
call add(snipPos[j], [])
|
||||
let withoutOthers = substitute(a:snip, '${\d\+.\{-}}\|$'.i.'\@!\d\+', '', 'g')
|
||||
while match(withoutOthers, '$'.i.'\(\D\|$\)') != -1
|
||||
let beforeMark = matchstr(withoutOthers, '^.\{-}\ze'.dots.'$'.i.'\(\D\|$\)')
|
||||
call add(snipPos[j][3], [0, 0])
|
||||
let snipPos[j][3][-1][0] = a:lnum + s:Count(beforeMark, "\n")
|
||||
let snipPos[j][3][-1][1] = a:indent + (snipPos[j][3][-1][0] > a:lnum
|
||||
\ ? len(matchstr(beforeMark, '.*\n\zs.*'))
|
||||
\ : a:col + len(beforeMark))
|
||||
let withoutOthers = substitute(withoutOthers, '$'.i.'\ze\(\D\|$\)', '', '')
|
||||
endw
|
||||
endif
|
||||
let i += 1
|
||||
endw
|
||||
return [snipPos, i - 1]
|
||||
endf
|
||||
|
||||
fun snipMate#jumpTabStop(backwards)
|
||||
let leftPlaceholder = exists('s:origWordLen')
|
||||
\ && s:origWordLen != g:snipPos[s:curPos][2]
|
||||
if leftPlaceholder && exists('s:oldEndCol')
|
||||
let startPlaceholder = s:oldEndCol + 1
|
||||
endif
|
||||
|
||||
if exists('s:update')
|
||||
call s:UpdatePlaceholderTabStops()
|
||||
else
|
||||
call s:UpdateTabStops()
|
||||
endif
|
||||
|
||||
" Don't reselect placeholder if it has been modified
|
||||
if leftPlaceholder && g:snipPos[s:curPos][2] != -1
|
||||
if exists('startPlaceholder')
|
||||
let g:snipPos[s:curPos][1] = startPlaceholder
|
||||
else
|
||||
let g:snipPos[s:curPos][1] = col('.')
|
||||
let g:snipPos[s:curPos][2] = 0
|
||||
endif
|
||||
endif
|
||||
|
||||
let s:curPos += a:backwards ? -1 : 1
|
||||
" Loop over the snippet when going backwards from the beginning
|
||||
if s:curPos < 0 | let s:curPos = s:snipLen - 1 | endif
|
||||
|
||||
if s:curPos == s:snipLen
|
||||
let sMode = s:endCol == g:snipPos[s:curPos-1][1]+g:snipPos[s:curPos-1][2]
|
||||
call s:RemoveSnippet()
|
||||
return sMode ? "\<tab>" : TriggerSnippet()
|
||||
endif
|
||||
|
||||
call cursor(g:snipPos[s:curPos][0], g:snipPos[s:curPos][1])
|
||||
|
||||
let s:endLine = g:snipPos[s:curPos][0]
|
||||
let s:endCol = g:snipPos[s:curPos][1]
|
||||
let s:prevLen = [line('$'), col('$')]
|
||||
|
||||
return g:snipPos[s:curPos][2] == -1 ? '' : s:SelectWord()
|
||||
endf
|
||||
|
||||
fun s:UpdatePlaceholderTabStops()
|
||||
let changeLen = s:origWordLen - g:snipPos[s:curPos][2]
|
||||
unl s:startCol s:origWordLen s:update
|
||||
if !exists('s:oldVars') | return | endif
|
||||
" Update tab stops in snippet if text has been added via "$#"
|
||||
" (e.g., in "${1:foo}bar$1${2}").
|
||||
if changeLen != 0
|
||||
let curLine = line('.')
|
||||
|
||||
for pos in g:snipPos
|
||||
if pos == g:snipPos[s:curPos] | continue | endif
|
||||
let changed = pos[0] == curLine && pos[1] > s:oldEndCol
|
||||
let changedVars = 0
|
||||
let endPlaceholder = pos[2] - 1 + pos[1]
|
||||
" Subtract changeLen from each tab stop that was after any of
|
||||
" the current tab stop's placeholders.
|
||||
for [lnum, col] in s:oldVars
|
||||
if lnum > pos[0] | break | endif
|
||||
if pos[0] == lnum
|
||||
if pos[1] > col || (pos[2] == -1 && pos[1] == col)
|
||||
let changed += 1
|
||||
elseif col < endPlaceholder
|
||||
let changedVars += 1
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
let pos[1] -= changeLen * changed
|
||||
let pos[2] -= changeLen * changedVars " Parse variables within placeholders
|
||||
" e.g., "${1:foo} ${2:$1bar}"
|
||||
|
||||
if pos[2] == -1 | continue | endif
|
||||
" Do the same to any placeholders in the other tab stops.
|
||||
for nPos in pos[3]
|
||||
let changed = nPos[0] == curLine && nPos[1] > s:oldEndCol
|
||||
for [lnum, col] in s:oldVars
|
||||
if lnum > nPos[0] | break | endif
|
||||
if nPos[0] == lnum && nPos[1] > col
|
||||
let changed += 1
|
||||
endif
|
||||
endfor
|
||||
let nPos[1] -= changeLen * changed
|
||||
endfor
|
||||
endfor
|
||||
endif
|
||||
unl s:endCol s:oldVars s:oldEndCol
|
||||
endf
|
||||
|
||||
fun s:UpdateTabStops()
|
||||
let changeLine = s:endLine - g:snipPos[s:curPos][0]
|
||||
let changeCol = s:endCol - g:snipPos[s:curPos][1]
|
||||
if exists('s:origWordLen')
|
||||
let changeCol -= s:origWordLen
|
||||
unl s:origWordLen
|
||||
endif
|
||||
let lnum = g:snipPos[s:curPos][0]
|
||||
let col = g:snipPos[s:curPos][1]
|
||||
" Update the line number of all proceeding tab stops if <cr> has
|
||||
" been inserted.
|
||||
if changeLine != 0
|
||||
let changeLine -= 1
|
||||
for pos in g:snipPos
|
||||
if pos[0] >= lnum
|
||||
if pos[0] == lnum | let pos[1] += changeCol | endif
|
||||
let pos[0] += changeLine
|
||||
endif
|
||||
if pos[2] == -1 | continue | endif
|
||||
for nPos in pos[3]
|
||||
if nPos[0] >= lnum
|
||||
if nPos[0] == lnum | let nPos[1] += changeCol | endif
|
||||
let nPos[0] += changeLine
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
elseif changeCol != 0
|
||||
" Update the column of all proceeding tab stops if text has
|
||||
" been inserted/deleted in the current line.
|
||||
for pos in g:snipPos
|
||||
if pos[1] >= col && pos[0] == lnum
|
||||
let pos[1] += changeCol
|
||||
endif
|
||||
if pos[2] == -1 | continue | endif
|
||||
for nPos in pos[3]
|
||||
if nPos[0] > lnum | break | endif
|
||||
if nPos[0] == lnum && nPos[1] >= col
|
||||
let nPos[1] += changeCol
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
endif
|
||||
endf
|
||||
|
||||
fun s:SelectWord()
|
||||
let s:origWordLen = g:snipPos[s:curPos][2]
|
||||
let s:oldWord = strpart(getline('.'), g:snipPos[s:curPos][1] - 1,
|
||||
\ s:origWordLen)
|
||||
let s:prevLen[1] -= s:origWordLen
|
||||
if !empty(g:snipPos[s:curPos][3])
|
||||
let s:update = 1
|
||||
let s:endCol = -1
|
||||
let s:startCol = g:snipPos[s:curPos][1] - 1
|
||||
endif
|
||||
if !s:origWordLen | return '' | endif
|
||||
let l = col('.') != 1 ? 'l' : ''
|
||||
if &sel == 'exclusive'
|
||||
return "\<esc>".l.'v'.s:origWordLen."l\<c-g>"
|
||||
endif
|
||||
return s:origWordLen == 1 ? "\<esc>".l.'gh'
|
||||
\ : "\<esc>".l.'v'.(s:origWordLen - 1)."l\<c-g>"
|
||||
endf
|
||||
|
||||
" This updates the snippet as you type when text needs to be inserted
|
||||
" into multiple places (e.g. in "${1:default text}foo$1bar$1",
|
||||
" "default text" would be highlighted, and if the user types something,
|
||||
" UpdateChangedSnip() would be called so that the text after "foo" & "bar"
|
||||
" are updated accordingly)
|
||||
"
|
||||
" It also automatically quits the snippet if the cursor is moved out of it
|
||||
" while in insert mode.
|
||||
fun s:UpdateChangedSnip(entering)
|
||||
if exists('g:snipPos') && bufnr(0) != s:lastBuf
|
||||
call s:RemoveSnippet()
|
||||
elseif exists('s:update') " If modifying a placeholder
|
||||
if !exists('s:oldVars') && s:curPos + 1 < s:snipLen
|
||||
" Save the old snippet & word length before it's updated
|
||||
" s:startCol must be saved too, in case text is added
|
||||
" before the snippet (e.g. in "foo$1${2}bar${1:foo}").
|
||||
let s:oldEndCol = s:startCol
|
||||
let s:oldVars = deepcopy(g:snipPos[s:curPos][3])
|
||||
endif
|
||||
let col = col('.') - 1
|
||||
|
||||
if s:endCol != -1
|
||||
let changeLen = col('$') - s:prevLen[1]
|
||||
let s:endCol += changeLen
|
||||
else " When being updated the first time, after leaving select mode
|
||||
if a:entering | return | endif
|
||||
let s:endCol = col - 1
|
||||
endif
|
||||
|
||||
" If the cursor moves outside the snippet, quit it
|
||||
if line('.') != g:snipPos[s:curPos][0] || col < s:startCol ||
|
||||
\ col - 1 > s:endCol
|
||||
unl! s:startCol s:origWordLen s:oldVars s:update
|
||||
return s:RemoveSnippet()
|
||||
endif
|
||||
|
||||
call s:UpdateVars()
|
||||
let s:prevLen[1] = col('$')
|
||||
elseif exists('g:snipPos')
|
||||
if !a:entering && g:snipPos[s:curPos][2] != -1
|
||||
let g:snipPos[s:curPos][2] = -2
|
||||
endif
|
||||
|
||||
let col = col('.')
|
||||
let lnum = line('.')
|
||||
let changeLine = line('$') - s:prevLen[0]
|
||||
|
||||
if lnum == s:endLine
|
||||
let s:endCol += col('$') - s:prevLen[1]
|
||||
let s:prevLen = [line('$'), col('$')]
|
||||
endif
|
||||
if changeLine != 0
|
||||
let s:endLine += changeLine
|
||||
let s:endCol = col
|
||||
endif
|
||||
|
||||
" Delete snippet if cursor moves out of it in insert mode
|
||||
if (lnum == s:endLine && (col > s:endCol || col < g:snipPos[s:curPos][1]))
|
||||
\ || lnum > s:endLine || lnum < g:snipPos[s:curPos][0]
|
||||
call s:RemoveSnippet()
|
||||
endif
|
||||
endif
|
||||
endf
|
||||
|
||||
" This updates the variables in a snippet when a placeholder has been edited.
|
||||
" (e.g., each "$1" in "${1:foo} $1bar $1bar")
|
||||
fun s:UpdateVars()
|
||||
let newWordLen = s:endCol - s:startCol + 1
|
||||
let newWord = strpart(getline('.'), s:startCol, newWordLen)
|
||||
if newWord == s:oldWord || empty(g:snipPos[s:curPos][3])
|
||||
return
|
||||
endif
|
||||
|
||||
let changeLen = g:snipPos[s:curPos][2] - newWordLen
|
||||
let curLine = line('.')
|
||||
let startCol = col('.')
|
||||
let oldStartSnip = s:startCol
|
||||
let updateTabStops = changeLen != 0
|
||||
let i = 0
|
||||
|
||||
for [lnum, col] in g:snipPos[s:curPos][3]
|
||||
if updateTabStops
|
||||
let start = s:startCol
|
||||
if lnum == curLine && col <= start
|
||||
let s:startCol -= changeLen
|
||||
let s:endCol -= changeLen
|
||||
endif
|
||||
for nPos in g:snipPos[s:curPos][3][(i):]
|
||||
" This list is in ascending order, so quit if we've gone too far.
|
||||
if nPos[0] > lnum | break | endif
|
||||
if nPos[0] == lnum && nPos[1] > col
|
||||
let nPos[1] -= changeLen
|
||||
endif
|
||||
endfor
|
||||
if lnum == curLine && col > start
|
||||
let col -= changeLen
|
||||
let g:snipPos[s:curPos][3][i][1] = col
|
||||
endif
|
||||
let i += 1
|
||||
endif
|
||||
|
||||
" "Very nomagic" is used here to allow special characters.
|
||||
call setline(lnum, substitute(getline(lnum), '\%'.col.'c\V'.
|
||||
\ escape(s:oldWord, '\'), escape(newWord, '\&'), ''))
|
||||
endfor
|
||||
if oldStartSnip != s:startCol
|
||||
call cursor(0, startCol + s:startCol - oldStartSnip)
|
||||
endif
|
||||
|
||||
let s:oldWord = newWord
|
||||
let g:snipPos[s:curPos][2] = newWordLen
|
||||
endf
|
||||
" vim:noet:sw=4:ts=4:ft=vim
|
||||
@@ -1,322 +0,0 @@
|
||||
*snipMate.txt* Plugin for using TextMate-style snippets in Vim.
|
||||
|
||||
snipMate *snippet* *snippets* *snipMate*
|
||||
Last Change: December 27, 2009
|
||||
|
||||
|snipMate-description| Description
|
||||
|snipMate-syntax| Snippet syntax
|
||||
|snipMate-usage| Usage
|
||||
|snipMate-settings| Settings
|
||||
|snipMate-features| Features
|
||||
|snipMate-disadvantages| Disadvantages to TextMate
|
||||
|snipMate-contact| Contact
|
||||
|snipMate-license| License
|
||||
|
||||
For Vim version 7.0 or later.
|
||||
This plugin only works if 'compatible' is not set.
|
||||
{Vi does not have any of these features.}
|
||||
|
||||
==============================================================================
|
||||
DESCRIPTION *snipMate-description*
|
||||
|
||||
snipMate.vim implements some of TextMate's snippets features in Vim. A
|
||||
snippet is a piece of often-typed text that you can insert into your
|
||||
document using a trigger word followed by a <tab>.
|
||||
|
||||
For instance, in a C file using the default installation of snipMate.vim, if
|
||||
you type "for<tab>" in insert mode, it will expand a typical for loop in C: >
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
|
||||
}
|
||||
|
||||
|
||||
To go to the next item in the loop, simply <tab> over to it; if there is
|
||||
repeated code, such as the "i" variable in this example, you can simply
|
||||
start typing once it's highlighted and all the matches specified in the
|
||||
snippet will be updated. To go in reverse, use <shift-tab>.
|
||||
|
||||
==============================================================================
|
||||
SYNTAX *snippet-syntax*
|
||||
|
||||
Snippets can be defined in two ways. They can be in their own file, named
|
||||
after their trigger in 'snippets/<filetype>/<trigger>.snippet', or they can be
|
||||
defined together in a 'snippets/<filetype>.snippets' file. Note that dotted
|
||||
'filetype' syntax is supported -- e.g., you can use >
|
||||
|
||||
:set ft=html.eruby
|
||||
|
||||
to activate snippets for both HTML and eRuby for the current file.
|
||||
|
||||
The syntax for snippets in *.snippets files is the following: >
|
||||
|
||||
snippet trigger
|
||||
expanded text
|
||||
more expanded text
|
||||
|
||||
Note that the first hard tab after the snippet trigger is required, and not
|
||||
expanded in the actual snippet. The syntax for *.snippet files is the same,
|
||||
only without the trigger declaration and starting indentation.
|
||||
|
||||
Also note that snippets must be defined using hard tabs. They can be expanded
|
||||
to spaces later if desired (see |snipMate-indenting|).
|
||||
|
||||
"#" is used as a line-comment character in *.snippets files; however, they can
|
||||
only be used outside of a snippet declaration. E.g.: >
|
||||
|
||||
# this is a correct comment
|
||||
snippet trigger
|
||||
expanded text
|
||||
snippet another_trigger
|
||||
# this isn't a comment!
|
||||
expanded text
|
||||
<
|
||||
This should hopefully be obvious with the included syntax highlighting.
|
||||
|
||||
*snipMate-${#}*
|
||||
Tab stops ~
|
||||
|
||||
By default, the cursor is placed at the end of a snippet. To specify where the
|
||||
cursor is to be placed next, use "${#}", where the # is the number of the tab
|
||||
stop. E.g., to place the cursor first on the id of a <div> tag, and then allow
|
||||
the user to press <tab> to go to the middle of it:
|
||||
>
|
||||
snippet div
|
||||
<div id="${1}">
|
||||
${2}
|
||||
</div>
|
||||
<
|
||||
*snipMate-placeholders* *snipMate-${#:}* *snipMate-$#*
|
||||
Placeholders ~
|
||||
|
||||
Placeholder text can be supplied using "${#:text}", where # is the number of
|
||||
the tab stop. This text then can be copied throughout the snippet using "$#",
|
||||
given # is the same number as used before. So, to make a C for loop: >
|
||||
|
||||
snippet for
|
||||
for (${2:i}; $2 < ${1:count}; $1++) {
|
||||
${4}
|
||||
}
|
||||
|
||||
This will cause "count" to first be selected and change if the user starts
|
||||
typing. When <tab> is pressed, the "i" in ${2}'s position will be selected;
|
||||
all $2 variables will default to "i" and automatically be updated if the user
|
||||
starts typing.
|
||||
NOTE: "$#" syntax is used only for variables, not for tab stops as in TextMate.
|
||||
|
||||
Variables within variables are also possible. For instance: >
|
||||
|
||||
snippet opt
|
||||
<option value="${1:option}">${2:$1}</option>
|
||||
|
||||
Will, as usual, cause "option" to first be selected and update all the $1
|
||||
variables if the user starts typing. Since one of these variables is inside of
|
||||
${2}, this text will then be used as a placeholder for the next tab stop,
|
||||
allowing the user to change it if he wishes.
|
||||
|
||||
To copy a value throughout a snippet without supplying default text, simply
|
||||
use the "${#:}" construct without the text; e.g.: >
|
||||
|
||||
snippet foo
|
||||
${1:}bar$1
|
||||
< *snipMate-commands*
|
||||
Interpolated Vim Script ~
|
||||
|
||||
Snippets can also contain Vim script commands that are executed (via |eval()|)
|
||||
when the snippet is inserted. Commands are given inside backticks (`...`); for
|
||||
TextMates's functionality, use the |system()| function. E.g.: >
|
||||
|
||||
snippet date
|
||||
`system("date +%Y-%m-%d")`
|
||||
|
||||
will insert the current date, assuming you are on a Unix system. Note that you
|
||||
can also (and should) use |strftime()| for this example.
|
||||
|
||||
Filename([{expr}] [, {defaultText}]) *snipMate-filename* *Filename()*
|
||||
|
||||
Since the current filename is used often in snippets, a default function
|
||||
has been defined for it in snipMate.vim, appropriately called Filename().
|
||||
|
||||
With no arguments, the default filename without an extension is returned;
|
||||
the first argument specifies what to place before or after the filename,
|
||||
and the second argument supplies the default text to be used if the file
|
||||
has not been named. "$1" in the first argument is replaced with the filename;
|
||||
if you only want the filename to be returned, the first argument can be left
|
||||
blank. Examples: >
|
||||
|
||||
snippet filename
|
||||
`Filename()`
|
||||
snippet filename_with_default
|
||||
`Filename('', 'name')`
|
||||
snippet filename_foo
|
||||
`filename('$1_foo')`
|
||||
|
||||
The first example returns the filename if it the file has been named, and an
|
||||
empty string if it hasn't. The second returns the filename if it's been named,
|
||||
and "name" if it hasn't. The third returns the filename followed by "_foo" if
|
||||
it has been named, and an empty string if it hasn't.
|
||||
|
||||
*multi_snip*
|
||||
To specify that a snippet can have multiple matches in a *.snippets file, use
|
||||
this syntax: >
|
||||
|
||||
snippet trigger A description of snippet #1
|
||||
expand this text
|
||||
snippet trigger A description of snippet #2
|
||||
expand THIS text!
|
||||
|
||||
In this example, when "trigger<tab>" is typed, a numbered menu containing all
|
||||
of the descriptions of the "trigger" will be shown; when the user presses the
|
||||
corresponding number, that snippet will then be expanded.
|
||||
|
||||
To create a snippet with multiple matches using *.snippet files,
|
||||
simply place all the snippets in a subdirectory with the trigger name:
|
||||
'snippets/<filetype>/<trigger>/<name>.snippet'.
|
||||
|
||||
==============================================================================
|
||||
USAGE *snipMate-usage*
|
||||
|
||||
*'snippets'* *g:snippets_dir*
|
||||
Snippets are by default looked for any 'snippets' directory in your
|
||||
'runtimepath'. Typically, it is located at '~/.vim/snippets/' on *nix or
|
||||
'$HOME\vimfiles\snippets\' on Windows. To change that location or add another
|
||||
one, change the g:snippets_dir variable in your |.vimrc| to your preferred
|
||||
directory, or use the |ExtractSnips()|function. This will be used by the
|
||||
|globpath()| function, and so accepts the same syntax as it (e.g.,
|
||||
comma-separated paths).
|
||||
|
||||
ExtractSnipsFile({directory}, {filetype}) *ExtractSnipsFile()* *.snippets*
|
||||
|
||||
ExtractSnipsFile() extracts the specified *.snippets file for the given
|
||||
filetype. A .snippets file contains multiple snippet declarations for the
|
||||
filetype. It is further explained above, in |snippet-syntax|.
|
||||
|
||||
ExtractSnips({directory}, {filetype}) *ExtractSnips()* *.snippet*
|
||||
|
||||
ExtractSnips() extracts *.snippet files from the specified directory and
|
||||
defines them as snippets for the given filetype. The directory tree should
|
||||
look like this: 'snippets/<filetype>/<trigger>.snippet'. If the snippet has
|
||||
multiple matches, it should look like this:
|
||||
'snippets/<filetype>/<trigger>/<name>.snippet' (see |multi_snip|).
|
||||
|
||||
ResetAllSnippets() *ResetAllSnippets()*
|
||||
ResetAllSnippets() removes all snippets from memory. This is useful to put at
|
||||
the top of a snippet setup file for if you would like to |:source| it multiple
|
||||
times.
|
||||
|
||||
ResetSnippets({filetype}) *ResetSnippets()*
|
||||
ResetSnippets() removes all snippets from memory for the given filetype.
|
||||
|
||||
ReloadAllSnippets() *ReloadAllSnippets()*
|
||||
ReloadAllSnippets() reloads all snippets for all filetypes. This is useful for
|
||||
testing and debugging.
|
||||
|
||||
ReloadSnippets({filetype}) *ReloadSnippets()*
|
||||
ReloadSnippets() reloads all snippets for the given filetype.
|
||||
|
||||
*list-snippets* *i_CTRL-R_<Tab>*
|
||||
If you would like to see what snippets are available, simply type <c-r><tab>
|
||||
in the current buffer to show a list via |popupmenu-completion|.
|
||||
|
||||
==============================================================================
|
||||
SETTINGS *snipMate-settings* *g:snips_author*
|
||||
|
||||
The g:snips_author string (similar to $TM_FULLNAME in TextMate) should be set
|
||||
to your name; it can then be used in snippets to automatically add it. E.g.: >
|
||||
|
||||
let g:snips_author = 'Hubert Farnsworth'
|
||||
snippet name
|
||||
`g:snips_author`
|
||||
<
|
||||
*snipMate-expandtab* *snipMate-indenting*
|
||||
If you would like your snippets to be expanded using spaces instead of tabs,
|
||||
just enable 'expandtab' and set 'softtabstop' to your preferred amount of
|
||||
spaces. If 'softtabstop' is not set, 'shiftwidth' is used instead.
|
||||
|
||||
*snipMate-remap*
|
||||
snipMate does not come with a setting to customize the trigger key, but you
|
||||
can remap it easily in the two lines it's defined in the 'after' directory
|
||||
under 'plugin/snipMate.vim'. For instance, to change the trigger key
|
||||
to CTRL-J, just change this: >
|
||||
|
||||
ino <tab> <c-r>=TriggerSnippet()<cr>
|
||||
snor <tab> <esc>i<right><c-r>=TriggerSnippet()<cr>
|
||||
|
||||
to this: >
|
||||
ino <c-j> <c-r>=TriggerSnippet()<cr>
|
||||
snor <c-j> <esc>i<right><c-r>=TriggerSnippet()<cr>
|
||||
|
||||
==============================================================================
|
||||
FEATURES *snipMate-features*
|
||||
|
||||
snipMate.vim has the following features among others:
|
||||
- The syntax of snippets is very similar to TextMate's, allowing
|
||||
easy conversion.
|
||||
- The position of the snippet is kept transparently (i.e. it does not use
|
||||
markers/placeholders written to the buffer), which allows you to escape
|
||||
out of an incomplete snippet, something particularly useful in Vim.
|
||||
- Variables in snippets are updated as-you-type.
|
||||
- Snippets can have multiple matches.
|
||||
- Snippets can be out of order. For instance, in a do...while loop, the
|
||||
condition can be added before the code.
|
||||
- [New] File-based snippets are supported.
|
||||
- [New] Triggers after non-word delimiters are expanded, e.g. "foo"
|
||||
in "bar.foo".
|
||||
- [New] <shift-tab> can now be used to jump tab stops in reverse order.
|
||||
|
||||
==============================================================================
|
||||
DISADVANTAGES *snipMate-disadvantages*
|
||||
|
||||
snipMate.vim currently has the following disadvantages to TextMate's snippets:
|
||||
- There is no $0; the order of tab stops must be explicitly stated.
|
||||
- Placeholders within placeholders are not possible. E.g.: >
|
||||
|
||||
'<div${1: id="${2:some_id}}">${3}</div>'
|
||||
<
|
||||
In TextMate this would first highlight ' id="some_id"', and if
|
||||
you hit delete it would automatically skip ${2} and go to ${3}
|
||||
on the next <tab>, but if you didn't delete it it would highlight
|
||||
"some_id" first. You cannot do this in snipMate.vim.
|
||||
- Regex cannot be performed on variables, such as "${1/.*/\U&}"
|
||||
- Placeholders cannot span multiple lines.
|
||||
- Activating snippets in different scopes of the same file is
|
||||
not possible.
|
||||
|
||||
Perhaps some of these features will be added in a later release.
|
||||
|
||||
==============================================================================
|
||||
CONTACT *snipMate-contact* *snipMate-author*
|
||||
|
||||
To contact the author (Michael Sanders), please email:
|
||||
msanders42+snipmate <at> gmail <dot> com
|
||||
|
||||
I greatly appreciate any suggestions or improvements offered for the script.
|
||||
|
||||
==============================================================================
|
||||
LICENSE *snipMate-license*
|
||||
|
||||
snipMate is released under the MIT license:
|
||||
|
||||
Copyright 2009-2010 Michael Sanders. All rights reserved.
|
||||
|
||||
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.
|
||||
|
||||
==============================================================================
|
||||
|
||||
vim:tw=78:ts=8:ft=help:norl:
|
||||
@@ -1,37 +0,0 @@
|
||||
'snippets' snipMate.txt /*'snippets'*
|
||||
.snippet snipMate.txt /*.snippet*
|
||||
.snippets snipMate.txt /*.snippets*
|
||||
ExtractSnips() snipMate.txt /*ExtractSnips()*
|
||||
ExtractSnipsFile() snipMate.txt /*ExtractSnipsFile()*
|
||||
Filename() snipMate.txt /*Filename()*
|
||||
ReloadAllSnippets() snipMate.txt /*ReloadAllSnippets()*
|
||||
ReloadSnippets() snipMate.txt /*ReloadSnippets()*
|
||||
ResetAllSnippets() snipMate.txt /*ResetAllSnippets()*
|
||||
ResetSnippets() snipMate.txt /*ResetSnippets()*
|
||||
g:snippets_dir snipMate.txt /*g:snippets_dir*
|
||||
g:snips_author snipMate.txt /*g:snips_author*
|
||||
i_CTRL-R_<Tab> snipMate.txt /*i_CTRL-R_<Tab>*
|
||||
list-snippets snipMate.txt /*list-snippets*
|
||||
multi_snip snipMate.txt /*multi_snip*
|
||||
snipMate snipMate.txt /*snipMate*
|
||||
snipMate-$# snipMate.txt /*snipMate-$#*
|
||||
snipMate-${#:} snipMate.txt /*snipMate-${#:}*
|
||||
snipMate-${#} snipMate.txt /*snipMate-${#}*
|
||||
snipMate-author snipMate.txt /*snipMate-author*
|
||||
snipMate-commands snipMate.txt /*snipMate-commands*
|
||||
snipMate-contact snipMate.txt /*snipMate-contact*
|
||||
snipMate-description snipMate.txt /*snipMate-description*
|
||||
snipMate-disadvantages snipMate.txt /*snipMate-disadvantages*
|
||||
snipMate-expandtab snipMate.txt /*snipMate-expandtab*
|
||||
snipMate-features snipMate.txt /*snipMate-features*
|
||||
snipMate-filename snipMate.txt /*snipMate-filename*
|
||||
snipMate-indenting snipMate.txt /*snipMate-indenting*
|
||||
snipMate-license snipMate.txt /*snipMate-license*
|
||||
snipMate-placeholders snipMate.txt /*snipMate-placeholders*
|
||||
snipMate-remap snipMate.txt /*snipMate-remap*
|
||||
snipMate-settings snipMate.txt /*snipMate-settings*
|
||||
snipMate-usage snipMate.txt /*snipMate-usage*
|
||||
snipMate.txt snipMate.txt /*snipMate.txt*
|
||||
snippet snipMate.txt /*snippet*
|
||||
snippet-syntax snipMate.txt /*snippet-syntax*
|
||||
snippets snipMate.txt /*snippets*
|
||||
@@ -1,10 +0,0 @@
|
||||
" Helper function for (x)html snippets
|
||||
if exists('s:did_snip_helper') || &cp || !exists('loaded_snips')
|
||||
finish
|
||||
endif
|
||||
let s:did_snip_helper = 1
|
||||
|
||||
" Automatically closes tag if in xhtml
|
||||
fun! Close()
|
||||
return stridx(&ft, 'xhtml') == -1 ? '' : ' /'
|
||||
endf
|
||||
@@ -1,8 +0,0 @@
|
||||
{
|
||||
"name" : "snipmate",
|
||||
"version" : "dev",
|
||||
"author" : "Michael Sanders <msanders42@gmail.com>",
|
||||
"repository" : {"type": "git", "url": "git://github.com/msanders/snipmate.vim.git"},
|
||||
"dependencies" : {},
|
||||
"description" : "snipMate.vim aims to be a concise vim script that implements some of TextMate's snippets features in Vim."
|
||||
}
|
||||
@@ -1,271 +0,0 @@
|
||||
" File: snipMate.vim
|
||||
" Author: Michael Sanders
|
||||
" Version: 0.84
|
||||
" Description: snipMate.vim implements some of TextMate's snippets features in
|
||||
" Vim. A snippet is a piece of often-typed text that you can
|
||||
" insert into your document using a trigger word followed by a "<tab>".
|
||||
"
|
||||
" For more help see snipMate.txt; you can do this by using:
|
||||
" :helptags ~/.vim/doc
|
||||
" :h snipMate.txt
|
||||
|
||||
if exists('loaded_snips') || &cp || version < 700
|
||||
finish
|
||||
endif
|
||||
let loaded_snips = 1
|
||||
if !exists('snips_author') | let snips_author = 'Me' | endif
|
||||
|
||||
au BufRead,BufNewFile *.snippets\= set ft=snippet
|
||||
au FileType snippet setl noet fdm=indent
|
||||
|
||||
let s:snippets = {} | let s:multi_snips = {}
|
||||
|
||||
if !exists('snippets_dir')
|
||||
let snippets_dir = substitute(globpath(&rtp, 'snippets/'), "\n", ',', 'g')
|
||||
endif
|
||||
|
||||
fun! MakeSnip(scope, trigger, content, ...)
|
||||
let multisnip = a:0 && a:1 != ''
|
||||
let var = multisnip ? 's:multi_snips' : 's:snippets'
|
||||
if !has_key({var}, a:scope) | let {var}[a:scope] = {} | endif
|
||||
if !has_key({var}[a:scope], a:trigger)
|
||||
let {var}[a:scope][a:trigger] = multisnip ? [[a:1, a:content]] : a:content
|
||||
elseif multisnip | let {var}[a:scope][a:trigger] += [[a:1, a:content]]
|
||||
else
|
||||
echom 'Warning in snipMate.vim: Snippet '.a:trigger.' is already defined.'
|
||||
\ .' See :h multi_snip for help on snippets with multiple matches.'
|
||||
endif
|
||||
endf
|
||||
|
||||
fun! ExtractSnips(dir, ft)
|
||||
for path in split(globpath(a:dir, '*'), "\n")
|
||||
if isdirectory(path)
|
||||
let pathname = fnamemodify(path, ':t')
|
||||
for snipFile in split(globpath(path, '*.snippet'), "\n")
|
||||
call s:ProcessFile(snipFile, a:ft, pathname)
|
||||
endfor
|
||||
elseif fnamemodify(path, ':e') == 'snippet'
|
||||
call s:ProcessFile(path, a:ft)
|
||||
endif
|
||||
endfor
|
||||
endf
|
||||
|
||||
" Processes a single-snippet file; optionally add the name of the parent
|
||||
" directory for a snippet with multiple matches.
|
||||
fun s:ProcessFile(file, ft, ...)
|
||||
let keyword = fnamemodify(a:file, ':t:r')
|
||||
if keyword == '' | return | endif
|
||||
try
|
||||
let text = join(readfile(a:file), "\n")
|
||||
catch /E484/
|
||||
echom "Error in snipMate.vim: couldn't read file: ".a:file
|
||||
endtry
|
||||
return a:0 ? MakeSnip(a:ft, a:1, text, keyword)
|
||||
\ : MakeSnip(a:ft, keyword, text)
|
||||
endf
|
||||
|
||||
fun! ExtractSnipsFile(file, ft)
|
||||
if !filereadable(a:file) | return | endif
|
||||
let text = readfile(a:file)
|
||||
let inSnip = 0
|
||||
for line in text + ["\n"]
|
||||
if inSnip && (line[0] == "\t" || line == '')
|
||||
let content .= strpart(line, 1)."\n"
|
||||
continue
|
||||
elseif inSnip
|
||||
call MakeSnip(a:ft, trigger, content[:-2], name)
|
||||
let inSnip = 0
|
||||
endif
|
||||
|
||||
if line[:6] == 'snippet'
|
||||
let inSnip = 1
|
||||
let trigger = strpart(line, 8)
|
||||
let name = ''
|
||||
let space = stridx(trigger, ' ') + 1
|
||||
if space " Process multi snip
|
||||
let name = strpart(trigger, space)
|
||||
let trigger = strpart(trigger, 0, space - 1)
|
||||
endif
|
||||
let content = ''
|
||||
endif
|
||||
endfor
|
||||
endf
|
||||
|
||||
" Reset snippets for filetype.
|
||||
fun! ResetSnippets(ft)
|
||||
let ft = a:ft == '' ? '_' : a:ft
|
||||
for dict in [s:snippets, s:multi_snips, g:did_ft]
|
||||
if has_key(dict, ft)
|
||||
unlet dict[ft]
|
||||
endif
|
||||
endfor
|
||||
endf
|
||||
|
||||
" Reset snippets for all filetypes.
|
||||
fun! ResetAllSnippets()
|
||||
let s:snippets = {} | let s:multi_snips = {} | let g:did_ft = {}
|
||||
endf
|
||||
|
||||
" Reload snippets for filetype.
|
||||
fun! ReloadSnippets(ft)
|
||||
let ft = a:ft == '' ? '_' : a:ft
|
||||
call ResetSnippets(ft)
|
||||
call GetSnippets(g:snippets_dir, ft)
|
||||
endf
|
||||
|
||||
" Reload snippets for all filetypes.
|
||||
fun! ReloadAllSnippets()
|
||||
for ft in keys(g:did_ft)
|
||||
call ReloadSnippets(ft)
|
||||
endfor
|
||||
endf
|
||||
|
||||
let g:did_ft = {}
|
||||
fun! GetSnippets(dir, filetypes)
|
||||
for ft in split(a:filetypes, '\.')
|
||||
if has_key(g:did_ft, ft) | continue | endif
|
||||
call s:DefineSnips(a:dir, ft, ft)
|
||||
if ft == 'objc' || ft == 'cpp' || ft == 'cs'
|
||||
call s:DefineSnips(a:dir, 'c', ft)
|
||||
elseif ft == 'xhtml'
|
||||
call s:DefineSnips(a:dir, 'html', 'xhtml')
|
||||
endif
|
||||
let g:did_ft[ft] = 1
|
||||
endfor
|
||||
endf
|
||||
|
||||
" Define "aliasft" snippets for the filetype "realft".
|
||||
fun s:DefineSnips(dir, aliasft, realft)
|
||||
for path in split(globpath(a:dir, a:aliasft.'/')."\n".
|
||||
\ globpath(a:dir, a:aliasft.'-*/'), "\n")
|
||||
call ExtractSnips(path, a:realft)
|
||||
endfor
|
||||
for path in split(globpath(a:dir, a:aliasft.'.snippets')."\n".
|
||||
\ globpath(a:dir, a:aliasft.'-*.snippets'), "\n")
|
||||
call ExtractSnipsFile(path, a:realft)
|
||||
endfor
|
||||
endf
|
||||
|
||||
fun! TriggerSnippet()
|
||||
if exists('g:SuperTabMappingForward')
|
||||
if g:SuperTabMappingForward == "<tab>"
|
||||
let SuperTabKey = "\<c-n>"
|
||||
elseif g:SuperTabMappingBackward == "<tab>"
|
||||
let SuperTabKey = "\<c-p>"
|
||||
endif
|
||||
endif
|
||||
|
||||
if pumvisible() " Update snippet if completion is used, or deal with supertab
|
||||
if exists('SuperTabKey')
|
||||
call feedkeys(SuperTabKey) | return ''
|
||||
endif
|
||||
call feedkeys("\<esc>a", 'n') " Close completion menu
|
||||
call feedkeys("\<tab>") | return ''
|
||||
endif
|
||||
|
||||
if exists('g:snipPos') | return snipMate#jumpTabStop(0) | endif
|
||||
|
||||
let word = matchstr(getline('.'), '\S\+\%'.col('.').'c')
|
||||
for scope in [bufnr('%')] + split(&ft, '\.') + ['_']
|
||||
let [trigger, snippet] = s:GetSnippet(word, scope)
|
||||
" If word is a trigger for a snippet, delete the trigger & expand
|
||||
" the snippet.
|
||||
if snippet != ''
|
||||
let col = col('.') - len(trigger)
|
||||
sil exe 's/\V'.escape(trigger, '/\.').'\%#//'
|
||||
return snipMate#expandSnip(snippet, col)
|
||||
endif
|
||||
endfor
|
||||
|
||||
if exists('SuperTabKey')
|
||||
call feedkeys(SuperTabKey)
|
||||
return ''
|
||||
endif
|
||||
return "\<tab>"
|
||||
endf
|
||||
|
||||
fun! BackwardsSnippet()
|
||||
if exists('g:snipPos') | return snipMate#jumpTabStop(1) | endif
|
||||
|
||||
if exists('g:SuperTabMappingForward')
|
||||
if g:SuperTabMappingBackward == "<s-tab>"
|
||||
let SuperTabKey = "\<c-p>"
|
||||
elseif g:SuperTabMappingForward == "<s-tab>"
|
||||
let SuperTabKey = "\<c-n>"
|
||||
endif
|
||||
endif
|
||||
if exists('SuperTabKey')
|
||||
call feedkeys(SuperTabKey)
|
||||
return ''
|
||||
endif
|
||||
return "\<s-tab>"
|
||||
endf
|
||||
|
||||
" Check if word under cursor is snippet trigger; if it isn't, try checking if
|
||||
" the text after non-word characters is (e.g. check for "foo" in "bar.foo")
|
||||
fun s:GetSnippet(word, scope)
|
||||
let word = a:word | let snippet = ''
|
||||
while snippet == ''
|
||||
if exists('s:snippets["'.a:scope.'"]["'.escape(word, '\"').'"]')
|
||||
let snippet = s:snippets[a:scope][word]
|
||||
elseif exists('s:multi_snips["'.a:scope.'"]["'.escape(word, '\"').'"]')
|
||||
let snippet = s:ChooseSnippet(a:scope, word)
|
||||
if snippet == '' | break | endif
|
||||
else
|
||||
if match(word, '\W') == -1 | break | endif
|
||||
let word = substitute(word, '.\{-}\W', '', '')
|
||||
endif
|
||||
endw
|
||||
if word == '' && a:word != '.' && stridx(a:word, '.') != -1
|
||||
let [word, snippet] = s:GetSnippet('.', a:scope)
|
||||
endif
|
||||
return [word, snippet]
|
||||
endf
|
||||
|
||||
fun s:ChooseSnippet(scope, trigger)
|
||||
let snippet = []
|
||||
let i = 1
|
||||
for snip in s:multi_snips[a:scope][a:trigger]
|
||||
let snippet += [i.'. '.snip[0]]
|
||||
let i += 1
|
||||
endfor
|
||||
if i == 2 | return s:multi_snips[a:scope][a:trigger][0][1] | endif
|
||||
let num = inputlist(snippet) - 1
|
||||
return num == -1 ? '' : s:multi_snips[a:scope][a:trigger][num][1]
|
||||
endf
|
||||
|
||||
fun! ShowAvailableSnips()
|
||||
let line = getline('.')
|
||||
let col = col('.')
|
||||
let word = matchstr(getline('.'), '\S\+\%'.col.'c')
|
||||
let words = [word]
|
||||
if stridx(word, '.')
|
||||
let words += split(word, '\.', 1)
|
||||
endif
|
||||
let matchlen = 0
|
||||
let matches = []
|
||||
for scope in [bufnr('%')] + split(&ft, '\.') + ['_']
|
||||
let triggers = has_key(s:snippets, scope) ? keys(s:snippets[scope]) : []
|
||||
if has_key(s:multi_snips, scope)
|
||||
let triggers += keys(s:multi_snips[scope])
|
||||
endif
|
||||
for trigger in triggers
|
||||
for word in words
|
||||
if word == ''
|
||||
let matches += [trigger] " Show all matches if word is empty
|
||||
elseif trigger =~ '^'.word
|
||||
let matches += [trigger]
|
||||
let len = len(word)
|
||||
if len > matchlen | let matchlen = len | endif
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
endfor
|
||||
|
||||
" This is to avoid a bug with Vim when using complete(col - matchlen, matches)
|
||||
" (Issue#46 on the Google Code snipMate issue tracker).
|
||||
call setline(line('.'), substitute(line, repeat('.', matchlen).'\%'.col.'c', '', ''))
|
||||
call complete(col, matches)
|
||||
return ''
|
||||
endf
|
||||
" vim:noet:sw=4:ts=4:ft=vim
|
||||
@@ -1,9 +0,0 @@
|
||||
# Global snippets
|
||||
|
||||
# (c) holds no legal value ;)
|
||||
snippet c)
|
||||
Copyright `&enc[:2] == "utf" ? "©" : "(c)"` `strftime("%Y")` ${1:`g:snips_author`}. All Rights Reserved.${2}
|
||||
snippet date
|
||||
`strftime("%Y-%m-%d")`
|
||||
snippet ddate
|
||||
`strftime("%B %d, %Y")`
|
||||
@@ -1,66 +0,0 @@
|
||||
snippet if
|
||||
If ${1:condition} Then
|
||||
${2:; True code}
|
||||
EndIf
|
||||
snippet el
|
||||
Else
|
||||
${1}
|
||||
snippet elif
|
||||
ElseIf ${1:condition} Then
|
||||
${2:; True code}
|
||||
# If/Else block
|
||||
snippet ifel
|
||||
If ${1:condition} Then
|
||||
${2:; True code}
|
||||
Else
|
||||
${3:; Else code}
|
||||
EndIf
|
||||
# If/ElseIf/Else block
|
||||
snippet ifelif
|
||||
If ${1:condition 1} Then
|
||||
${2:; True code}
|
||||
ElseIf ${3:condition 2} Then
|
||||
${4:; True code}
|
||||
Else
|
||||
${5:; Else code}
|
||||
EndIf
|
||||
# Switch block
|
||||
snippet switch
|
||||
Switch (${1:condition})
|
||||
Case {$2:case1}:
|
||||
{$3:; Case 1 code}
|
||||
Case Else:
|
||||
{$4:; Else code}
|
||||
EndSwitch
|
||||
# Select block
|
||||
snippet select
|
||||
Select (${1:condition})
|
||||
Case {$2:case1}:
|
||||
{$3:; Case 1 code}
|
||||
Case Else:
|
||||
{$4:; Else code}
|
||||
EndSelect
|
||||
# While loop
|
||||
snippet while
|
||||
While (${1:condition})
|
||||
${2:; code...}
|
||||
WEnd
|
||||
# For loop
|
||||
snippet for
|
||||
For ${1:n} = ${3:1} to ${2:count}
|
||||
${4:; code...}
|
||||
Next
|
||||
# New Function
|
||||
snippet func
|
||||
Func ${1:fname}(${2:`indent('.') ? 'self' : ''`}):
|
||||
${4:Return}
|
||||
EndFunc
|
||||
# Message box
|
||||
snippet msg
|
||||
MsgBox(${3:MsgType}, ${1:"Title"}, ${2:"Message Text"})
|
||||
# Debug Message
|
||||
snippet debug
|
||||
MsgBox(0, "Debug", ${1:"Debug Message"})
|
||||
# Show Variable Debug Message
|
||||
snippet showvar
|
||||
MsgBox(0, "${1:VarName}", $1)
|
||||
@@ -1,113 +0,0 @@
|
||||
# main()
|
||||
snippet main
|
||||
int main(int argc, const char *argv[])
|
||||
{
|
||||
${1}
|
||||
return 0;
|
||||
}
|
||||
snippet mainn
|
||||
int main(void)
|
||||
{
|
||||
${1}
|
||||
return 0;
|
||||
}
|
||||
# #include <...>
|
||||
snippet inc
|
||||
#include <${1:stdio}.h>${2}
|
||||
# #include "..."
|
||||
snippet Inc
|
||||
#include "${1:`Filename("$1.h")`}"${2}
|
||||
# #ifndef ... #define ... #endif
|
||||
snippet Def
|
||||
#ifndef $1
|
||||
#define ${1:SYMBOL} ${2:value}
|
||||
#endif${3}
|
||||
snippet def
|
||||
#define
|
||||
snippet ifdef
|
||||
#ifdef ${1:FOO}
|
||||
${2:#define }
|
||||
#endif
|
||||
snippet #if
|
||||
#if ${1:FOO}
|
||||
${2}
|
||||
#endif
|
||||
# Header Include-Guard
|
||||
snippet once
|
||||
#ifndef ${1:`toupper(Filename('$1_H', 'UNTITLED_H'))`}
|
||||
|
||||
#define $1
|
||||
|
||||
${2}
|
||||
|
||||
#endif /* end of include guard: $1 */
|
||||
# If Condition
|
||||
snippet if
|
||||
if (${1:/* condition */}) {
|
||||
${2:/* code */}
|
||||
}
|
||||
snippet el
|
||||
else {
|
||||
${1}
|
||||
}
|
||||
# Ternary conditional
|
||||
snippet t
|
||||
${1:/* condition */} ? ${2:a} : ${3:b}
|
||||
# Do While Loop
|
||||
snippet do
|
||||
do {
|
||||
${2:/* code */}
|
||||
} while (${1:/* condition */});
|
||||
# While Loop
|
||||
snippet wh
|
||||
while (${1:/* condition */}) {
|
||||
${2:/* code */}
|
||||
}
|
||||
# For Loop
|
||||
snippet for
|
||||
for (${2:i} = 0; $2 < ${1:count}; $2${3:++}) {
|
||||
${4:/* code */}
|
||||
}
|
||||
# Custom For Loop
|
||||
snippet forr
|
||||
for (${1:i} = ${2:0}; ${3:$1 < 10}; $1${4:++}) {
|
||||
${5:/* code */}
|
||||
}
|
||||
# Function
|
||||
snippet fun
|
||||
${1:void} ${2:function_name}(${3})
|
||||
{
|
||||
${4:/* code */}
|
||||
}
|
||||
# Function Declaration
|
||||
snippet fund
|
||||
${1:void} ${2:function_name}(${3});${4}
|
||||
# Typedef
|
||||
snippet td
|
||||
typedef ${1:int} ${2:MyCustomType};${3}
|
||||
# Struct
|
||||
snippet st
|
||||
struct ${1:`Filename('$1_t', 'name')`} {
|
||||
${2:/* data */}
|
||||
}${3: /* optional variable list */};${4}
|
||||
# Typedef struct
|
||||
snippet tds
|
||||
typedef struct ${2:_$1 }{
|
||||
${3:/* data */}
|
||||
} ${1:`Filename('$1_t', 'name')`};
|
||||
# Typdef enum
|
||||
snippet tde
|
||||
typedef enum {
|
||||
${1:/* data */}
|
||||
} ${2:foo};
|
||||
# printf
|
||||
# unfortunately version this isn't as nice as TextMates's, given the lack of a
|
||||
# dynamic `...`
|
||||
snippet pr
|
||||
printf("${1:%s}\n"${2});${3}
|
||||
# fprintf (again, this isn't as nice as TextMate's version, but it works)
|
||||
snippet fpr
|
||||
fprintf(${1:stderr}, "${2:%s}\n"${3});${4}
|
||||
# This is kind of convenient
|
||||
snippet .
|
||||
[${1}]${2}
|
||||
@@ -1,63 +0,0 @@
|
||||
snippet bfun
|
||||
${1:(${2:args}) }=>
|
||||
${3:# body...}
|
||||
|
||||
snippet cla
|
||||
class ${1:ClassName}${2: extends ${3:Ancestor}}
|
||||
${4:constructor: (${5:args}) ->
|
||||
${6:# body...}}
|
||||
$7
|
||||
|
||||
snippet elif
|
||||
else if ${1:condition}
|
||||
${2:# body...}
|
||||
|
||||
snippet fora
|
||||
for ${1:name} in ${2:array}
|
||||
${3:# body...}
|
||||
|
||||
snippet foro
|
||||
for ${1:key}, ${2:value} of ${3:Object}
|
||||
${0:# body...}
|
||||
|
||||
snippet forr
|
||||
for ${1:name} in [${2:start}..${3:finish}]${4: by ${5:step}}
|
||||
${6:# body...}
|
||||
|
||||
snippet forrex
|
||||
for ${1:name} in [${2:start}...${3:finish}]${4: by ${5:step}}
|
||||
${6:# body...}
|
||||
|
||||
snippet fun
|
||||
${1:name} = (${2:args}) ->
|
||||
${3:# body...}
|
||||
|
||||
snippet if
|
||||
if ${1:condition}
|
||||
${2:# body...}
|
||||
|
||||
snippet ife
|
||||
if ${1:condition}
|
||||
${2:# body...}
|
||||
else
|
||||
${3:# body...}
|
||||
|
||||
snippet ifte
|
||||
if ${1:condition} then ${2:value} else ${3:other}
|
||||
|
||||
snippet log
|
||||
console.log $1
|
||||
|
||||
snippet swi
|
||||
switch ${1:object}
|
||||
when ${2:value}
|
||||
${0:# body...}
|
||||
|
||||
snippet try
|
||||
try
|
||||
$1
|
||||
catch ${2:error}
|
||||
$3
|
||||
|
||||
snippet unl
|
||||
${1:action} unless ${2:condition}
|
||||
@@ -1,34 +0,0 @@
|
||||
# Read File Into Vector
|
||||
snippet readfile
|
||||
std::vector<char> v;
|
||||
if (FILE *${2:fp} = fopen(${1:"filename"}, "r")) {
|
||||
char buf[1024];
|
||||
while (size_t len = fread(buf, 1, sizeof(buf), $2))
|
||||
v.insert(v.end(), buf, buf + len);
|
||||
fclose($2);
|
||||
}${3}
|
||||
# std::map
|
||||
snippet map
|
||||
std::map<${1:key}, ${2:value}> map${3};
|
||||
# std::vector
|
||||
snippet vector
|
||||
std::vector<${1:char}> v${2};
|
||||
# Namespace
|
||||
snippet ns
|
||||
namespace ${1:`Filename('', 'my')`} {
|
||||
${2}
|
||||
} /* $1 */
|
||||
# Class
|
||||
snippet cl
|
||||
class ${1:`Filename('$1_t', 'name')`} {
|
||||
public:
|
||||
$1 (${2:arguments});
|
||||
virtual ~$1 ();
|
||||
|
||||
private:
|
||||
${3:/* data */}
|
||||
};
|
||||
snippet fori
|
||||
for (int ${2:i} = 0; $2 < ${1:count}; $2${3:++}) {
|
||||
${4:/* code */}
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
# module and export all
|
||||
snippet mod
|
||||
-module(${1:`Filename('', 'my')`}).
|
||||
|
||||
-compile([export_all]).
|
||||
|
||||
start() ->
|
||||
${2}
|
||||
|
||||
stop() ->
|
||||
ok.
|
||||
# define directive
|
||||
snippet def
|
||||
-define(${1:macro}, ${2:body}).${3}
|
||||
# export directive
|
||||
snippet exp
|
||||
-export([${1:function}/${2:arity}]).
|
||||
# include directive
|
||||
snippet inc
|
||||
-include("${1:file}").${2}
|
||||
# behavior directive
|
||||
snippet beh
|
||||
-behaviour(${1:behaviour}).${2}
|
||||
# if expression
|
||||
snippet if
|
||||
if
|
||||
${1:guard} ->
|
||||
${2:body}
|
||||
end
|
||||
# case expression
|
||||
snippet case
|
||||
case ${1:expression} of
|
||||
${2:pattern} ->
|
||||
${3:body};
|
||||
end
|
||||
# record directive
|
||||
snippet rec
|
||||
-record(${1:record}, {
|
||||
${2:field}=${3:value}}).${4}
|
||||
@@ -1,190 +0,0 @@
|
||||
# Some useful Unicode entities
|
||||
# Non-Breaking Space
|
||||
snippet nbs
|
||||
|
||||
# ←
|
||||
snippet left
|
||||
←
|
||||
# →
|
||||
snippet right
|
||||
→
|
||||
# ↑
|
||||
snippet up
|
||||
↑
|
||||
# ↓
|
||||
snippet down
|
||||
↓
|
||||
# ↩
|
||||
snippet return
|
||||
↩
|
||||
# ⇤
|
||||
snippet backtab
|
||||
⇤
|
||||
# ⇥
|
||||
snippet tab
|
||||
⇥
|
||||
# ⇧
|
||||
snippet shift
|
||||
⇧
|
||||
# ⌃
|
||||
snippet control
|
||||
⌃
|
||||
# ⌅
|
||||
snippet enter
|
||||
⌅
|
||||
# ⌘
|
||||
snippet command
|
||||
⌘
|
||||
# ⌥
|
||||
snippet option
|
||||
⌥
|
||||
# ⌦
|
||||
snippet delete
|
||||
⌦
|
||||
# ⌫
|
||||
snippet backspace
|
||||
⌫
|
||||
# ⎋
|
||||
snippet escape
|
||||
⎋
|
||||
# Generic Doctype
|
||||
snippet doctype HTML 4.01 Strict
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
|
||||
"http://www.w3.org/TR/html4/strict.dtd">
|
||||
snippet doctype HTML 4.01 Transitional
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
|
||||
"http://www.w3.org/TR/html4/loose.dtd">
|
||||
snippet doctype HTML 5
|
||||
<!DOCTYPE HTML>
|
||||
snippet doctype XHTML 1.0 Frameset
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
|
||||
snippet doctype XHTML 1.0 Strict
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
|
||||
snippet doctype XHTML 1.0 Transitional
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||||
snippet doctype XHTML 1.1
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
|
||||
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
|
||||
# HTML Doctype 4.01 Strict
|
||||
snippet docts
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
|
||||
"http://www.w3.org/TR/html4/strict.dtd">
|
||||
# HTML Doctype 4.01 Transitional
|
||||
snippet doct
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
|
||||
"http://www.w3.org/TR/html4/loose.dtd">
|
||||
# HTML Doctype 5
|
||||
snippet doct5
|
||||
<!DOCTYPE HTML>
|
||||
# XHTML Doctype 1.0 Frameset
|
||||
snippet docxf
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
|
||||
# XHTML Doctype 1.0 Strict
|
||||
snippet docxs
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
|
||||
# XHTML Doctype 1.0 Transitional
|
||||
snippet docxt
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||||
# XHTML Doctype 1.1
|
||||
snippet docx
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
|
||||
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
|
||||
snippet html
|
||||
<html>
|
||||
${1}
|
||||
</html>
|
||||
snippet xhtml
|
||||
<html xmlns="http://www.w3.org/1999/xhtml">
|
||||
${1}
|
||||
</html>
|
||||
snippet body
|
||||
<body>
|
||||
${1}
|
||||
</body>
|
||||
snippet head
|
||||
<head>
|
||||
<meta http-equiv="content-type" content="text/html; charset=utf-8"`Close()`>
|
||||
|
||||
<title>${1:`substitute(Filename('', 'Page Title'), '^.', '\u&', '')`}</title>
|
||||
${2}
|
||||
</head>
|
||||
snippet title
|
||||
<title>${1:`substitute(Filename('', 'Page Title'), '^.', '\u&', '')`}</title>${2}
|
||||
snippet script
|
||||
<script type="text/javascript" charset="utf-8">
|
||||
${1}
|
||||
</script>${2}
|
||||
snippet scriptsrc
|
||||
<script src="${1}.js" type="text/javascript" charset="utf-8"></script>${2}
|
||||
snippet style
|
||||
<style type="text/css" media="${1:screen}">
|
||||
${2}
|
||||
</style>${3}
|
||||
snippet base
|
||||
<base href="${1}" target="${2}"`Close()`>
|
||||
snippet r
|
||||
<br`Close()[1:]`>
|
||||
snippet div
|
||||
<div id="${1:name}">
|
||||
${2}
|
||||
</div>
|
||||
# Embed QT Movie
|
||||
snippet movie
|
||||
<object width="$2" height="$3" classid="clsid:02BF25D5-8C17-4B23-BC80-D3488ABDDC6B"
|
||||
codebase="http://www.apple.com/qtactivex/qtplugin.cab">
|
||||
<param name="src" value="$1"`Close()`>
|
||||
<param name="controller" value="$4"`Close()`>
|
||||
<param name="autoplay" value="$5"`Close()`>
|
||||
<embed src="${1:movie.mov}"
|
||||
width="${2:320}" height="${3:240}"
|
||||
controller="${4:true}" autoplay="${5:true}"
|
||||
scale="tofit" cache="true"
|
||||
pluginspage="http://www.apple.com/quicktime/download/"
|
||||
`Close()[1:]`>
|
||||
</object>${6}
|
||||
snippet fieldset
|
||||
<fieldset id="$1">
|
||||
<legend>${1:name}</legend>
|
||||
|
||||
${3}
|
||||
</fieldset>
|
||||
snippet form
|
||||
<form action="${1:`Filename('$1_submit')`}" method="${2:get}" accept-charset="utf-8">
|
||||
${3}
|
||||
|
||||
|
||||
<p><input type="submit" value="Continue →"`Close()`></p>
|
||||
</form>
|
||||
snippet h1
|
||||
<h1 id="${1:heading}">${2:$1}</h1>
|
||||
snippet input
|
||||
<input type="${1:text/submit/hidden/button}" name="${2:some_name}" value="${3}"`Close()`>${4}
|
||||
snippet label
|
||||
<label for="${2:$1}">${1:name}</label><input type="${3:text/submit/hidden/button}" name="${4:$2}" value="${5}" id="${6:$2}"`Close()`>${7}
|
||||
snippet link
|
||||
<link rel="${1:stylesheet}" href="${2:/css/master.css}" type="text/css" media="${3:screen}" charset="utf-8"`Close()`>${4}
|
||||
snippet mailto
|
||||
<a href="mailto:${1:joe@example.com}?subject=${2:feedback}">${3:email me}</a>
|
||||
snippet meta
|
||||
<meta name="${1:name}" content="${2:content}"`Close()`>${3}
|
||||
snippet opt
|
||||
<option value="${1:option}">${2:$1}</option>${3}
|
||||
snippet optt
|
||||
<option>${1:option}</option>${2}
|
||||
snippet select
|
||||
<select name="${1:some_name}" id="${2:$1}">
|
||||
<option value="${3:option}">${4:$3}</option>
|
||||
</select>${5}
|
||||
snippet table
|
||||
<table border="${1:0}">
|
||||
<tr><th>${2:Header}</th></tr>
|
||||
<tr><th>${3:Data}</th></tr>
|
||||
</table>${4}
|
||||
snippet textarea
|
||||
<textarea name="${1:Name}" rows="${2:8}" cols="${3:40}">${4}</textarea>${5}
|
||||
@@ -1,95 +0,0 @@
|
||||
snippet main
|
||||
public static void main (String [] args)
|
||||
{
|
||||
${1:/* code */}
|
||||
}
|
||||
snippet pu
|
||||
public
|
||||
snippet po
|
||||
protected
|
||||
snippet pr
|
||||
private
|
||||
snippet st
|
||||
static
|
||||
snippet fi
|
||||
final
|
||||
snippet ab
|
||||
abstract
|
||||
snippet re
|
||||
return
|
||||
snippet br
|
||||
break;
|
||||
snippet de
|
||||
default:
|
||||
${1}
|
||||
snippet ca
|
||||
catch(${1:Exception} ${2:e}) ${3}
|
||||
snippet th
|
||||
throw
|
||||
snippet sy
|
||||
synchronized
|
||||
snippet im
|
||||
import
|
||||
snippet imp
|
||||
implements
|
||||
snippet ext
|
||||
extends
|
||||
snippet j.u
|
||||
java.util
|
||||
snippet j.i
|
||||
java.io.
|
||||
snippet j.b
|
||||
java.beans.
|
||||
snippet j.n
|
||||
java.net.
|
||||
snippet j.m
|
||||
java.math.
|
||||
snippet if
|
||||
if (${1}) ${2}
|
||||
snippet el
|
||||
else
|
||||
snippet elif
|
||||
else if (${1}) ${2}
|
||||
snippet wh
|
||||
while (${1}) ${2}
|
||||
snippet for
|
||||
for (${1}; ${2}; ${3}) ${4}
|
||||
snippet fore
|
||||
for (${1} : ${2}) ${3}
|
||||
snippet sw
|
||||
switch (${1}) ${2}
|
||||
snippet cs
|
||||
case ${1}:
|
||||
${2}
|
||||
${3}
|
||||
snippet tc
|
||||
public class ${1:`Filename()`} extends ${2:TestCase}
|
||||
snippet t
|
||||
public void test${1:Name}() throws Exception ${2}
|
||||
snippet cl
|
||||
class ${1:`Filename("", "untitled")`} ${2}
|
||||
snippet in
|
||||
interface ${1:`Filename("", "untitled")`} ${2:extends Parent}${3}
|
||||
snippet m
|
||||
${1:void} ${2:method}(${3}) ${4:throws }${5}
|
||||
snippet v
|
||||
${1:String} ${2:var}${3: = null}${4};${5}
|
||||
snippet co
|
||||
static public final ${1:String} ${2:var} = ${3};${4}
|
||||
snippet cos
|
||||
static public final String ${1:var} = "${2}";${3}
|
||||
snippet as
|
||||
assert ${1:test} : "${2:Failure message}";${3}
|
||||
snippet try
|
||||
try {
|
||||
${3}
|
||||
} catch(${1:Exception} ${2:e}) {
|
||||
}
|
||||
snippet tryf
|
||||
try {
|
||||
${3}
|
||||
} catch(${1:Exception} ${2:e}) {
|
||||
} finally {
|
||||
}
|
||||
snippet rst
|
||||
ResultSet ${1:rst}${2: = null}${3};${4}
|
||||
@@ -1,74 +0,0 @@
|
||||
# Prototype
|
||||
snippet proto
|
||||
${1:class_name}.prototype.${2:method_name} =
|
||||
function(${3:first_argument}) {
|
||||
${4:// body...}
|
||||
};
|
||||
# Function
|
||||
snippet fun
|
||||
function ${1:function_name} (${2:argument}) {
|
||||
${3:// body...}
|
||||
}
|
||||
# Anonymous Function
|
||||
snippet f
|
||||
function(${1}) {${2}};
|
||||
# if
|
||||
snippet if
|
||||
if (${1:true}) {${2}}
|
||||
# if ... else
|
||||
snippet ife
|
||||
if (${1:true}) {${2}}
|
||||
else{${3}}
|
||||
# tertiary conditional
|
||||
snippet t
|
||||
${1:/* condition */} ? ${2:a} : ${3:b}
|
||||
# switch
|
||||
snippet switch
|
||||
switch(${1:expression}) {
|
||||
case '${3:case}':
|
||||
${4:// code}
|
||||
break;
|
||||
${5}
|
||||
default:
|
||||
${2:// code}
|
||||
}
|
||||
# case
|
||||
snippet case
|
||||
case '${1:case}':
|
||||
${2:// code}
|
||||
break;
|
||||
${3}
|
||||
# for (...) {...}
|
||||
snippet for
|
||||
for (var ${2:i} = 0; $2 < ${1:Things}.length; $2${3:++}) {
|
||||
${4:$1[$2]}
|
||||
};
|
||||
# for (...) {...} (Improved Native For-Loop)
|
||||
snippet forr
|
||||
for (var ${2:i} = ${1:Things}.length - 1; $2 >= 0; $2${3:--}) {
|
||||
${4:$1[$2]}
|
||||
};
|
||||
# while (...) {...}
|
||||
snippet wh
|
||||
while (${1:/* condition */}) {
|
||||
${2:/* code */}
|
||||
}
|
||||
# do...while
|
||||
snippet do
|
||||
do {
|
||||
${2:/* code */}
|
||||
} while (${1:/* condition */});
|
||||
# Object Method
|
||||
snippet :f
|
||||
${1:method_name}: function(${2:attribute}) {
|
||||
${4}
|
||||
}${3:,}
|
||||
# setTimeout function
|
||||
snippet timeout
|
||||
setTimeout(function() {${3}}${2}, ${1:10};
|
||||
# Get Elements
|
||||
snippet get
|
||||
getElementsBy${1:TagName}('${2}')${3}
|
||||
# Get Element
|
||||
snippet gett
|
||||
getElementBy${1:Id}('${2}')${3}
|
||||
@@ -1,54 +0,0 @@
|
||||
snippet def
|
||||
<%def name="${1:name}">
|
||||
${2:}
|
||||
</%def>
|
||||
snippet call
|
||||
<%call expr="${1:name}">
|
||||
${2:}
|
||||
</%call>
|
||||
snippet doc
|
||||
<%doc>
|
||||
${1:}
|
||||
</%doc>
|
||||
snippet text
|
||||
<%text>
|
||||
${1:}
|
||||
</%text>
|
||||
snippet for
|
||||
% for ${1:i} in ${2:iter}:
|
||||
${3:}
|
||||
% endfor
|
||||
snippet if if
|
||||
% if ${1:condition}:
|
||||
${2:}
|
||||
% endif
|
||||
snippet if if/else
|
||||
% if ${1:condition}:
|
||||
${2:}
|
||||
% else:
|
||||
${3:}
|
||||
% endif
|
||||
snippet try
|
||||
% try:
|
||||
${1:}
|
||||
% except${2:}:
|
||||
${3:pass}
|
||||
% endtry
|
||||
snippet wh
|
||||
% while ${1:}:
|
||||
${2:}
|
||||
% endwhile
|
||||
snippet $
|
||||
${ ${1:} }
|
||||
snippet <%
|
||||
<% ${1:} %>
|
||||
snippet <!%
|
||||
<!% ${1:} %>
|
||||
snippet inherit
|
||||
<%inherit file="${1:filename}" />
|
||||
snippet include
|
||||
<%include file="${1:filename}" />
|
||||
snippet namespace
|
||||
<%namespace file="${1:name}" />
|
||||
snippet page
|
||||
<%page args="${1:}" />
|
||||
@@ -1,247 +0,0 @@
|
||||
# #import <...>
|
||||
snippet Imp
|
||||
#import <${1:Cocoa/Cocoa.h}>${2}
|
||||
# #import "..."
|
||||
snippet imp
|
||||
#import "${1:`Filename()`.h}"${2}
|
||||
# @selector(...)
|
||||
snippet sel
|
||||
@selector(${1:method}:)${3}
|
||||
# @"..." string
|
||||
snippet s
|
||||
@"${1}"${2}
|
||||
# Object
|
||||
snippet o
|
||||
${1:NSObject} *${2:foo} = [${3:$1 alloc}]${4};${5}
|
||||
# NSLog(...)
|
||||
snippet log
|
||||
NSLog(@"${1:%@}"${2});${3}
|
||||
# Class
|
||||
snippet objc
|
||||
@interface ${1:`Filename('', 'someClass')`} : ${2:NSObject}
|
||||
{
|
||||
}
|
||||
@end
|
||||
|
||||
@implementation $1
|
||||
${3}
|
||||
@end
|
||||
# Class Interface
|
||||
snippet int
|
||||
@interface ${1:`Filename('', 'someClass')`} : ${2:NSObject}
|
||||
{${3}
|
||||
}
|
||||
${4}
|
||||
@end
|
||||
snippet @interface
|
||||
@interface ${1:`Filename('', 'someClass')`} : ${2:NSObject}
|
||||
{${3}
|
||||
}
|
||||
${4}
|
||||
@end
|
||||
# Class Implementation
|
||||
snippet impl
|
||||
@implementation ${1:`Filename('', 'someClass')`}
|
||||
${2}
|
||||
@end
|
||||
snippet @implementation
|
||||
@implementation ${1:`Filename('', 'someClass')`}
|
||||
${2}
|
||||
@end
|
||||
# Protocol
|
||||
snippet pro
|
||||
@protocol ${1:`Filename('$1Delegate', 'MyProtocol')`} ${2:<NSObject>}
|
||||
${3}
|
||||
@end
|
||||
snippet @protocol
|
||||
@protocol ${1:`Filename('$1Delegate', 'MyProtocol')`} ${2:<NSObject>}
|
||||
${3}
|
||||
@end
|
||||
# init Definition
|
||||
snippet init
|
||||
- (id)init
|
||||
{
|
||||
if (self = [super init]) {
|
||||
${1}
|
||||
}
|
||||
return self;
|
||||
}
|
||||
# dealloc Definition
|
||||
snippet dealloc
|
||||
- (void) dealloc
|
||||
{
|
||||
${1:deallocations}
|
||||
[super dealloc];
|
||||
}
|
||||
snippet su
|
||||
[super ${1:init}]${2}
|
||||
snippet ibo
|
||||
IBOutlet ${1:NSSomeClass} *${2:$1};${3}
|
||||
# Category
|
||||
snippet cat
|
||||
@interface ${1:NSObject} (${2:MyCategory})
|
||||
@end
|
||||
|
||||
@implementation $1 ($2)
|
||||
${3}
|
||||
@end
|
||||
# Category Interface
|
||||
snippet cath
|
||||
@interface ${1:`Filename('$1', 'NSObject')`} (${2:MyCategory})
|
||||
${3}
|
||||
@end
|
||||
# Method
|
||||
snippet m
|
||||
- (${1:id})${2:method}
|
||||
{
|
||||
${3}
|
||||
}
|
||||
# Method declaration
|
||||
snippet md
|
||||
- (${1:id})${2:method};${3}
|
||||
# IBAction declaration
|
||||
snippet ibad
|
||||
- (IBAction)${1:method}:(${2:id})sender;${3}
|
||||
# IBAction method
|
||||
snippet iba
|
||||
- (IBAction)${1:method}:(${2:id})sender
|
||||
{
|
||||
${3}
|
||||
}
|
||||
# awakeFromNib method
|
||||
snippet wake
|
||||
- (void)awakeFromNib
|
||||
{
|
||||
${1}
|
||||
}
|
||||
# Class Method
|
||||
snippet M
|
||||
+ (${1:id})${2:method}
|
||||
{
|
||||
${3:return nil;}
|
||||
}
|
||||
# Sub-method (Call super)
|
||||
snippet sm
|
||||
- (${1:id})${2:method}
|
||||
{
|
||||
[super $2];${3}
|
||||
return self;
|
||||
}
|
||||
# Accessor Methods For:
|
||||
# Object
|
||||
snippet objacc
|
||||
- (${1:id})${2:thing}
|
||||
{
|
||||
return $2;
|
||||
}
|
||||
|
||||
- (void)set$2:($1)${3:new$2}
|
||||
{
|
||||
[$3 retain];
|
||||
[$2 release];
|
||||
$2 = $3;
|
||||
}${4}
|
||||
# for (object in array)
|
||||
snippet forin
|
||||
for (${1:Class} *${2:some$1} in ${3:array}) {
|
||||
${4}
|
||||
}
|
||||
snippet fore
|
||||
for (${1:object} in ${2:array}) {
|
||||
${3:statements}
|
||||
}
|
||||
snippet forarray
|
||||
unsigned int ${1:object}Count = [${2:array} count];
|
||||
|
||||
for (unsigned int index = 0; index < $1Count; index++) {
|
||||
${3:id} $1 = [$2 $1AtIndex:index];
|
||||
${4}
|
||||
}
|
||||
snippet fora
|
||||
unsigned int ${1:object}Count = [${2:array} count];
|
||||
|
||||
for (unsigned int index = 0; index < $1Count; index++) {
|
||||
${3:id} $1 = [$2 $1AtIndex:index];
|
||||
${4}
|
||||
}
|
||||
# Try / Catch Block
|
||||
snippet @try
|
||||
@try {
|
||||
${1:statements}
|
||||
}
|
||||
@catch (NSException * e) {
|
||||
${2:handler}
|
||||
}
|
||||
@finally {
|
||||
${3:statements}
|
||||
}
|
||||
snippet @catch
|
||||
@catch (${1:exception}) {
|
||||
${2:handler}
|
||||
}
|
||||
snippet @finally
|
||||
@finally {
|
||||
${1:statements}
|
||||
}
|
||||
# IBOutlet
|
||||
# @property (Objective-C 2.0)
|
||||
snippet prop
|
||||
@property (${1:retain}) ${2:NSSomeClass} ${3:*$2};${4}
|
||||
# @synthesize (Objective-C 2.0)
|
||||
snippet syn
|
||||
@synthesize ${1:property};${2}
|
||||
# [[ alloc] init]
|
||||
snippet alloc
|
||||
[[${1:foo} alloc] init${2}];${3}
|
||||
snippet a
|
||||
[[${1:foo} alloc] init${2}];${3}
|
||||
# retain
|
||||
snippet ret
|
||||
[${1:foo} retain];${2}
|
||||
# release
|
||||
snippet rel
|
||||
[${1:foo} release];
|
||||
# autorelease
|
||||
snippet arel
|
||||
[${1:foo} autorelease];
|
||||
# autorelease pool
|
||||
snippet pool
|
||||
NSAutoreleasePool *${1:pool} = [[NSAutoreleasePool alloc] init];
|
||||
${2:/* code */}
|
||||
[$1 drain];
|
||||
# Throw an exception
|
||||
snippet except
|
||||
NSException *${1:badness};
|
||||
$1 = [NSException exceptionWithName:@"${2:$1Name}"
|
||||
reason:@"${3}"
|
||||
userInfo:nil];
|
||||
[$1 raise];
|
||||
snippet prag
|
||||
#pragma mark ${1:-}
|
||||
snippet cl
|
||||
@class ${1:Foo};${2}
|
||||
snippet color
|
||||
[[NSColor ${1:blackColor}] set];
|
||||
# NSArray
|
||||
snippet array
|
||||
NSMutableArray *${1:array} = [NSMutable array];${2}
|
||||
snippet nsa
|
||||
NSArray ${1}
|
||||
snippet nsma
|
||||
NSMutableArray ${1}
|
||||
snippet aa
|
||||
NSArray * array;${1}
|
||||
snippet ma
|
||||
NSMutableArray * array;${1}
|
||||
# NSDictionary
|
||||
snippet dict
|
||||
NSMutableDictionary *${1:dict} = [NSMutableDictionary dictionary];${2}
|
||||
snippet nsd
|
||||
NSDictionary ${1}
|
||||
snippet nsmd
|
||||
NSMutableDictionary ${1}
|
||||
# NSString
|
||||
snippet nss
|
||||
NSString ${1}
|
||||
snippet nsms
|
||||
NSMutableString ${1}
|
||||
@@ -1,97 +0,0 @@
|
||||
# #!/usr/bin/perl
|
||||
snippet #!
|
||||
#!/usr/bin/perl
|
||||
|
||||
# Hash Pointer
|
||||
snippet .
|
||||
=>
|
||||
# Function
|
||||
snippet sub
|
||||
sub ${1:function_name} {
|
||||
${2:#body ...}
|
||||
}
|
||||
# Conditional
|
||||
snippet if
|
||||
if (${1}) {
|
||||
${2:# body...}
|
||||
}
|
||||
# Conditional if..else
|
||||
snippet ife
|
||||
if (${1}) {
|
||||
${2:# body...}
|
||||
}
|
||||
else {
|
||||
${3:# else...}
|
||||
}
|
||||
# Conditional if..elsif..else
|
||||
snippet ifee
|
||||
if (${1}) {
|
||||
${2:# body...}
|
||||
}
|
||||
elsif (${3}) {
|
||||
${4:# elsif...}
|
||||
}
|
||||
else {
|
||||
${5:# else...}
|
||||
}
|
||||
# Conditional One-line
|
||||
snippet xif
|
||||
${1:expression} if ${2:condition};${3}
|
||||
# Unless conditional
|
||||
snippet unless
|
||||
unless (${1}) {
|
||||
${2:# body...}
|
||||
}
|
||||
# Unless conditional One-line
|
||||
snippet xunless
|
||||
${1:expression} unless ${2:condition};${3}
|
||||
# Try/Except
|
||||
snippet eval
|
||||
eval {
|
||||
${1:# do something risky...}
|
||||
};
|
||||
if ($@) {
|
||||
${2:# handle failure...}
|
||||
}
|
||||
# While Loop
|
||||
snippet wh
|
||||
while (${1}) {
|
||||
${2:# body...}
|
||||
}
|
||||
# While Loop One-line
|
||||
snippet xwh
|
||||
${1:expression} while ${2:condition};${3}
|
||||
# C-style For Loop
|
||||
snippet cfor
|
||||
for (my $${2:var} = 0; $$2 < ${1:count}; $$2${3:++}) {
|
||||
${4:# body...}
|
||||
}
|
||||
# For loop one-line
|
||||
snippet xfor
|
||||
${1:expression} for @${2:array};${3}
|
||||
# Foreach Loop
|
||||
snippet for
|
||||
foreach my $${1:x} (@${2:array}) {
|
||||
${3:# body...}
|
||||
}
|
||||
# Foreach Loop One-line
|
||||
snippet fore
|
||||
${1:expression} foreach @${2:array};${3}
|
||||
# Package
|
||||
snippet cl
|
||||
package ${1:ClassName};
|
||||
|
||||
use base qw(${2:ParentClass});
|
||||
|
||||
sub new {
|
||||
my $class = shift;
|
||||
$class = ref $class if ref $class;
|
||||
my $self = bless {}, $class;
|
||||
$self;
|
||||
}
|
||||
|
||||
1;${3}
|
||||
# Read File
|
||||
snippet slurp
|
||||
my $${1:var};
|
||||
{ local $/ = undef; local *FILE; open FILE, "<${2:file}"; $$1 = <FILE>; close FILE }${3}
|
||||
@@ -1,222 +0,0 @@
|
||||
snippet php
|
||||
<?php
|
||||
${1}
|
||||
?>
|
||||
snippet ec
|
||||
echo "${1:string}"${2};
|
||||
snippet inc
|
||||
include '${1:file}';${2}
|
||||
snippet inc1
|
||||
include_once '${1:file}';${2}
|
||||
snippet req
|
||||
require '${1:file}';${2}
|
||||
snippet req1
|
||||
require_once '${1:file}';${2}
|
||||
# $GLOBALS['...']
|
||||
snippet globals
|
||||
$GLOBALS['${1:variable}']${2: = }${3:something}${4:;}${5}
|
||||
snippet $_ COOKIE['...']
|
||||
$_COOKIE['${1:variable}']${2}
|
||||
snippet $_ ENV['...']
|
||||
$_ENV['${1:variable}']${2}
|
||||
snippet $_ FILES['...']
|
||||
$_FILES['${1:variable}']${2}
|
||||
snippet $_ Get['...']
|
||||
$_GET['${1:variable}']${2}
|
||||
snippet $_ POST['...']
|
||||
$_POST['${1:variable}']${2}
|
||||
snippet $_ REQUEST['...']
|
||||
$_REQUEST['${1:variable}']${2}
|
||||
snippet $_ SERVER['...']
|
||||
$_SERVER['${1:variable}']${2}
|
||||
snippet $_ SESSION['...']
|
||||
$_SESSION['${1:variable}']${2}
|
||||
# Start Docblock
|
||||
snippet /*
|
||||
/**
|
||||
* ${1}
|
||||
**/
|
||||
# Class - post doc
|
||||
snippet doc_cp
|
||||
/**
|
||||
* ${1:undocumented class}
|
||||
*
|
||||
* @package ${2:default}
|
||||
* @author ${3:`g:snips_author`}
|
||||
**/${4}
|
||||
# Class Variable - post doc
|
||||
snippet doc_vp
|
||||
/**
|
||||
* ${1:undocumented class variable}
|
||||
*
|
||||
* @var ${2:string}
|
||||
**/${3}
|
||||
# Class Variable
|
||||
snippet doc_v
|
||||
/**
|
||||
* ${3:undocumented class variable}
|
||||
*
|
||||
* @var ${4:string}
|
||||
**/
|
||||
${1:var} $${2};${5}
|
||||
# Class
|
||||
snippet doc_c
|
||||
/**
|
||||
* ${3:undocumented class}
|
||||
*
|
||||
* @packaged ${4:default}
|
||||
* @author ${5:`g:snips_author`}
|
||||
**/
|
||||
${1:}class ${2:}
|
||||
{${6}
|
||||
} // END $1class $2
|
||||
# Constant Definition - post doc
|
||||
snippet doc_dp
|
||||
/**
|
||||
* ${1:undocumented constant}
|
||||
**/${2}
|
||||
# Constant Definition
|
||||
snippet doc_d
|
||||
/**
|
||||
* ${3:undocumented constant}
|
||||
**/
|
||||
define(${1}, ${2});${4}
|
||||
# Function - post doc
|
||||
snippet doc_fp
|
||||
/**
|
||||
* ${1:undocumented function}
|
||||
*
|
||||
* @return ${2:void}
|
||||
* @author ${3:`g:snips_author`}
|
||||
**/${4}
|
||||
# Function signature
|
||||
snippet doc_s
|
||||
/**
|
||||
* ${4:undocumented function}
|
||||
*
|
||||
* @return ${5:void}
|
||||
* @author ${6:`g:snips_author`}
|
||||
**/
|
||||
${1}function ${2}(${3});${7}
|
||||
# Function
|
||||
snippet doc_f
|
||||
/**
|
||||
* ${4:undocumented function}
|
||||
*
|
||||
* @return ${5:void}
|
||||
* @author ${6:`g:snips_author`}
|
||||
**/
|
||||
${1}function ${2}(${3})
|
||||
{${7}
|
||||
}
|
||||
# Header
|
||||
snippet doc_h
|
||||
/**
|
||||
* ${1}
|
||||
*
|
||||
* @author ${2:`g:snips_author`}
|
||||
* @version ${3:$Id$}
|
||||
* @copyright ${4:$2}, `strftime('%d %B, %Y')`
|
||||
* @package ${5:default}
|
||||
**/
|
||||
|
||||
/**
|
||||
* Define DocBlock
|
||||
*//
|
||||
# Interface
|
||||
snippet doc_i
|
||||
/**
|
||||
* ${2:undocumented class}
|
||||
*
|
||||
* @package ${3:default}
|
||||
* @author ${4:`g:snips_author`}
|
||||
**/
|
||||
interface ${1:}
|
||||
{${5}
|
||||
} // END interface $1
|
||||
# class ...
|
||||
snippet class
|
||||
/**
|
||||
* ${1}
|
||||
**/
|
||||
class ${2:ClassName}
|
||||
{
|
||||
${3}
|
||||
function ${4:__construct}(${5:argument})
|
||||
{
|
||||
${6:// code...}
|
||||
}
|
||||
}
|
||||
# define(...)
|
||||
snippet def
|
||||
define('${1}'${2});${3}
|
||||
# defined(...)
|
||||
snippet def?
|
||||
${1}defined('${2}')${3}
|
||||
snippet wh
|
||||
while (${1:/* condition */}) {
|
||||
${2:// code...}
|
||||
}
|
||||
# do ... while
|
||||
snippet do
|
||||
do {
|
||||
${2:// code... }
|
||||
} while (${1:/* condition */});
|
||||
snippet if
|
||||
if (${1:/* condition */}) {
|
||||
${2:// code...}
|
||||
}
|
||||
snippet ife
|
||||
if (${1:/* condition */}) {
|
||||
${2:// code...}
|
||||
} else {
|
||||
${3:// code...}
|
||||
}
|
||||
${4}
|
||||
snippet else
|
||||
else {
|
||||
${1:// code...}
|
||||
}
|
||||
snippet elseif
|
||||
elseif (${1:/* condition */}) {
|
||||
${2:// code...}
|
||||
}
|
||||
# Tertiary conditional
|
||||
snippet t
|
||||
$${1:retVal} = (${2:condition}) ? ${3:a} : ${4:b};${5}
|
||||
snippet switch
|
||||
switch ($${1:variable}) {
|
||||
case '${2:value}':
|
||||
${3:// code...}
|
||||
break;
|
||||
${5}
|
||||
default:
|
||||
${4:// code...}
|
||||
break;
|
||||
}
|
||||
snippet case
|
||||
case '${1:value}':
|
||||
${2:// code...}
|
||||
break;${3}
|
||||
snippet for
|
||||
for ($${2:i} = 0; $$2 < ${1:count}; $$2${3:++}) {
|
||||
${4: // code...}
|
||||
}
|
||||
snippet foreach
|
||||
foreach ($${1:variable} as $${2:key}) {
|
||||
${3:// code...}
|
||||
}
|
||||
snippet fun
|
||||
${1:public }function ${2:FunctionName}(${3})
|
||||
{
|
||||
${4:// code...}
|
||||
}
|
||||
# $... = array (...)
|
||||
snippet array
|
||||
$${1:arrayName} = array('${2}' => ${3});${4}
|
||||
snippet arr
|
||||
array(
|
||||
'${1:key}' => ${2:value}
|
||||
);
|
||||
snippet a
|
||||
array('${1:key}' => ${2:value});
|
||||
@@ -1,221 +0,0 @@
|
||||
snippet php
|
||||
<?php
|
||||
${1}
|
||||
?>
|
||||
snippet ec
|
||||
echo "${1:string}"${2};
|
||||
snippet {
|
||||
{
|
||||
${1}
|
||||
}
|
||||
snippet inc
|
||||
include '${1:file}';${2}
|
||||
snippet inc1
|
||||
include_once '${1:file}';${2}
|
||||
snippet req
|
||||
require '${1:file}';${2}
|
||||
snippet req1
|
||||
require_once '${1:file}';${2}
|
||||
# $GLOBALS['...']
|
||||
snippet globals
|
||||
$GLOBALS['${1:variable}']${2: = }${3:something}${4:;}${5}
|
||||
snippet $_ COOKIE['...']
|
||||
$_COOKIE['${1:variable}']${2}
|
||||
snippet $_ ENV['...']
|
||||
$_ENV['${1:variable}']${2}
|
||||
snippet $_ FILES['...']
|
||||
$_FILES['${1:variable}']${2}
|
||||
snippet $_ Get['...']
|
||||
$_GET['${1:variable}']${2}
|
||||
snippet $_ POST['...']
|
||||
$_POST['${1:variable}']${2}
|
||||
snippet $_ REQUEST['...']
|
||||
$_REQUEST['${1:variable}']${2}
|
||||
snippet $_ SERVER['...']
|
||||
$_SERVER['${1:variable}']${2}
|
||||
snippet $_ SESSION['...']
|
||||
$_SESSION['${1:variable}']${2}
|
||||
# Start Docblock
|
||||
snippet /*
|
||||
/**
|
||||
* ${1:description}
|
||||
*
|
||||
* @param ${2:int} ${3:var} ${4:desc}
|
||||
* @return ${5:int} ${6:desc}
|
||||
* @access ${7:public}
|
||||
**/
|
||||
# Class - post doc
|
||||
snippet doc_cp
|
||||
/**
|
||||
* ${1:undocumented class}
|
||||
*
|
||||
* @package ${2:default}
|
||||
* @author ${3:`g:snips_author`}
|
||||
**/${4}
|
||||
# Class Variable - post doc
|
||||
snippet doc_vp
|
||||
/**
|
||||
* ${1:undocumented class variable}
|
||||
*
|
||||
* @var ${2:string}
|
||||
**/${3}
|
||||
# Class Variable
|
||||
snippet doc_v
|
||||
/**
|
||||
* ${3:undocumented class variable}
|
||||
*
|
||||
* @var ${4:string}
|
||||
**/
|
||||
${1:var} $${2};${5}
|
||||
# Class
|
||||
snippet doc_c
|
||||
/**
|
||||
* ${3:undocumented class}
|
||||
*
|
||||
* @packaged ${4:default}
|
||||
* @author ${5:`g:snips_author`}
|
||||
**/
|
||||
${1:}class ${2:}
|
||||
{${6}
|
||||
} // END $1class $2
|
||||
# Constant Definition - post doc
|
||||
snippet doc_dp
|
||||
/**
|
||||
* ${1:undocumented constant}
|
||||
**/${2}
|
||||
# Constant Definition
|
||||
snippet doc_d
|
||||
/**
|
||||
* ${3:undocumented constant}
|
||||
**/
|
||||
define(${1}, ${2});${4}
|
||||
# Function - post doc
|
||||
snippet doc_fp
|
||||
/**
|
||||
* ${1:undocumented function}
|
||||
*
|
||||
* @return ${2:void}
|
||||
* @author ${3:`g:snips_author`}
|
||||
**/${4}
|
||||
# Function signature
|
||||
snippet doc_s
|
||||
/**
|
||||
* ${4:undocumented function}
|
||||
*
|
||||
* @return ${5:void}
|
||||
* @author ${6:`g:snips_author`}
|
||||
**/
|
||||
${1}function ${2}(${3});${7}
|
||||
# Function
|
||||
snippet doc_f
|
||||
/**
|
||||
* ${4:undocumented function}
|
||||
*
|
||||
* @return ${5:void}
|
||||
* @author ${6:`g:snips_author`}
|
||||
**/
|
||||
${1}function ${2}(${3})
|
||||
{${7}
|
||||
}
|
||||
# Header
|
||||
snippet doc_h
|
||||
/**
|
||||
* ${1}
|
||||
*
|
||||
* @author ${2:`g:snips_author`}
|
||||
* @version ${3:$Id$}
|
||||
* @copyright ${4:$2}, `strftime('%d %B, %Y')`
|
||||
* @package ${5:default}
|
||||
**/
|
||||
|
||||
/**
|
||||
* Define DocBlock
|
||||
*//
|
||||
# Interface
|
||||
snippet doc_i
|
||||
/**
|
||||
* ${2:undocumented class}
|
||||
*
|
||||
* @package ${3:default}
|
||||
* @author ${4:`g:snips_author`}
|
||||
**/
|
||||
interface ${1:}
|
||||
{${5}
|
||||
} // END interface $1
|
||||
# class ...
|
||||
snippet class
|
||||
class ${1:ClassName} ${2:extends} ${3:ClassName} {
|
||||
${4}
|
||||
}
|
||||
# define(...)
|
||||
snippet def
|
||||
define('${1}', ${2});${3}
|
||||
# defined(...)
|
||||
snippet def?
|
||||
${1}defined('${2}')${3}
|
||||
snippet while
|
||||
while (${1:/* condition */}) {
|
||||
${2:// code...}
|
||||
}
|
||||
# do ... while
|
||||
snippet do
|
||||
do {
|
||||
${2:// code... }
|
||||
} while (${1:/* condition */});
|
||||
snippet if
|
||||
if (${1:/* condition */}) {
|
||||
${2:// code...}
|
||||
}
|
||||
snippet ife
|
||||
if (${1:/* condition */}) {
|
||||
${2:// code...}
|
||||
} else {
|
||||
${3:// code...}
|
||||
}
|
||||
${4}
|
||||
snippet else
|
||||
else {
|
||||
${1:// code...}
|
||||
}
|
||||
snippet elseif
|
||||
elseif (${1:/* condition */}) {
|
||||
${2:// code...}
|
||||
}
|
||||
# Tertiary conditional
|
||||
snippet t
|
||||
$${1:retVal} = (${2:condition}) ? ${3:a} : ${4:b};${5}
|
||||
snippet switch
|
||||
switch ($${1:variable}) {
|
||||
case '${2:value}':
|
||||
${3:// code...}
|
||||
break;
|
||||
${5}
|
||||
default:
|
||||
${4:// code...}
|
||||
break;
|
||||
}
|
||||
snippet case
|
||||
case '${1:value}':
|
||||
${2:// code...}
|
||||
break;${3}
|
||||
snippet for
|
||||
for ($${1:i}=${2:0}; $$1 < ${3:count}; $$1${4:++}) {
|
||||
${5: // code...}
|
||||
}
|
||||
snippet foreach
|
||||
foreach ($${1:variable} as $${2:key}) {
|
||||
${3:// code...}
|
||||
}
|
||||
snippet fun
|
||||
${1:public} function ${2:FunctionName}(${3}) {
|
||||
${4}
|
||||
}
|
||||
# $... = array (...)
|
||||
snippet ar
|
||||
$${1:arrayName} = array(${2:key} => ${3:value});
|
||||
snippet a
|
||||
array(${1})
|
||||
snippet arr
|
||||
array(
|
||||
${1}
|
||||
)
|
||||
@@ -1,86 +0,0 @@
|
||||
snippet #!
|
||||
#!/usr/bin/env python
|
||||
|
||||
snippet imp
|
||||
import ${1:module}
|
||||
# Module Docstring
|
||||
snippet docs
|
||||
'''
|
||||
File: ${1:`Filename('$1.py', 'foo.py')`}
|
||||
Author: ${2:`g:snips_author`}
|
||||
Description: ${3}
|
||||
'''
|
||||
snippet wh
|
||||
while ${1:condition}:
|
||||
${2:# code...}
|
||||
snippet for
|
||||
for ${1:needle} in ${2:haystack}:
|
||||
${3:# code...}
|
||||
# New Class
|
||||
snippet cl
|
||||
class ${1:ClassName}(${2:object}):
|
||||
"""${3:docstring for $1}"""
|
||||
def __init__(self, ${4:arg}):
|
||||
${5:super($1, self).__init__()}
|
||||
self.$4 = $4
|
||||
${6}
|
||||
# New Function
|
||||
snippet def
|
||||
def ${1:fname}(${2:`indent('.') ? 'self' : ''`}):
|
||||
"""${3:docstring for $1}"""
|
||||
${4:pass}
|
||||
snippet deff
|
||||
def ${1:fname}(${2:`indent('.') ? 'self' : ''`}):
|
||||
${3}
|
||||
# New Method
|
||||
snippet defs
|
||||
def ${1:mname}(self, ${2:arg}):
|
||||
${3:pass}
|
||||
# New Property
|
||||
snippet property
|
||||
def ${1:foo}():
|
||||
doc = "${2:The $1 property.}"
|
||||
def fget(self):
|
||||
${3:return self._$1}
|
||||
def fset(self, value):
|
||||
${4:self._$1 = value}
|
||||
# Lambda
|
||||
snippet ld
|
||||
${1:var} = lambda ${2:vars} : ${3:action}
|
||||
snippet .
|
||||
self.
|
||||
snippet try Try/Except
|
||||
try:
|
||||
${1:pass}
|
||||
except ${2:Exception}, ${3:e}:
|
||||
${4:raise $3}
|
||||
snippet try Try/Except/Else
|
||||
try:
|
||||
${1:pass}
|
||||
except ${2:Exception}, ${3:e}:
|
||||
${4:raise $3}
|
||||
else:
|
||||
${5:pass}
|
||||
snippet try Try/Except/Finally
|
||||
try:
|
||||
${1:pass}
|
||||
except ${2:Exception}, ${3:e}:
|
||||
${4:raise $3}
|
||||
finally:
|
||||
${5:pass}
|
||||
snippet try Try/Except/Else/Finally
|
||||
try:
|
||||
${1:pass}
|
||||
except ${2:Exception}, ${3:e}:
|
||||
${4:raise $3}
|
||||
else:
|
||||
${5:pass}
|
||||
finally:
|
||||
${6:pass}
|
||||
# if __name__ == '__main__':
|
||||
snippet ifmain
|
||||
if __name__ == '__main__':
|
||||
${1:main()}
|
||||
# __magic__
|
||||
snippet _
|
||||
__${1:init}__${2}
|
||||
@@ -1,504 +0,0 @@
|
||||
# #!/usr/bin/env ruby
|
||||
snippet #!
|
||||
#!/usr/bin/env ruby
|
||||
|
||||
# New Block
|
||||
snippet =b
|
||||
=begin rdoc
|
||||
${1}
|
||||
=end
|
||||
snippet y
|
||||
:yields: ${1:arguments}
|
||||
snippet rb
|
||||
#!/usr/bin/env ruby -wKU
|
||||
snippet beg
|
||||
begin
|
||||
${3}
|
||||
rescue ${1:Exception} => ${2:e}
|
||||
end
|
||||
|
||||
snippet req
|
||||
require "${1}"${2}
|
||||
snippet #
|
||||
# =>
|
||||
snippet end
|
||||
__END__
|
||||
snippet case
|
||||
case ${1:object}
|
||||
when ${2:condition}
|
||||
${3}
|
||||
end
|
||||
snippet when
|
||||
when ${1:condition}
|
||||
${2}
|
||||
snippet def
|
||||
def ${1:method_name}
|
||||
${2}
|
||||
end
|
||||
snippet deft
|
||||
def test_${1:case_name}
|
||||
${2}
|
||||
end
|
||||
snippet if
|
||||
if ${1:condition}
|
||||
${2}
|
||||
end
|
||||
snippet ife
|
||||
if ${1:condition}
|
||||
${2}
|
||||
else
|
||||
${3}
|
||||
end
|
||||
snippet elsif
|
||||
elsif ${1:condition}
|
||||
${2}
|
||||
snippet unless
|
||||
unless ${1:condition}
|
||||
${2}
|
||||
end
|
||||
snippet while
|
||||
while ${1:condition}
|
||||
${2}
|
||||
end
|
||||
snippet for
|
||||
for ${1:e} in ${2:c}
|
||||
${3}
|
||||
end
|
||||
snippet until
|
||||
until ${1:condition}
|
||||
${2}
|
||||
end
|
||||
snippet cla class .. end
|
||||
class ${1:`substitute(Filename(), '^.', '\u&', '')`}
|
||||
${2}
|
||||
end
|
||||
snippet cla class .. initialize .. end
|
||||
class ${1:`substitute(Filename(), '^.', '\u&', '')`}
|
||||
def initialize(${2:args})
|
||||
${3}
|
||||
end
|
||||
|
||||
|
||||
end
|
||||
snippet cla class .. < ParentClass .. initialize .. end
|
||||
class ${1:`substitute(Filename(), '^.', '\u&', '')`} < ${2:ParentClass}
|
||||
def initialize(${3:args})
|
||||
${4}
|
||||
end
|
||||
|
||||
|
||||
end
|
||||
snippet cla ClassName = Struct .. do .. end
|
||||
${1:`substitute(Filename(), '^.', '\u&', '')`} = Struct.new(:${2:attr_names}) do
|
||||
def ${3:method_name}
|
||||
${4}
|
||||
end
|
||||
|
||||
|
||||
end
|
||||
snippet cla class BlankSlate .. initialize .. end
|
||||
class ${1:BlankSlate}
|
||||
instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A__/ }
|
||||
snippet cla class << self .. end
|
||||
class << ${1:self}
|
||||
${2}
|
||||
end
|
||||
# class .. < DelegateClass .. initialize .. end
|
||||
snippet cla-
|
||||
class ${1:`substitute(Filename(), '^.', '\u&', '')`} < DelegateClass(${2:ParentClass})
|
||||
def initialize(${3:args})
|
||||
super(${4:del_obj})
|
||||
|
||||
${5}
|
||||
end
|
||||
|
||||
|
||||
end
|
||||
snippet mod module .. end
|
||||
module ${1:`substitute(Filename(), '^.', '\u&', '')`}
|
||||
${2}
|
||||
end
|
||||
snippet mod module .. module_function .. end
|
||||
module ${1:`substitute(Filename(), '^.', '\u&', '')`}
|
||||
module_function
|
||||
|
||||
${2}
|
||||
end
|
||||
snippet mod module .. ClassMethods .. end
|
||||
module ${1:`substitute(Filename(), '^.', '\u&', '')`}
|
||||
module ClassMethods
|
||||
${2}
|
||||
end
|
||||
|
||||
module InstanceMethods
|
||||
|
||||
end
|
||||
|
||||
def self.included(receiver)
|
||||
receiver.extend ClassMethods
|
||||
receiver.send :include, InstanceMethods
|
||||
end
|
||||
end
|
||||
# attr_reader
|
||||
snippet r
|
||||
attr_reader :${1:attr_names}
|
||||
# attr_writer
|
||||
snippet w
|
||||
attr_writer :${1:attr_names}
|
||||
# attr_accessor
|
||||
snippet rw
|
||||
attr_accessor :${1:attr_names}
|
||||
# include Enumerable
|
||||
snippet Enum
|
||||
include Enumerable
|
||||
|
||||
def each(&block)
|
||||
${1}
|
||||
end
|
||||
# include Comparable
|
||||
snippet Comp
|
||||
include Comparable
|
||||
|
||||
def <=>(other)
|
||||
${1}
|
||||
end
|
||||
# extend Forwardable
|
||||
snippet Forw-
|
||||
extend Forwardable
|
||||
# def self
|
||||
snippet defs
|
||||
def self.${1:class_method_name}
|
||||
${2}
|
||||
end
|
||||
# def method_missing
|
||||
snippet defmm
|
||||
def method_missing(meth, *args, &blk)
|
||||
${1}
|
||||
end
|
||||
snippet defd
|
||||
def_delegator :${1:@del_obj}, :${2:del_meth}, :${3:new_name}
|
||||
snippet defds
|
||||
def_delegators :${1:@del_obj}, :${2:del_methods}
|
||||
snippet am
|
||||
alias_method :${1:new_name}, :${2:old_name}
|
||||
snippet app
|
||||
if __FILE__ == $PROGRAM_NAME
|
||||
${1}
|
||||
end
|
||||
# usage_if()
|
||||
snippet usai
|
||||
if ARGV.${1}
|
||||
abort "Usage: #{$PROGRAM_NAME} ${2:ARGS_GO_HERE}"${3}
|
||||
end
|
||||
# usage_unless()
|
||||
snippet usau
|
||||
unless ARGV.${1}
|
||||
abort "Usage: #{$PROGRAM_NAME} ${2:ARGS_GO_HERE}"${3}
|
||||
end
|
||||
snippet array
|
||||
Array.new(${1:10}) { |${2:i}| ${3} }
|
||||
snippet hash
|
||||
Hash.new { |${1:hash}, ${2:key}| $1[$2] = ${3} }
|
||||
snippet file File.foreach() { |line| .. }
|
||||
File.foreach(${1:"path/to/file"}) { |${2:line}| ${3} }
|
||||
snippet file File.read()
|
||||
File.read(${1:"path/to/file"})${2}
|
||||
snippet Dir Dir.global() { |file| .. }
|
||||
Dir.glob(${1:"dir/glob/*"}) { |${2:file}| ${3} }
|
||||
snippet Dir Dir[".."]
|
||||
Dir[${1:"glob/**/*.rb"}]${2}
|
||||
snippet dir
|
||||
Filename.dirname(__FILE__)
|
||||
snippet deli
|
||||
delete_if { |${1:e}| ${2} }
|
||||
snippet fil
|
||||
fill(${1:range}) { |${2:i}| ${3} }
|
||||
# flatten_once()
|
||||
snippet flao
|
||||
inject(Array.new) { |${1:arr}, ${2:a}| $1.push(*$2)}${3}
|
||||
snippet zip
|
||||
zip(${1:enums}) { |${2:row}| ${3} }
|
||||
# downto(0) { |n| .. }
|
||||
snippet dow
|
||||
downto(${1:0}) { |${2:n}| ${3} }
|
||||
snippet ste
|
||||
step(${1:2}) { |${2:n}| ${3} }
|
||||
snippet tim
|
||||
times { |${1:n}| ${2} }
|
||||
snippet upt
|
||||
upto(${1:1.0/0.0}) { |${2:n}| ${3} }
|
||||
snippet loo
|
||||
loop { ${1} }
|
||||
snippet ea
|
||||
each { |${1:e}| ${2} }
|
||||
snippet ead
|
||||
each do |${1:e}|
|
||||
${2}
|
||||
end
|
||||
snippet eab
|
||||
each_byte { |${1:byte}| ${2} }
|
||||
snippet eac- each_char { |chr| .. }
|
||||
each_char { |${1:chr}| ${2} }
|
||||
snippet eac- each_cons(..) { |group| .. }
|
||||
each_cons(${1:2}) { |${2:group}| ${3} }
|
||||
snippet eai
|
||||
each_index { |${1:i}| ${2} }
|
||||
snippet eaid
|
||||
each_index do |${1:i}|
|
||||
end
|
||||
snippet eak
|
||||
each_key { |${1:key}| ${2} }
|
||||
snippet eakd
|
||||
each_key do |${1:key}|
|
||||
${2}
|
||||
end
|
||||
snippet eal
|
||||
each_line { |${1:line}| ${2} }
|
||||
snippet eald
|
||||
each_line do |${1:line}|
|
||||
${2}
|
||||
end
|
||||
snippet eap
|
||||
each_pair { |${1:name}, ${2:val}| ${3} }
|
||||
snippet eapd
|
||||
each_pair do |${1:name}, ${2:val}|
|
||||
${3}
|
||||
end
|
||||
snippet eas-
|
||||
each_slice(${1:2}) { |${2:group}| ${3} }
|
||||
snippet easd-
|
||||
each_slice(${1:2}) do |${2:group}|
|
||||
${3}
|
||||
end
|
||||
snippet eav
|
||||
each_value { |${1:val}| ${2} }
|
||||
snippet eavd
|
||||
each_value do |${1:val}|
|
||||
${2}
|
||||
end
|
||||
snippet eawi
|
||||
each_with_index { |${1:e}, ${2:i}| ${3} }
|
||||
snippet eawid
|
||||
each_with_index do |${1:e},${2:i}|
|
||||
${3}
|
||||
end
|
||||
snippet reve
|
||||
reverse_each { |${1:e}| ${2} }
|
||||
snippet reved
|
||||
reverse_each do |${1:e}|
|
||||
${2}
|
||||
end
|
||||
snippet inj
|
||||
inject(${1:init}) { |${2:mem}, ${3:var}| ${4} }
|
||||
snippet injd
|
||||
inject(${1:init}) do |${2:mem}, ${3:var}|
|
||||
${4}
|
||||
end
|
||||
snippet map
|
||||
map { |${1:e}| ${2} }
|
||||
snippet mapd
|
||||
map do |${1:e}|
|
||||
${2}
|
||||
end
|
||||
snippet mapwi-
|
||||
enum_with_index.map { |${1:e}, ${2:i}| ${3} }
|
||||
snippet sor
|
||||
sort { |a, b| ${1} }
|
||||
snippet sorb
|
||||
sort_by { |${1:e}| ${2} }
|
||||
snippet ran
|
||||
sort_by { rand }
|
||||
snippet all
|
||||
all? { |${1:e}| ${2} }
|
||||
snippet any
|
||||
any? { |${1:e}| ${2} }
|
||||
snippet cl
|
||||
classify { |${1:e}| ${2} }
|
||||
snippet col
|
||||
collect { |${1:e}| ${2} }
|
||||
snippet cold
|
||||
collect do |${1:e}|
|
||||
${2}
|
||||
end
|
||||
snippet det
|
||||
detect { |${1:e}| ${2} }
|
||||
snippet detd
|
||||
detect do |${1:e}|
|
||||
${2}
|
||||
end
|
||||
snippet fet
|
||||
fetch(${1:name}) { |${2:key}| ${3} }
|
||||
snippet fin
|
||||
find { |${1:e}| ${2} }
|
||||
snippet find
|
||||
find do |${1:e}|
|
||||
${2}
|
||||
end
|
||||
snippet fina
|
||||
find_all { |${1:e}| ${2} }
|
||||
snippet finad
|
||||
find_all do |${1:e}|
|
||||
${2}
|
||||
end
|
||||
snippet gre
|
||||
grep(${1:/pattern/}) { |${2:match}| ${3} }
|
||||
snippet sub
|
||||
${1:g}sub(${2:/pattern/}) { |${3:match}| ${4} }
|
||||
snippet sca
|
||||
scan(${1:/pattern/}) { |${2:match}| ${3} }
|
||||
snippet scad
|
||||
scan(${1:/pattern/}) do |${2:match}|
|
||||
${3}
|
||||
end
|
||||
snippet max
|
||||
max { |a, b| ${1} }
|
||||
snippet min
|
||||
min { |a, b| ${1} }
|
||||
snippet par
|
||||
partition { |${1:e}| ${2} }
|
||||
snippet pard
|
||||
partition do |${1:e}|
|
||||
${2}
|
||||
end
|
||||
snippet rej
|
||||
reject { |${1:e}| ${2} }
|
||||
snippet rejd
|
||||
reject do |${1:e}|
|
||||
${2}
|
||||
end
|
||||
snippet sel
|
||||
select { |${1:e}| ${2} }
|
||||
snippet seld
|
||||
select do |${1:e}|
|
||||
${2}
|
||||
end
|
||||
snippet lam
|
||||
lambda { |${1:args}| ${2} }
|
||||
snippet do
|
||||
do |${1:variable}|
|
||||
${2}
|
||||
end
|
||||
snippet :
|
||||
:${1:key} => ${2:"value"}${3}
|
||||
snippet ope
|
||||
open(${1:"path/or/url/or/pipe"}, "${2:w}") { |${3:io}| ${4} }
|
||||
# path_from_here()
|
||||
snippet patfh
|
||||
File.join(File.dirname(__FILE__), *%2[${1:rel path here}])${2}
|
||||
# unix_filter {}
|
||||
snippet unif
|
||||
ARGF.each_line${1} do |${2:line}|
|
||||
${3}
|
||||
end
|
||||
# option_parse {}
|
||||
snippet optp
|
||||
require "optparse"
|
||||
|
||||
options = {${1:default => "args"}}
|
||||
|
||||
ARGV.options do |opts|
|
||||
opts.banner = "Usage: #{File.basename($PROGRAM_NAME)}
|
||||
snippet opt
|
||||
opts.on( "-${1:o}", "--${2:long-option-name}", ${3:String},
|
||||
"${4:Option description.}") do |${5:opt}|
|
||||
${6}
|
||||
end
|
||||
snippet tc
|
||||
require "test/unit"
|
||||
|
||||
require "${1:library_file_name}"
|
||||
|
||||
class Test${2:$1} < Test::Unit::TestCase
|
||||
def test_${3:case_name}
|
||||
${4}
|
||||
end
|
||||
end
|
||||
snippet ts
|
||||
require "test/unit"
|
||||
|
||||
require "tc_${1:test_case_file}"
|
||||
require "tc_${2:test_case_file}"${3}
|
||||
snippet as
|
||||
assert(${1:test}, "${2:Failure message.}")${3}
|
||||
snippet ase
|
||||
assert_equal(${1:expected}, ${2:actual})${3}
|
||||
snippet asne
|
||||
assert_not_equal(${1:unexpected}, ${2:actual})${3}
|
||||
snippet asid
|
||||
assert_in_delta(${1:expected_float}, ${2:actual_float}, ${3:2 ** -20})${4}
|
||||
snippet asio
|
||||
assert_instance_of(${1:ExpectedClass}, ${2:actual_instance})${3}
|
||||
snippet asko
|
||||
assert_kind_of(${1:ExpectedKind}, ${2:actual_instance})${3}
|
||||
snippet asn
|
||||
assert_nil(${1:instance})${2}
|
||||
snippet asnn
|
||||
assert_not_nil(${1:instance})${2}
|
||||
snippet asm
|
||||
assert_match(/${1:expected_pattern}/, ${2:actual_string})${3}
|
||||
snippet asnm
|
||||
assert_no_match(/${1:unexpected_pattern}/, ${2:actual_string})${3}
|
||||
snippet aso
|
||||
assert_operator(${1:left}, :${2:operator}, ${3:right})${4}
|
||||
snippet asr
|
||||
assert_raise(${1:Exception}) { ${2} }
|
||||
snippet asnr
|
||||
assert_nothing_raised(${1:Exception}) { ${2} }
|
||||
snippet asrt
|
||||
assert_respond_to(${1:object}, :${2:method})${3}
|
||||
snippet ass assert_same(..)
|
||||
assert_same(${1:expected}, ${2:actual})${3}
|
||||
snippet ass assert_send(..)
|
||||
assert_send([${1:object}, :${2:message}, ${3:args}])${4}
|
||||
snippet asns
|
||||
assert_not_same(${1:unexpected}, ${2:actual})${3}
|
||||
snippet ast
|
||||
assert_throws(:${1:expected}) { ${2} }
|
||||
snippet asnt
|
||||
assert_nothing_thrown { ${1} }
|
||||
snippet fl
|
||||
flunk("${1:Failure message.}")${2}
|
||||
# Benchmark.bmbm do .. end
|
||||
snippet bm-
|
||||
TESTS = ${1:10_000}
|
||||
Benchmark.bmbm do |results|
|
||||
${2}
|
||||
end
|
||||
snippet rep
|
||||
results.report("${1:name}:") { TESTS.times { ${2} }}
|
||||
# Marshal.dump(.., file)
|
||||
snippet Md
|
||||
File.open(${1:"path/to/file.dump"}, "wb") { |${2:file}| Marshal.dump(${3:obj}, $2) }${4}
|
||||
# Mashal.load(obj)
|
||||
snippet Ml
|
||||
File.open(${1:"path/to/file.dump"}, "rb") { |${2:file}| Marshal.load($2) }${3}
|
||||
# deep_copy(..)
|
||||
snippet deec
|
||||
Marshal.load(Marshal.dump(${1:obj_to_copy}))${2}
|
||||
snippet Pn-
|
||||
PStore.new(${1:"file_name.pstore"})${2}
|
||||
snippet tra
|
||||
transaction(${1:true}) { ${2} }
|
||||
# xmlread(..)
|
||||
snippet xml-
|
||||
REXML::Document.new(File.read(${1:"path/to/file"}))${2}
|
||||
# xpath(..) { .. }
|
||||
snippet xpa
|
||||
elements.each(${1:"//Xpath"}) do |${2:node}|
|
||||
${3}
|
||||
end
|
||||
# class_from_name()
|
||||
snippet clafn
|
||||
split("::").inject(Object) { |par, const| par.const_get(const) }
|
||||
# singleton_class()
|
||||
snippet sinc
|
||||
class << self; self end
|
||||
snippet nam
|
||||
namespace :${1:`Filename()`} do
|
||||
${2}
|
||||
end
|
||||
snippet tas
|
||||
desc "${1:Task description\}"
|
||||
task :${2:task_name => [:dependent, :tasks]} do
|
||||
${3}
|
||||
end
|
||||
@@ -1,28 +0,0 @@
|
||||
# #!/bin/bash
|
||||
snippet #!
|
||||
#!/bin/bash
|
||||
|
||||
snippet if
|
||||
if [[ ${1:condition} ]]; then
|
||||
${2:#statements}
|
||||
fi
|
||||
snippet elif
|
||||
elif [[ ${1:condition} ]]; then
|
||||
${2:#statements}
|
||||
snippet for
|
||||
for (( ${2:i} = 0; $2 < ${1:count}; $2++ )); do
|
||||
${3:#statements}
|
||||
done
|
||||
snippet wh
|
||||
while [[ ${1:condition} ]]; do
|
||||
${2:#statements}
|
||||
done
|
||||
snippet until
|
||||
until [[ ${1:condition} ]]; do
|
||||
${2:#statements}
|
||||
done
|
||||
snippet case
|
||||
case ${1:word} in
|
||||
${2:pattern})
|
||||
${3};;
|
||||
esac
|
||||
@@ -1,7 +0,0 @@
|
||||
# snippets for making snippets :)
|
||||
snippet snip
|
||||
snippet ${1:trigger}
|
||||
${2}
|
||||
snippet msnip
|
||||
snippet ${1:trigger} ${2:description}
|
||||
${3}
|
||||
@@ -1,92 +0,0 @@
|
||||
# #!/usr/bin/env tclsh
|
||||
snippet #!
|
||||
#!/usr/bin/env tclsh
|
||||
|
||||
# Process
|
||||
snippet pro
|
||||
proc ${1:function_name} {${2:args}} {
|
||||
${3:#body ...}
|
||||
}
|
||||
#xif
|
||||
snippet xif
|
||||
${1:expr}? ${2:true} : ${3:false}
|
||||
# Conditional
|
||||
snippet if
|
||||
if {${1}} {
|
||||
${2:# body...}
|
||||
}
|
||||
# Conditional if..else
|
||||
snippet ife
|
||||
if {${1}} {
|
||||
${2:# body...}
|
||||
} else {
|
||||
${3:# else...}
|
||||
}
|
||||
# Conditional if..elsif..else
|
||||
snippet ifee
|
||||
if {${1}} {
|
||||
${2:# body...}
|
||||
} elseif {${3}} {
|
||||
${4:# elsif...}
|
||||
} else {
|
||||
${5:# else...}
|
||||
}
|
||||
# If catch then
|
||||
snippet ifc
|
||||
if { [catch {${1:#do something...}} ${2:err}] } {
|
||||
${3:# handle failure...}
|
||||
}
|
||||
# Catch
|
||||
snippet catch
|
||||
catch {${1}} ${2:err} ${3:options}
|
||||
# While Loop
|
||||
snippet wh
|
||||
while {${1}} {
|
||||
${2:# body...}
|
||||
}
|
||||
# For Loop
|
||||
snippet for
|
||||
for {set ${2:var} 0} {$$2 < ${1:count}} {${3:incr} $2} {
|
||||
${4:# body...}
|
||||
}
|
||||
# Foreach Loop
|
||||
snippet fore
|
||||
foreach ${1:x} {${2:#list}} {
|
||||
${3:# body...}
|
||||
}
|
||||
# after ms script...
|
||||
snippet af
|
||||
after ${1:ms} ${2:#do something}
|
||||
# after cancel id
|
||||
snippet afc
|
||||
after cancel ${1:id or script}
|
||||
# after idle
|
||||
snippet afi
|
||||
after idle ${1:script}
|
||||
# after info id
|
||||
snippet afin
|
||||
after info ${1:id}
|
||||
# Expr
|
||||
snippet exp
|
||||
expr {${1:#expression here}}
|
||||
# Switch
|
||||
snippet sw
|
||||
switch ${1:var} {
|
||||
${3:pattern 1} {
|
||||
${4:#do something}
|
||||
}
|
||||
default {
|
||||
${2:#do something}
|
||||
}
|
||||
}
|
||||
# Case
|
||||
snippet ca
|
||||
${1:pattern} {
|
||||
${2:#do something}
|
||||
}${3}
|
||||
# Namespace eval
|
||||
snippet ns
|
||||
namespace eval ${1:path} {${2:#script...}}
|
||||
# Namespace current
|
||||
snippet nsc
|
||||
namespace current
|
||||
@@ -1,115 +0,0 @@
|
||||
# \begin{}...\end{}
|
||||
snippet begin
|
||||
\begin{${1:env}}
|
||||
${2}
|
||||
\end{$1}
|
||||
# Tabular
|
||||
snippet tab
|
||||
\begin{${1:tabular}}{${2:c}}
|
||||
${3}
|
||||
\end{$1}
|
||||
# Align(ed)
|
||||
snippet ali
|
||||
\begin{align${1:ed}}
|
||||
${2}
|
||||
\end{align$1}
|
||||
# Gather(ed)
|
||||
snippet gat
|
||||
\begin{gather${1:ed}}
|
||||
${2}
|
||||
\end{gather$1}
|
||||
# Equation
|
||||
snippet eq
|
||||
\begin{equation}
|
||||
${1}
|
||||
\end{equation}
|
||||
# Unnumbered Equation
|
||||
snippet \
|
||||
\\[
|
||||
${1}
|
||||
\\]
|
||||
# Enumerate
|
||||
snippet enum
|
||||
\begin{enumerate}
|
||||
\item ${1}
|
||||
\end{enumerate}
|
||||
# Itemize
|
||||
snippet item
|
||||
\begin{itemize}
|
||||
\item ${1}
|
||||
\end{itemize}
|
||||
# Description
|
||||
snippet desc
|
||||
\begin{description}
|
||||
\item[${1}] ${2}
|
||||
\end{description}
|
||||
# Matrix
|
||||
snippet mat
|
||||
\begin{${1:p/b/v/V/B/small}matrix}
|
||||
${2}
|
||||
\end{$1matrix}
|
||||
# Cases
|
||||
snippet cas
|
||||
\begin{cases}
|
||||
${1:equation}, &\text{ if }${2:case}\\
|
||||
${3}
|
||||
\end{cases}
|
||||
# Split
|
||||
snippet spl
|
||||
\begin{split}
|
||||
${1}
|
||||
\end{split}
|
||||
# Part
|
||||
snippet part
|
||||
\part{${1:part name}} % (fold)
|
||||
\label{prt:${2:$1}}
|
||||
${3}
|
||||
% part $2 (end)
|
||||
# Chapter
|
||||
snippet cha
|
||||
\chapter{${1:chapter name}} % (fold)
|
||||
\label{cha:${2:$1}}
|
||||
${3}
|
||||
% chapter $2 (end)
|
||||
# Section
|
||||
snippet sec
|
||||
\section{${1:section name}} % (fold)
|
||||
\label{sec:${2:$1}}
|
||||
${3}
|
||||
% section $2 (end)
|
||||
# Sub Section
|
||||
snippet sub
|
||||
\subsection{${1:subsection name}} % (fold)
|
||||
\label{sub:${2:$1}}
|
||||
${3}
|
||||
% subsection $2 (end)
|
||||
# Sub Sub Section
|
||||
snippet subs
|
||||
\subsubsection{${1:subsubsection name}} % (fold)
|
||||
\label{ssub:${2:$1}}
|
||||
${3}
|
||||
% subsubsection $2 (end)
|
||||
# Paragraph
|
||||
snippet par
|
||||
\paragraph{${1:paragraph name}} % (fold)
|
||||
\label{par:${2:$1}}
|
||||
${3}
|
||||
% paragraph $2 (end)
|
||||
# Sub Paragraph
|
||||
snippet subp
|
||||
\subparagraph{${1:subparagraph name}} % (fold)
|
||||
\label{subp:${2:$1}}
|
||||
${3}
|
||||
% subparagraph $2 (end)
|
||||
snippet itd
|
||||
\item[${1:description}] ${2:item}
|
||||
snippet figure
|
||||
${1:Figure}~\ref{${2:fig:}}${3}
|
||||
snippet table
|
||||
${1:Table}~\ref{${2:tab:}}${3}
|
||||
snippet listing
|
||||
${1:Listing}~\ref{${2:list}}${3}
|
||||
snippet section
|
||||
${1:Section}~\ref{${2:sec:}}${3}
|
||||
snippet page
|
||||
${1:page}~\pageref{${2}}${3}
|
||||
@@ -1,32 +0,0 @@
|
||||
snippet header
|
||||
" File: ${1:`expand('%:t')`}
|
||||
" Author: ${2:`g:snips_author`}
|
||||
" Description: ${3}
|
||||
${4:" Last Modified: `strftime("%B %d, %Y")`}
|
||||
snippet guard
|
||||
if exists('${1:did_`Filename()`}') || &cp${2: || version < 700}
|
||||
finish
|
||||
endif
|
||||
let $1 = 1${3}
|
||||
snippet f
|
||||
fun ${1:function_name}(${2})
|
||||
${3:" code}
|
||||
endf
|
||||
snippet for
|
||||
for ${1:needle} in ${2:haystack}
|
||||
${3:" code}
|
||||
endfor
|
||||
snippet wh
|
||||
while ${1:condition}
|
||||
${2:" code}
|
||||
endw
|
||||
snippet if
|
||||
if ${1:condition}
|
||||
${2:" code}
|
||||
endif
|
||||
snippet ife
|
||||
if ${1:condition}
|
||||
${2}
|
||||
else
|
||||
${3}
|
||||
endif
|
||||
@@ -1,58 +0,0 @@
|
||||
# #!/bin/zsh
|
||||
snippet #!
|
||||
#!/bin/zsh
|
||||
|
||||
snippet if
|
||||
if ${1:condition}; then
|
||||
${2:# statements}
|
||||
fi
|
||||
snippet ife
|
||||
if ${1:condition}; then
|
||||
${2:# statements}
|
||||
else
|
||||
${3:# statements}
|
||||
fi
|
||||
snippet elif
|
||||
elif ${1:condition} ; then
|
||||
${2:# statements}
|
||||
snippet for
|
||||
for (( ${2:i} = 0; $2 < ${1:count}; $2++ )); do
|
||||
${3:# statements}
|
||||
done
|
||||
snippet fore
|
||||
for ${1:item} in ${2:list}; do
|
||||
${3:# statements}
|
||||
done
|
||||
snippet wh
|
||||
while ${1:condition}; do
|
||||
${2:# statements}
|
||||
done
|
||||
snippet until
|
||||
until ${1:condition}; do
|
||||
${2:# statements}
|
||||
done
|
||||
snippet repeat
|
||||
repeat ${1:integer}; do
|
||||
${2:# statements}
|
||||
done
|
||||
snippet case
|
||||
case ${1:word} in
|
||||
${2:pattern})
|
||||
${3};;
|
||||
esac
|
||||
snippet select
|
||||
select ${1:answer} in ${2:choices}; do
|
||||
${3:# statements}
|
||||
done
|
||||
snippet (
|
||||
( ${1:#statements} )
|
||||
snippet {
|
||||
{ ${1:#statements} }
|
||||
snippet [
|
||||
[[ ${1:test} ]]
|
||||
snippet always
|
||||
{ ${1:try} } always { ${2:always} }
|
||||
snippet fun
|
||||
function ${1:name} (${2:args}) {
|
||||
${3:# body}
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
" Syntax highlighting for snippet files (used for snipMate.vim)
|
||||
" Hopefully this should make snippets a bit nicer to write!
|
||||
syn match snipComment '^#.*'
|
||||
syn match placeHolder '\${\d\+\(:.\{-}\)\=}' contains=snipCommand
|
||||
syn match tabStop '\$\d\+'
|
||||
syn match snipCommand '[^\\]`.\{-}`'
|
||||
syn match snippet '^snippet.*' transparent contains=multiSnipText,snipKeyword
|
||||
syn match multiSnipText '\S\+ \zs.*' contained
|
||||
syn match snipKeyword '^snippet'me=s+8 contained
|
||||
syn match snipError "^[^#s\t].*$"
|
||||
|
||||
hi link snipComment Comment
|
||||
hi link multiSnipText String
|
||||
hi link snipKeyword Keyword
|
||||
hi link snipComment Comment
|
||||
hi link placeHolder Special
|
||||
hi link tabStop Special
|
||||
hi link snipCommand String
|
||||
hi link snipError Error
|
||||
@@ -1,142 +0,0 @@
|
||||
,
|
||||
/ \,,_ .'|
|
||||
,{{| /}}}}/_.' _____________________________________________
|
||||
}}}}` '{{' '. / \
|
||||
{{{{{ _ ;, \ / Gentlemen, \
|
||||
,}}}}}} /o`\ ` ;) | |
|
||||
{{{{{{ / ( | this is ... |
|
||||
}}}}}} | \ | |
|
||||
{{{{{{{{ \ \ | |
|
||||
}}}}}}}}} '.__ _ | | _____ __ __ _ |
|
||||
{{{{{{{{ /`._ (_\ / | / ___/__ ______ / /_____ ______/ /_(_)____ |
|
||||
}}}}}}' | //___/ --=: \__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ |
|
||||
jgs `{{{{` | '--' | ___/ / /_/ / / / / /_/ /_/ (__ ) /_/ / /__ |
|
||||
}}}` | /____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/ |
|
||||
| /____/ |
|
||||
| /
|
||||
\_____________________________________________/
|
||||
|
||||
|
||||
|
||||
|
||||
Syntastic is a syntax checking plugin that runs files through external syntax
|
||||
checkers and displays any resulting errors to the user. This can be done on
|
||||
demand, or automatically as files are saved. If syntax errors are detected, the
|
||||
user is notified and is happy because they didn't have to compile their code or
|
||||
execute their script to find them.
|
||||
|
||||
At the time of this writing, syntax checking plugins exist for applescript, c,
|
||||
coffee, cpp, css, cucumber, cuda, docbk, erlang, eruby, fortran,
|
||||
gentoo_metadata, go, haml, haskell, html, javascript, json, less, lua, matlab,
|
||||
perl, php, puppet, python, rst, ruby, sass/scss, sh, tcl, tex, vala, xhtml,
|
||||
xml, xslt, yaml, zpt
|
||||
|
||||
Screenshot
|
||||
----------
|
||||
|
||||
Below is a screenshot showing the methods that Syntastic uses to display syntax
|
||||
errors. Note that, in practise, you will only have a subset of these methods
|
||||
enabled.
|
||||
|
||||
|
||||
|
||||
1. Errors are loaded into the location list for the corresponding window.
|
||||
2. When the cursor is on a line containing an error, the error message is echoed in the command window.
|
||||
3. Signs are placed beside lines with errors - note that warnings are displayed in a different color.
|
||||
4. There is a configurable statusline flag you can include in your statusline config.
|
||||
5. Hover the mouse over a line containing an error and the error message is displayed as a balloon.
|
||||
6. (not shown) Highlighting errors with syntax highlighting. Erroneous parts of lines can be highlighted.
|
||||
|
||||
Installation
|
||||
------------
|
||||
|
||||
[pathogen.vim](https://github.com/tpope/vim-pathogen) is the recommended way to install syntastic.
|
||||
|
||||
cd ~/.vim/bundle
|
||||
git clone https://github.com/scrooloose/syntastic.git
|
||||
|
||||
Then reload vim, run `:helptags`, and check out `:help syntastic.txt`.
|
||||
|
||||
|
||||
Google group
|
||||
------------
|
||||
|
||||
To get information or make suggestions check out the [google group](https://groups.google.com/group/vim-syntastic).
|
||||
|
||||
|
||||
Changelog
|
||||
---------
|
||||
|
||||
2.2.0 (24-dec-2011)
|
||||
|
||||
* only do syntax checks when files are saved (not when first opened) - add g:syntastic_check_on_open option to get the old behavior back
|
||||
* bug fix with echoing error messages; fixes incompatability with cmd-t (datanoise)
|
||||
* dont allow warnings to mask errors when signing/echoing errors (ashikase)
|
||||
* auto close location list when leaving buffer. (millermedeiros)
|
||||
* update errors appropriately when :SyntasticToggleMode is called
|
||||
* updates/fixes to existing checkers:
|
||||
* javascript/jshint (millermedeiros)
|
||||
* javascript/jslint
|
||||
* c (kongo2002)
|
||||
* Support for new filetypes:
|
||||
* JSON (millermedeiros, tocer)
|
||||
* rst (reStructuredText files) (JNRowe)
|
||||
* gentoo-metadata (JNRowe)
|
||||
|
||||
2.1.0 (14-dec-2011)
|
||||
|
||||
* when the cursor is on a line containing an error, echo the
|
||||
* error msg (kevinw)
|
||||
* various bug fixes and refactoring
|
||||
* updates/fixes to existing checkers:
|
||||
* html (millermedeiros)
|
||||
* erlang
|
||||
* coffeescript
|
||||
* javascript
|
||||
* sh
|
||||
* php (add support for phpcs - technosophos)
|
||||
* add an applescript checker (Zhai Cai)
|
||||
* add support for hyphenated filetypes (JNRowe)
|
||||
|
||||
2.0.0 (2-dec-2011):
|
||||
|
||||
* Add support for highlighting the erroneous parts of lines (kstep)
|
||||
* Add support for displaying errors via balloons (kstep)
|
||||
* Add syntastic_mode_map option to give more control over when checking should be done.
|
||||
* Add :SyntasticCheck command to force a syntax check - useful in passive mode (justone).
|
||||
* Add the option to automatically close the location list, but not automatically open it (milkypostman)
|
||||
* Add syntastic_auto_jump option to automatically jump to the first error (milkypostman)
|
||||
* Only source syntax checkers as needed - instead of loading all of them when vim starts
|
||||
|
||||
* Support for new filetypes:
|
||||
* less (julienXX)
|
||||
* docbook (tpope)
|
||||
* matlab (jasongraham)
|
||||
* go (dtjm)
|
||||
* puppet (uggedal, roman, zsprackett)
|
||||
* haskell (baldo, roman)
|
||||
* tcl (et)
|
||||
* vala (kstep)
|
||||
* cuda (temporaer)
|
||||
* css (oryband, sitedyno)
|
||||
* fortran (Karl Yngve Lervåg)
|
||||
* xml (kusnier)
|
||||
* xslt (kusnier)
|
||||
* erlang (kTT)
|
||||
* zpt (claytron)
|
||||
|
||||
* updates to existing checkers:
|
||||
* javascript (mogren, bryanforbes, cjab, ajduncan)
|
||||
* sass/scss (tmm1, atourino, dlee, epeli)
|
||||
* ruby (changa)
|
||||
* perl (harleypig)
|
||||
* haml (bmihelac)
|
||||
* php (kstep, docteurklein)
|
||||
* python (kstep, soli)
|
||||
* lua (kstep)
|
||||
* html (kstep)
|
||||
* xhtml (kstep)
|
||||
* c (kongo2002, brandonw)
|
||||
* cpp (kongo2002)
|
||||
* coffee (industrial)
|
||||
* eruby (sergevm)
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 90 KiB |
@@ -1,171 +0,0 @@
|
||||
if exists("g:loaded_syntastic_c_autoload")
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_autoload = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
" initialize c/cpp syntax checker handlers
|
||||
function! s:Init()
|
||||
let s:handlers = []
|
||||
let s:cflags = {}
|
||||
|
||||
call s:RegHandler('gtk', 'syntastic#c#CheckPKG',
|
||||
\ ['gtk', 'gtk+-2.0', 'gtk+', 'glib-2.0', 'glib'])
|
||||
call s:RegHandler('glib', 'syntastic#c#CheckPKG',
|
||||
\ ['glib', 'glib-2.0', 'glib'])
|
||||
call s:RegHandler('glade', 'syntastic#c#CheckPKG',
|
||||
\ ['glade', 'libglade-2.0', 'libglade'])
|
||||
call s:RegHandler('libsoup', 'syntastic#c#CheckPKG',
|
||||
\ ['libsoup', 'libsoup-2.4', 'libsoup-2.2'])
|
||||
call s:RegHandler('webkit', 'syntastic#c#CheckPKG',
|
||||
\ ['webkit', 'webkit-1.0'])
|
||||
call s:RegHandler('cairo', 'syntastic#c#CheckPKG',
|
||||
\ ['cairo', 'cairo'])
|
||||
call s:RegHandler('pango', 'syntastic#c#CheckPKG',
|
||||
\ ['pango', 'pango'])
|
||||
call s:RegHandler('libxml', 'syntastic#c#CheckPKG',
|
||||
\ ['libxml', 'libxml-2.0', 'libxml'])
|
||||
call s:RegHandler('freetype', 'syntastic#c#CheckPKG',
|
||||
\ ['freetype', 'freetype2', 'freetype'])
|
||||
call s:RegHandler('SDL', 'syntastic#c#CheckPKG',
|
||||
\ ['sdl', 'sdl'])
|
||||
call s:RegHandler('opengl', 'syntastic#c#CheckPKG',
|
||||
\ ['opengl', 'gl'])
|
||||
call s:RegHandler('ruby', 'syntastic#c#CheckRuby', [])
|
||||
call s:RegHandler('Python\.h', 'syntastic#c#CheckPython', [])
|
||||
call s:RegHandler('php\.h', 'syntastic#c#CheckPhp', [])
|
||||
endfunction
|
||||
|
||||
" search the first 100 lines for include statements that are
|
||||
" given in the handlers dictionary
|
||||
function! syntastic#c#SearchHeaders()
|
||||
let includes = ''
|
||||
let files = []
|
||||
let found = []
|
||||
let lines = filter(getline(1, 100), 'v:val =~# "#\s*include"')
|
||||
|
||||
" search current buffer
|
||||
for line in lines
|
||||
let file = matchstr(line, '"\zs\S\+\ze"')
|
||||
if file != ''
|
||||
call add(files, file)
|
||||
continue
|
||||
endif
|
||||
for handler in s:handlers
|
||||
if line =~# handler["regex"]
|
||||
let includes .= call(handler["func"], handler["args"])
|
||||
call add(found, handler["regex"])
|
||||
break
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
|
||||
" search included headers
|
||||
for hfile in files
|
||||
if hfile != ''
|
||||
let filename = expand('%:p:h') . ((has('win32') || has('win64')) ?
|
||||
\ '\' : '/') . hfile
|
||||
try
|
||||
let lines = readfile(filename, '', 100)
|
||||
catch /E484/
|
||||
continue
|
||||
endtry
|
||||
let lines = filter(lines, 'v:val =~# "#\s*include"')
|
||||
for handler in s:handlers
|
||||
if index(found, handler["regex"]) != -1
|
||||
continue
|
||||
endif
|
||||
for line in lines
|
||||
if line =~# handler["regex"]
|
||||
let includes .= call(handler["func"], handler["args"])
|
||||
call add(found, handler["regex"])
|
||||
break
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
endif
|
||||
endfor
|
||||
|
||||
return includes
|
||||
endfunction
|
||||
|
||||
" try to find library with 'pkg-config'
|
||||
" search possible libraries from first to last given
|
||||
" argument until one is found
|
||||
function! syntastic#c#CheckPKG(name, ...)
|
||||
if executable('pkg-config')
|
||||
if !has_key(s:cflags, a:name)
|
||||
for i in range(a:0)
|
||||
let l:cflags = system('pkg-config --cflags '.a:000[i])
|
||||
" since we cannot necessarily trust the pkg-config exit code
|
||||
" we have to check for an error output as well
|
||||
if v:shell_error == 0 && l:cflags !~? 'not found'
|
||||
let l:cflags = ' '.substitute(l:cflags, "\n", '', '')
|
||||
let s:cflags[a:name] = l:cflags
|
||||
return l:cflags
|
||||
endif
|
||||
endfor
|
||||
else
|
||||
return s:cflags[a:name]
|
||||
endif
|
||||
endif
|
||||
return ''
|
||||
endfunction
|
||||
|
||||
" try to find PHP includes with 'php-config'
|
||||
function! syntastic#c#CheckPhp()
|
||||
if executable('php-config')
|
||||
if !exists('s:php_flags')
|
||||
let s:php_flags = system('php-config --includes')
|
||||
let s:php_flags = ' ' . substitute(s:php_flags, "\n", '', '')
|
||||
endif
|
||||
return s:php_flags
|
||||
endif
|
||||
return ''
|
||||
endfunction
|
||||
|
||||
" try to find the ruby headers with 'rbconfig'
|
||||
function! syntastic#c#CheckRuby()
|
||||
if executable('ruby')
|
||||
if !exists('s:ruby_flags')
|
||||
let s:ruby_flags = system('ruby -r rbconfig -e '
|
||||
\ . '''puts Config::CONFIG["archdir"]''')
|
||||
let s:ruby_flags = substitute(s:ruby_flags, "\n", '', '')
|
||||
let s:ruby_flags = ' -I' . s:ruby_flags
|
||||
endif
|
||||
return s:ruby_flags
|
||||
endif
|
||||
return ''
|
||||
endfunction
|
||||
|
||||
" try to find the python headers with distutils
|
||||
function! syntastic#c#CheckPython()
|
||||
if executable('python')
|
||||
if !exists('s:python_flags')
|
||||
let s:python_flags = system('python -c ''from distutils import '
|
||||
\ . 'sysconfig; print sysconfig.get_python_inc()''')
|
||||
let s:python_flags = substitute(s:python_flags, "\n", '', '')
|
||||
let s:python_flags = ' -I' . s:python_flags
|
||||
endif
|
||||
return s:python_flags
|
||||
endif
|
||||
return ''
|
||||
endfunction
|
||||
|
||||
" return a handler dictionary object
|
||||
function! s:RegHandler(regex, function, args)
|
||||
let handler = {}
|
||||
let handler["regex"] = a:regex
|
||||
let handler["func"] = function(a:function)
|
||||
let handler["args"] = a:args
|
||||
call add(s:handlers, handler)
|
||||
endfunction
|
||||
|
||||
call s:Init()
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set et sts=4 sw=4:
|
||||
@@ -1,527 +0,0 @@
|
||||
*syntastic.txt* Syntax checking on the fly has never been so pimp.
|
||||
*syntastic*
|
||||
|
||||
|
||||
It's a bird! It's a plane! ZOMG It's ... ~
|
||||
|
||||
_____ __ __ _ ~
|
||||
/ ___/__ ______ / /_____ ______/ /_(_)____ ~
|
||||
\__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ ~
|
||||
___/ / /_/ / / / / /_/ /_/ (__ ) /_/ / /__ ~
|
||||
/____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/ ~
|
||||
/____/ ~
|
||||
|
||||
|
||||
|
||||
Reference Manual~
|
||||
|
||||
|
||||
==============================================================================
|
||||
CONTENTS *syntastic-contents*
|
||||
|
||||
1.Intro...................................|syntastic-intro|
|
||||
2.Functionality provided..................|syntastic-functionality|
|
||||
2.1.The statusline flag...............|syntastic-statusline-flag|
|
||||
2.2.Error signs.......................|syntastic-error-signs|
|
||||
2.3.Error window......................|syntastic-error-window|
|
||||
3.Commands................................|syntastic-commands|
|
||||
4.Options.................................|syntastic-options|
|
||||
5.Writing syntax checkers.................|syntastic-syntax-checkers|
|
||||
6.About...................................|syntastic-about|
|
||||
7.Changelog...............................|syntastic-changelog|
|
||||
8.Credits.................................|syntastic-credits|
|
||||
9.License.................................|syntastic-license|
|
||||
|
||||
|
||||
==============================================================================
|
||||
1. Intro *syntastic-intro*
|
||||
|
||||
Syntastic is a syntax checking plugin that runs files through external syntax
|
||||
checkers. This can be done on demand, or automatically as files are saved and
|
||||
opened. If syntax errors are detected, the user is notified and is happy
|
||||
because they didn't have to compile their code or execute their script to find
|
||||
them.
|
||||
|
||||
Syntastic comes in two parts: the syntax checker plugins, and the core script
|
||||
(i.e. syntastic.vim). The syntax checker plugins are defined on a per-filetype
|
||||
basis where each one wraps up an external syntax checking program. The core
|
||||
script delegates off to these plugins and uses their output to provide the
|
||||
syntastic functionality. At the time of this writing, syntax checking plugins
|
||||
exist for c, coffee, cpp, css, cucumber, cuda, docbk, erlang, eruby, fortran,
|
||||
go, haml, haskell, html, javascript, less, lua, matlab, perl, php, puppet,
|
||||
python, ruby, sass/scss, sh, tcl, tex, vala, xhtml, xml, xslt, zpt
|
||||
|
||||
Take a look in the syntax_checkers directory for the most up to date list.
|
||||
|
||||
If your language is not supported then see |syntastic-syntax-checkers| for
|
||||
details on how to implement a syntax checking plugin, and be sure to send me a
|
||||
patch ;-)
|
||||
|
||||
This plugin is currently only recommended for *nix users. It is functional on
|
||||
Windows, but since the syntax checking plugins shell out, the command window
|
||||
briefly appears whenever one is executed.
|
||||
|
||||
|
||||
==============================================================================
|
||||
2. Functionality provided *syntastic-functionality*
|
||||
|
||||
Syntax checking can be done automatically or on demand (see
|
||||
|'syntastic_mode_map'| for configuring this).
|
||||
|
||||
When syntax checking is done, the features below can be used to notify the
|
||||
user of errors. See |syntastic-options| for how to configure and
|
||||
activate/deactivate these features.
|
||||
|
||||
* A configurable statusline flag
|
||||
* Lines with errors can have |signs| placed beside them - where a different
|
||||
sign is used for errors and warnings.
|
||||
* A |location-list| can be displayed with error messages for erroneous
|
||||
buffers.
|
||||
* Offending parts of lines can be highlighted (this functionality is only
|
||||
provided by some syntax checkers).
|
||||
* Balloons (if compiled in) can be used to display error messages for
|
||||
erroneous lines when hovering the mouse over them.
|
||||
|
||||
|
||||
Note: This functionality is only available if a syntax checker plugin is
|
||||
present for the filetype of the buffer in question. See
|
||||
|syntastic-syntax-checkers| for details.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
2.1. The statusline flag *syntastic-statusline-flag*
|
||||
|
||||
To use the statusline flag, this must appear in your |'statusline'| setting >
|
||||
%{SyntasticStatuslineFlag()}
|
||||
<
|
||||
Something like this could be more useful: >
|
||||
set statusline+=%#warningmsg#
|
||||
set statusline+=%{SyntasticStatuslineFlag()}
|
||||
set statusline+=%*
|
||||
<
|
||||
When syntax errors are detected a flag will be shown. The content of the flag
|
||||
is derived from the |syntastic_stl_format| option
|
||||
------------------------------------------------------------------------------
|
||||
2.2. Error signs *syntastic-error-signs*
|
||||
|
||||
Syntastic uses the |:sign| commands to mark lines with errors and warnings in
|
||||
the sign column. To enable this feature, use the |'syntastic_enable_signs'|
|
||||
option.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
2.3. The error window *:Errors* *syntastic-error-window*
|
||||
|
||||
You can use the :Errors command to display the errors for the current buffer
|
||||
in the |location-list|.
|
||||
|
||||
Note that when you use :Errors, the current location list is overwritten with
|
||||
Syntastic's own location list.
|
||||
|
||||
|
||||
==============================================================================
|
||||
3. Commands *syntastic-commands*
|
||||
|
||||
:Errors *:SyntasticErrors*
|
||||
|
||||
When errors have been detected, use this command to pop up the |location-list|
|
||||
and display the error messages.
|
||||
|
||||
|
||||
:SyntasticToggleMode *:SyntasticToggleMode*
|
||||
|
||||
Toggles syntastic between active and passive mode. See |'syntastic_mode_map'|
|
||||
for more info.
|
||||
|
||||
|
||||
:SyntasticCheck *:SyntasticCheck*
|
||||
|
||||
Manually cause a syntax check to be done. Useful in passive mode, or if the
|
||||
current filetype is set to passive. See |'syntastic_mode_map'| for more info.
|
||||
|
||||
|
||||
==============================================================================
|
||||
4. Options *syntastic-options*
|
||||
|
||||
|
||||
*'syntastic_check_on_open'*
|
||||
Default: 0
|
||||
If enabled, syntastic will do syntax checks when buffers are first loaded as
|
||||
well as on saving >
|
||||
let g:syntastic_check_on_open=1
|
||||
<
|
||||
|
||||
*'syntastic_echo_current_error'*
|
||||
Default: 1
|
||||
If enabled, syntastic will error message associated with the current line to
|
||||
the command window. If multiple errors are found, the first will be used. >
|
||||
let g:syntastic_echo_current_error=1
|
||||
<
|
||||
|
||||
*'syntastic_enable_signs'*
|
||||
Default: 1
|
||||
Use this option to tell syntastic whether to use the |:sign| interface to mark
|
||||
syntax errors: >
|
||||
let g:syntastic_enable_signs=1
|
||||
<
|
||||
|
||||
*'syntastic_enable_balloons'*
|
||||
Default: 1
|
||||
Use this option to tell syntastic whether to display error messages in balloons
|
||||
when the mouse is hovered over erroneous lines: >
|
||||
let g:syntastic_enable_balloons = 1
|
||||
<
|
||||
Note that vim must be compiled with |+balloon_eval|.
|
||||
|
||||
*'syntastic_enable_highlighting'*
|
||||
Default: 1
|
||||
Use this option to tell syntastic whether to use syntax highlighting to mark
|
||||
errors (where possible). Highlighting can be turned off with the following >
|
||||
let g:syntastic_enable_highlighting = 0
|
||||
<
|
||||
|
||||
*'syntastic_auto_jump'*
|
||||
Default: 0
|
||||
Enable this option if you want the cursor to jump to the first detected error
|
||||
when saving or opening a file: >
|
||||
let g:syntastic_auto_jump=1
|
||||
<
|
||||
|
||||
*'syntastic_auto_loc_list'*
|
||||
Default: 2
|
||||
Use this option to tell syntastic to automatically open and/or close the
|
||||
|location-list| (see |syntastic-error-window|).
|
||||
|
||||
When set to 0 the error window will not be opened or closed automatically. >
|
||||
let g:syntastic_auto_loc_list=0
|
||||
<
|
||||
|
||||
When set to 1 the error window will be automatically opened when errors are
|
||||
detected, and closed when none are detected. >
|
||||
let g:syntastic_auto_loc_list=1
|
||||
<
|
||||
When set to 2 the error window will be automatically closed when no errors are
|
||||
detected, but not opened automatically. >
|
||||
let g:syntastic_auto_loc_list=2
|
||||
<
|
||||
|
||||
*'syntastic_mode_map'*
|
||||
Default: { "mode": "active",
|
||||
"active_filetypes": [],
|
||||
"passive_filetypes": [] }
|
||||
|
||||
Use this option to fine tune when automatic syntax checking is done (or not
|
||||
done).
|
||||
|
||||
The option should be set to something like: >
|
||||
|
||||
let g:syntastic_mode_map = { 'mode': 'active',
|
||||
\ 'active_filetypes': ['ruby', 'php'],
|
||||
\ 'passive_filetypes': ['puppet'] }
|
||||
<
|
||||
|
||||
"mode" can be mapped to one of two values - "active" or "passive". When set to
|
||||
active, syntastic does automatic checking whenever a buffer is saved or
|
||||
initially opened. When set to "passive" syntastic only checks when the user
|
||||
calls :SyntasticCheck.
|
||||
|
||||
The exceptions to these rules are defined with "active_filetypes" and
|
||||
"passive_filetypes". In passive mode, automatic checks are still done
|
||||
for all filetypes in the "active_filetypes" array. In active mode,
|
||||
automatic checks are not done for any filetypes in the
|
||||
"passive_filetypes" array.
|
||||
|
||||
At runtime, the |:SyntasticToggleMode| command can be used to switch between
|
||||
active and passive mode.
|
||||
|
||||
If any of "mode", "active_filetypes", or "passive_filetypes" are not specified
|
||||
then they will default to their default value as above.
|
||||
|
||||
*'syntastic_quiet_warnings'*
|
||||
|
||||
Use this option if you only care about syntax errors, not warnings. When set,
|
||||
this option has the following effects:
|
||||
* no |signs| appear unless there is at least one error, whereupon both
|
||||
errors and warnings are displayed
|
||||
* the |'syntastic_auto_loc_list'| option only pops up the error window if
|
||||
there's at least one error, whereupon both errors and warnings are
|
||||
displayed
|
||||
>
|
||||
let g:syntastic_quiet_warnings=1
|
||||
<
|
||||
|
||||
*'syntastic_stl_format'*
|
||||
|
||||
Default: [Syntax: line:%F (%t)]
|
||||
Use this option to control what the syntastic statusline text contains. Several
|
||||
magic flags are availble to insert information:
|
||||
%e - number of errors
|
||||
%w - number of warnings
|
||||
%t - total number of warnings and errors
|
||||
%fe - line number of first error
|
||||
%fw - line number of first warning
|
||||
%F - line number of first warning or error
|
||||
|
||||
Several additional flags are available to hide text under certain conditions:
|
||||
%E{...} - hide the text in the brackets unless there are errors
|
||||
%W{...} - hide the text in the brackets unless there are warnings
|
||||
%B{...} - hide the text in the brackets unless there are both warnings AND
|
||||
errors
|
||||
These flags cant be nested.
|
||||
|
||||
Example: >
|
||||
let g:syntastic_stl_format = '[%E{Err: %fe #%e}%B{, }%W{Warn: %fw #%w}]'
|
||||
<
|
||||
If this format is used and the current buffer has 5 errors and 1 warning
|
||||
starting on lines 20 and 10 respectively then this would appear on the
|
||||
statusline: >
|
||||
[Err: 20 #5, Warn: 10 #1]
|
||||
<
|
||||
If the buffer had 2 warnings, starting on line 5 then this would appear: >
|
||||
[Warn: 5 #2]
|
||||
<
|
||||
|
||||
|
||||
==============================================================================
|
||||
5. Writing syntax checkers *syntastic-syntax-checkers*
|
||||
|
||||
|
||||
A syntax checker plugin is really nothing more than a single function. You
|
||||
should define them in ~/.vim/syntax_checkers/<filetype>.vim, but this is
|
||||
purely for convenience; Syntastic doesn't actually care where these functions
|
||||
are defined.
|
||||
|
||||
A syntax checker plugin must define a function of the form:
|
||||
>
|
||||
SyntaxCheckers_<filetype>_GetLocList()
|
||||
<
|
||||
The output of this function must be of the same format as that returned by
|
||||
the |getloclist()| function. See |getloclist()| and |getqflist()| for
|
||||
details.
|
||||
|
||||
To achieve this, the function should call |SyntasticMake()| or shell out to a
|
||||
syntax checker, parse the output and munge it into the format.
|
||||
|
||||
There are several syntax checker plugins provided with this plugin. The ruby
|
||||
one is a good example of |SyntasticMake()|, while the haml one is a good
|
||||
example of how to create the data structure manually.
|
||||
|
||||
|
||||
SyntasticMake({options}) *SyntasticMake()*
|
||||
{options} must be a dictionary. It can contain "makeprg" and "errorformat"
|
||||
as keys (both optional).
|
||||
|
||||
SyntasticMake will run |:lmake| with the given |'makeprg'| and
|
||||
|'errorformat'| (using the current settings if none are supplied). It will
|
||||
store the resulting error list and use it to provide all of the
|
||||
|syntastic-functionality|. The previous makeprg and errorformat settings
|
||||
will then be restored, as well as the location list for the window. From
|
||||
the user's perspective, it will be as though |:lmake| was never run.
|
||||
|
||||
Note that the given "makeprg" and "errorformat" will be set using |:let-&|,
|
||||
so you should not escape spaces.
|
||||
|
||||
|
||||
==============================================================================
|
||||
6. About *syntastic-about*
|
||||
|
||||
The author of syntastic is a mighty wild stallion, hear him roar! >
|
||||
_ _ _____ _____ ___ ___ ___ ____ _ _ _
|
||||
| \ | | ____| ____|_ _|_ _|_ _/ ___| | | | |
|
||||
| \| | _| | _| | | | | | | | _| |_| | |
|
||||
| |\ | |___| |___ | | | | | | |_| | _ |_|
|
||||
|_| \_|_____|_____|___|___|___\____|_| |_(_)
|
||||
|
||||
<
|
||||
He likes to trot around in the back yard reading his emails and sipping a
|
||||
scolding hot cup of Earl Grey. Email him at martin.grenfell at gmail dot com.
|
||||
He can also be found trolling the #vim channel on the freenode IRC network as
|
||||
scrooloose.
|
||||
|
||||
Bug reports, feedback, suggestions etc are welcomed.
|
||||
|
||||
|
||||
The latest official releases will be on vim.org at some point.
|
||||
|
||||
The latest dev versions are on github
|
||||
http://github.com/scrooloose/syntastic
|
||||
|
||||
==============================================================================
|
||||
7. Changelog *syntastic-changelog*
|
||||
|
||||
next
|
||||
- Support for new filetypes:
|
||||
- yaml
|
||||
|
||||
2.2.0
|
||||
- only do syntax checks when files are saved (not when first opened) - add
|
||||
g:syntastic_check_on_open option to get the old behavior back
|
||||
- bug fix with echoing error messages; fixes incompatability with cmd-t (datanoise)
|
||||
- dont allow warnings to mask errors when signing/echoing errors (ashikase)
|
||||
- auto close location list when leaving buffer. (millermedeiros)
|
||||
- update errors appropriately when :SyntasticToggleMode is called
|
||||
- updates/fixes to existing checkers:
|
||||
- javascript/jshint (millermedeiros)
|
||||
- javascript/jslint
|
||||
- c (kongo2002)
|
||||
- Support for new filetypes:
|
||||
- JSON (millermedeiros, tocer)
|
||||
- rst (reStructuredText files) (JNRowe)
|
||||
- gentoo-metadata (JNRowe)
|
||||
|
||||
|
||||
2.1.0
|
||||
- when the cursor is on a line containing an error, echo the
|
||||
error msg (kevinw)
|
||||
- various bug fixes and refactoring
|
||||
- updates/fixes to existing checkers:
|
||||
- html (millermedeiros)
|
||||
- erlang
|
||||
- coffeescript
|
||||
- javascript
|
||||
- sh
|
||||
- php (add support for phpcs - technosophos)
|
||||
- add an applescript checker (Zhai Cai)
|
||||
- add support for hyphenated filetypes (JNRowe)
|
||||
|
||||
2.0.0
|
||||
- Add support for highlighting the erroneous parts of lines (kstep)
|
||||
- Add support for displaying errors via balloons (kstep)
|
||||
- Add syntastic_mode_map option to give more control over when checking
|
||||
should be done.
|
||||
- Add :SyntasticCheck command to force a syntax check - useful in passive
|
||||
mode (justone).
|
||||
- Add the option to automatically close the location list, but not
|
||||
automatically open it (milkypostman)
|
||||
- Add syntastic_auto_jump option to automatically jump to the first
|
||||
error (milkypostman)
|
||||
- Only source syntax checkers as needed - instead of loading all of them
|
||||
when vim starts
|
||||
|
||||
- Support for new filetypes:
|
||||
- less (julienXX)
|
||||
- docbook (tpope)
|
||||
- matlab (jasongraham)
|
||||
- go (dtjm)
|
||||
- puppet (uggedal, roman, zsprackett)
|
||||
- haskell (baldo, roman)
|
||||
- tcl (et)
|
||||
- vala (kstep)
|
||||
- cuda (temporaer)
|
||||
- css (oryband, sitedyno)
|
||||
- fortran (Karl Yngve Lervåg)
|
||||
- xml (kusnier)
|
||||
- xslt (kusnier)
|
||||
- erlang (kTT)
|
||||
- zpt (claytron)
|
||||
|
||||
- updates to existing checkers:
|
||||
- javascript (mogren, bryanforbes, cjab, ajduncan)
|
||||
- sass/scss (tmm1, atourino, dlee, epeli)
|
||||
- ruby (changa)
|
||||
- perl (harleypig)
|
||||
- haml (bmihelac)
|
||||
- php (kstep, docteurklein)
|
||||
- python (kstep, soli)
|
||||
- lua (kstep)
|
||||
- html (kstep)
|
||||
- xhtml (kstep)
|
||||
- c (kongo2002, brandonw)
|
||||
- cpp (kongo2002)
|
||||
- coffee (industrial)
|
||||
- eruby (sergevm)
|
||||
|
||||
1.2.0
|
||||
- New syntax checkers from github:kongo2002
|
||||
- c (thanks also to github:jperras)
|
||||
- cpp
|
||||
- lua
|
||||
- sh (thanks also to github:jmcantrell)
|
||||
- add coffee syntax checked by github:lstoll
|
||||
- add tex syntax checker
|
||||
- make html checker play nicer with html5, thanks to github:enaeseth
|
||||
- escape filenames properly when invoking syntax checkers, thanks to
|
||||
github:jmcantrell
|
||||
- adjust the ruby syntax checker to avoid some common annoying warnings,
|
||||
thanks to github:robertwahler
|
||||
|
||||
1.1.0 [codenamed: tpimp]
|
||||
- Dont load rubygems for ruby/eruby syntax checkers. Thanks tpope.
|
||||
- Improve the javascript syntax checker to catch some warnings that were
|
||||
getting missed. Thanks tpope.
|
||||
- Dont automatically focus the error window. Thanks tpope.
|
||||
- Add support for cucumber [tpope], haskell & perl [Anthony Carapetis],
|
||||
and xhtml
|
||||
- Add commands to enable/disable syntax checking at runtime. See :help
|
||||
syntastic-commands.
|
||||
- Add an option to specifiy syntax checkers that should be disabled by
|
||||
default. See :help syntastic_disabled_filetypes.
|
||||
- Dont use :signs if vim wasnt compiled with support for them.
|
||||
)
|
||||
|
||||
==============================================================================
|
||||
8. Credits *syntastic-credits*
|
||||
|
||||
Thanks to the following people for testing, bug reports, patches etc. They own,
|
||||
hard.
|
||||
|
||||
Benji Fisher (benjifisher)
|
||||
Lance Fetters (ashikase)
|
||||
datanoise
|
||||
Giuseppe Rota (grota)
|
||||
tocer
|
||||
James Rowe (JNRowe)
|
||||
Zhai Cai
|
||||
Matt Butcher (technosophos)
|
||||
Kevin Watters (kevinw)
|
||||
Miller Medeiros (millermedeiros)
|
||||
Pawel Salata (kTT)
|
||||
Fjölnir Ásgeirsson (aptiva)
|
||||
Clayton Parker (claytron)
|
||||
S. Zachariah Sprackett (zsprackett)
|
||||
Sylvain Soliman (soli)
|
||||
Ricardo Catalinas Jiménez (jimenezrick)
|
||||
kusnier
|
||||
Klein Florian (docteurklein)
|
||||
sitedyno
|
||||
Matthew Batema (mlb-)
|
||||
Nate Jones (justone)
|
||||
sergevm
|
||||
Karl Yngve Lervåg
|
||||
Pavel Argentov (argent-smith)
|
||||
Andy Duncan (ajduncan)
|
||||
Antonio Touriño (atourino)
|
||||
Chad Jablonski (cjab)
|
||||
Roman Gonzalez (roman)
|
||||
Tom Wieland (industrial)
|
||||
Ory Band (oryband)
|
||||
Esa-Matti Suuronen (epeli)
|
||||
Brandon Waskiewicz (brandonw)
|
||||
dlee
|
||||
temporaer
|
||||
Jason Graham (jasongraham)
|
||||
Sam Nguyen (dtjm)
|
||||
Claes Mogren (mogren)
|
||||
Eivind Uggedal (uggedal)
|
||||
kstep
|
||||
Andreas Baldeau (baldo)
|
||||
Eric Thomas (et)
|
||||
Brian Donovan (eventualbuddha)
|
||||
Bryan Forbes (bryanforbes)
|
||||
Aman Gupta (tmm1)
|
||||
Donald Ephraim Curtis (milkypostman)
|
||||
Dominique Rose-Rosette (changa)
|
||||
Harley Pig (harleypig)
|
||||
bmihelac
|
||||
Julien Blanchard (julienXX)
|
||||
Gregor Uhlenheuer (kongo2002)
|
||||
Lincoln Stoll
|
||||
Tim Carey-Smith (halorgium)
|
||||
Tim Pope (tpope)
|
||||
Travis Jeffery
|
||||
Anthony Carapetis
|
||||
|
||||
|
||||
==============================================================================
|
||||
9. License *syntastic-license*
|
||||
|
||||
Syntastic is released under the wtfpl.
|
||||
See http://sam.zoy.org/wtfpl/COPYING.
|
||||
@@ -1,562 +0,0 @@
|
||||
"============================================================================
|
||||
"File: syntastic.vim
|
||||
"Description: vim plugin for on the fly syntax checking
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"Version: 2.2.0
|
||||
"Last Change: 24 Dec, 2011
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists("g:loaded_syntastic_plugin")
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_plugin = 1
|
||||
|
||||
let s:running_windows = has("win16") || has("win32") || has("win64")
|
||||
|
||||
if !s:running_windows
|
||||
let s:uname = system('uname')
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_enable_signs")
|
||||
let g:syntastic_enable_signs = 1
|
||||
endif
|
||||
if !has('signs')
|
||||
let g:syntastic_enable_signs = 0
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_enable_balloons")
|
||||
let g:syntastic_enable_balloons = 1
|
||||
endif
|
||||
if !has('balloon_eval')
|
||||
let g:syntastic_enable_balloons = 0
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_enable_highlighting")
|
||||
let g:syntastic_enable_highlighting = 1
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_echo_current_error")
|
||||
let g:syntastic_echo_current_error = 1
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_auto_loc_list")
|
||||
let g:syntastic_auto_loc_list = 2
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_auto_jump")
|
||||
let syntastic_auto_jump=0
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_quiet_warnings")
|
||||
let g:syntastic_quiet_warnings = 0
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_stl_format")
|
||||
let g:syntastic_stl_format = '[Syntax: line:%F (%t)]'
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_mode_map")
|
||||
let g:syntastic_mode_map = {}
|
||||
endif
|
||||
|
||||
if !has_key(g:syntastic_mode_map, "mode")
|
||||
let g:syntastic_mode_map['mode'] = 'active'
|
||||
endif
|
||||
|
||||
if !has_key(g:syntastic_mode_map, "active_filetypes")
|
||||
let g:syntastic_mode_map['active_filetypes'] = []
|
||||
endif
|
||||
|
||||
if !has_key(g:syntastic_mode_map, "passive_filetypes")
|
||||
let g:syntastic_mode_map['passive_filetypes'] = []
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_check_on_open")
|
||||
let g:syntastic_check_on_open = 0
|
||||
endif
|
||||
|
||||
command! SyntasticToggleMode call s:ToggleMode()
|
||||
command! SyntasticCheck call s:UpdateErrors(0) <bar> redraw!
|
||||
command! Errors call s:ShowLocList()
|
||||
|
||||
highlight link SyntasticError SpellBad
|
||||
highlight link SyntasticWarning SpellCap
|
||||
|
||||
augroup syntastic
|
||||
if g:syntastic_echo_current_error
|
||||
autocmd cursormoved * call s:EchoCurrentError()
|
||||
endif
|
||||
|
||||
autocmd BufReadPost * if g:syntastic_check_on_open | call s:UpdateErrors(1) | endif
|
||||
autocmd BufWritePost * call s:UpdateErrors(1)
|
||||
|
||||
autocmd BufWinEnter * if empty(&bt) | call s:AutoToggleLocList() | endif
|
||||
autocmd BufWinLeave * if empty(&bt) | lclose | endif
|
||||
augroup END
|
||||
|
||||
|
||||
"refresh and redraw all the error info for this buf when saving or reading
|
||||
function! s:UpdateErrors(auto_invoked)
|
||||
if !empty(&buftype)
|
||||
return
|
||||
endif
|
||||
|
||||
if !a:auto_invoked || s:ModeMapAllowsAutoChecking()
|
||||
call s:CacheErrors()
|
||||
end
|
||||
|
||||
if s:BufHasErrorsOrWarningsToDisplay()
|
||||
call setloclist(0, s:LocList())
|
||||
endif
|
||||
|
||||
if g:syntastic_enable_balloons
|
||||
call s:RefreshBalloons()
|
||||
endif
|
||||
|
||||
if g:syntastic_enable_signs
|
||||
call s:RefreshSigns()
|
||||
endif
|
||||
|
||||
if g:syntastic_auto_jump && s:BufHasErrorsOrWarningsToDisplay()
|
||||
silent! ll
|
||||
endif
|
||||
|
||||
call s:AutoToggleLocList()
|
||||
endfunction
|
||||
|
||||
"automatically open/close the location list window depending on the users
|
||||
"config and buffer error state
|
||||
function! s:AutoToggleLocList()
|
||||
if s:BufHasErrorsOrWarningsToDisplay()
|
||||
if g:syntastic_auto_loc_list == 1
|
||||
call s:ShowLocList()
|
||||
endif
|
||||
else
|
||||
if g:syntastic_auto_loc_list > 0
|
||||
|
||||
"TODO: this will close the loc list window if one was opened by
|
||||
"something other than syntastic
|
||||
lclose
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"lazy init the loc list for the current buffer
|
||||
function! s:LocList()
|
||||
if !exists("b:syntastic_loclist")
|
||||
let b:syntastic_loclist = []
|
||||
endif
|
||||
return b:syntastic_loclist
|
||||
endfunction
|
||||
|
||||
"clear the loc list for the buffer
|
||||
function! s:ClearLocList()
|
||||
let b:syntastic_loclist = []
|
||||
endfunction
|
||||
|
||||
"detect and cache all syntax errors in this buffer
|
||||
"
|
||||
"depends on a function called SyntaxCheckers_{&ft}_GetLocList() existing
|
||||
"elsewhere
|
||||
function! s:CacheErrors()
|
||||
call s:ClearLocList()
|
||||
|
||||
if filereadable(expand("%"))
|
||||
|
||||
"sub - for _ in filetypes otherwise we cant name syntax checker
|
||||
"functions legally for filetypes like "gentoo-metadata"
|
||||
let fts = substitute(&ft, '-', '_', 'g')
|
||||
for ft in split(fts, '\.')
|
||||
if s:Checkable(ft)
|
||||
let errors = SyntaxCheckers_{ft}_GetLocList()
|
||||
"make errors have type "E" by default
|
||||
call SyntasticAddToErrors(errors, {'type': 'E'})
|
||||
call extend(s:LocList(), errors)
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"toggle the g:syntastic_mode_map['mode']
|
||||
function! s:ToggleMode()
|
||||
if g:syntastic_mode_map['mode'] == "active"
|
||||
let g:syntastic_mode_map['mode'] = "passive"
|
||||
else
|
||||
let g:syntastic_mode_map['mode'] = "active"
|
||||
endif
|
||||
|
||||
call s:ClearLocList()
|
||||
call s:UpdateErrors(1)
|
||||
|
||||
echo "Syntastic: " . g:syntastic_mode_map['mode'] . " mode enabled"
|
||||
endfunction
|
||||
|
||||
"check the current filetypes against g:syntastic_mode_map to determine whether
|
||||
"active mode syntax checking should be done
|
||||
function! s:ModeMapAllowsAutoChecking()
|
||||
let fts = split(&ft, '\.')
|
||||
|
||||
if g:syntastic_mode_map['mode'] == 'passive'
|
||||
"check at least one filetype is active
|
||||
let actives = g:syntastic_mode_map["active_filetypes"]
|
||||
return !empty(filter(fts, 'index(actives, v:val) != -1'))
|
||||
else
|
||||
"check no filetypes are passive
|
||||
let passives = g:syntastic_mode_map["passive_filetypes"]
|
||||
return empty(filter(fts, 'index(passives, v:val) != -1'))
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"return true if there are cached errors/warnings for this buf
|
||||
function! s:BufHasErrorsOrWarnings()
|
||||
return !empty(s:LocList())
|
||||
endfunction
|
||||
|
||||
"return true if there are cached errors for this buf
|
||||
function! s:BufHasErrors()
|
||||
return len(s:ErrorsForType('E')) > 0
|
||||
endfunction
|
||||
|
||||
function! s:BufHasErrorsOrWarningsToDisplay()
|
||||
return s:BufHasErrors() || (!g:syntastic_quiet_warnings && s:BufHasErrorsOrWarnings())
|
||||
endfunction
|
||||
|
||||
function! s:ErrorsForType(type)
|
||||
return s:FilterLocList({'type': a:type})
|
||||
endfunction
|
||||
|
||||
function! s:Errors()
|
||||
return s:ErrorsForType("E")
|
||||
endfunction
|
||||
|
||||
function! s:Warnings()
|
||||
return s:ErrorsForType("W")
|
||||
endfunction
|
||||
|
||||
"Filter a loc list (defaults to s:LocList()) by a:filters
|
||||
"e.g.
|
||||
" s:FilterLocList({'bufnr': 10, 'type': 'e'})
|
||||
"
|
||||
"would return all errors in s:LocList() for buffer 10.
|
||||
"
|
||||
"Note that all comparisons are done with ==?
|
||||
function! s:FilterLocList(filters, ...)
|
||||
let llist = a:0 ? a:1 : s:LocList()
|
||||
|
||||
let rv = deepcopy(llist)
|
||||
for error in llist
|
||||
for key in keys(a:filters)
|
||||
let rhs = a:filters[key]
|
||||
if type(rhs) == 1 "string
|
||||
let rhs = '"' . rhs . '"'
|
||||
endif
|
||||
|
||||
call filter(rv, "v:val['".key."'] ==? " . rhs)
|
||||
endfor
|
||||
endfor
|
||||
return rv
|
||||
endfunction
|
||||
|
||||
if g:syntastic_enable_signs
|
||||
"use >> to display syntax errors in the sign column
|
||||
sign define SyntasticError text=>> texthl=error
|
||||
sign define SyntasticWarning text=>> texthl=todo
|
||||
endif
|
||||
|
||||
"start counting sign ids at 5000, start here to hopefully avoid conflicting
|
||||
"with any other code that places signs (not sure if this precaution is
|
||||
"actually needed)
|
||||
let s:first_sign_id = 5000
|
||||
let s:next_sign_id = s:first_sign_id
|
||||
|
||||
"place signs by all syntax errs in the buffer
|
||||
function! s:SignErrors()
|
||||
if s:BufHasErrorsOrWarningsToDisplay()
|
||||
|
||||
let errors = s:FilterLocList({'bufnr': bufnr('')})
|
||||
for i in errors
|
||||
let sign_type = 'SyntasticError'
|
||||
if i['type'] ==? 'W'
|
||||
let sign_type = 'SyntasticWarning'
|
||||
endif
|
||||
|
||||
if !s:WarningMasksError(i, errors)
|
||||
exec "sign place ". s:next_sign_id ." line=". i['lnum'] ." name=". sign_type ." file=". expand("%:p")
|
||||
call add(s:BufSignIds(), s:next_sign_id)
|
||||
let s:next_sign_id += 1
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"return true if the given error item is a warning that, if signed, would
|
||||
"potentially mask an error if displayed at the same time
|
||||
function! s:WarningMasksError(error, llist)
|
||||
if a:error['type'] !=? 'w'
|
||||
return 0
|
||||
endif
|
||||
|
||||
return len(s:FilterLocList({ 'type': "E", 'lnum': a:error['lnum'] }, a:llist)) > 0
|
||||
endfunction
|
||||
|
||||
"remove the signs with the given ids from this buffer
|
||||
function! s:RemoveSigns(ids)
|
||||
for i in a:ids
|
||||
exec "sign unplace " . i
|
||||
call remove(s:BufSignIds(), index(s:BufSignIds(), i))
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
"get all the ids of the SyntaxError signs in the buffer
|
||||
function! s:BufSignIds()
|
||||
if !exists("b:syntastic_sign_ids")
|
||||
let b:syntastic_sign_ids = []
|
||||
endif
|
||||
return b:syntastic_sign_ids
|
||||
endfunction
|
||||
|
||||
"update the error signs
|
||||
function! s:RefreshSigns()
|
||||
let old_signs = copy(s:BufSignIds())
|
||||
call s:SignErrors()
|
||||
call s:RemoveSigns(old_signs)
|
||||
let s:first_sign_id = s:next_sign_id
|
||||
endfunction
|
||||
|
||||
"display the cached errors for this buf in the location list
|
||||
function! s:ShowLocList()
|
||||
if !empty(s:LocList())
|
||||
let num = winnr()
|
||||
lopen
|
||||
if num != winnr()
|
||||
wincmd p
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"remove all error highlights from the window
|
||||
function! s:ClearErrorHighlights()
|
||||
for match in getmatches()
|
||||
if stridx(match['group'], 'Syntastic') == 0
|
||||
call matchdelete(match['id'])
|
||||
endif
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
"check if a syntax checker exists for the given filetype - and attempt to
|
||||
"load one
|
||||
function! s:Checkable(ft)
|
||||
if !exists("g:loaded_" . a:ft . "_syntax_checker")
|
||||
exec "runtime syntax_checkers/" . a:ft . ".vim"
|
||||
endif
|
||||
|
||||
return exists("*SyntaxCheckers_". a:ft ."_GetLocList")
|
||||
endfunction
|
||||
|
||||
"set up error ballons for the current set of errors
|
||||
function! s:RefreshBalloons()
|
||||
let b:syntastic_balloons = {}
|
||||
if s:BufHasErrorsOrWarningsToDisplay()
|
||||
for i in s:LocList()
|
||||
let b:syntastic_balloons[i['lnum']] = i['text']
|
||||
endfor
|
||||
set beval bexpr=SyntasticErrorBalloonExpr()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"print as much of a:msg as possible without "Press Enter" prompt appearing
|
||||
function! s:WideMsg(msg)
|
||||
let old_ruler = &ruler
|
||||
let old_showcmd = &showcmd
|
||||
|
||||
let msg = strpart(a:msg, 0, winwidth(0)-1)
|
||||
|
||||
"This is here because it is possible for some error messages to begin with
|
||||
"\n which will cause a "press enter" prompt. I have noticed this in the
|
||||
"javascript:jshint checker and have been unable to figure out why it
|
||||
"happens
|
||||
let msg = substitute(msg, "\n", "", "g")
|
||||
|
||||
set noruler noshowcmd
|
||||
redraw
|
||||
|
||||
echo msg
|
||||
|
||||
let &ruler=old_ruler
|
||||
let &showcmd=old_showcmd
|
||||
endfunction
|
||||
|
||||
"echo out the first error we find for the current line in the cmd window
|
||||
function! s:EchoCurrentError()
|
||||
"If we have an error or warning at the current line, show it
|
||||
let errors = s:FilterLocList({'lnum': line("."), "type": 'e'})
|
||||
let warnings = s:FilterLocList({'lnum': line("."), "type": 'w'})
|
||||
|
||||
let b:syntastic_echoing_error = len(errors) || len(warnings)
|
||||
if len(errors)
|
||||
return s:WideMsg(errors[0]['text'])
|
||||
endif
|
||||
if len(warnings)
|
||||
return s:WideMsg(warnings[0]['text'])
|
||||
endif
|
||||
|
||||
"Otherwise, clear the status line
|
||||
if b:syntastic_echoing_error
|
||||
echo
|
||||
let b:syntastic_echoing_error = 0
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"return a string representing the state of buffer according to
|
||||
"g:syntastic_stl_format
|
||||
"
|
||||
"return '' if no errors are cached for the buffer
|
||||
function! SyntasticStatuslineFlag()
|
||||
if s:BufHasErrorsOrWarningsToDisplay()
|
||||
let errors = s:Errors()
|
||||
let warnings = s:Warnings()
|
||||
|
||||
let output = g:syntastic_stl_format
|
||||
|
||||
"hide stuff wrapped in %E(...) unless there are errors
|
||||
let output = substitute(output, '\C%E{\([^}]*\)}', len(errors) ? '\1' : '' , 'g')
|
||||
|
||||
"hide stuff wrapped in %W(...) unless there are warnings
|
||||
let output = substitute(output, '\C%W{\([^}]*\)}', len(warnings) ? '\1' : '' , 'g')
|
||||
|
||||
"hide stuff wrapped in %B(...) unless there are both errors and warnings
|
||||
let output = substitute(output, '\C%B{\([^}]*\)}', (len(warnings) && len(errors)) ? '\1' : '' , 'g')
|
||||
|
||||
"sub in the total errors/warnings/both
|
||||
let output = substitute(output, '\C%w', len(warnings), 'g')
|
||||
let output = substitute(output, '\C%e', len(errors), 'g')
|
||||
let output = substitute(output, '\C%t', len(s:LocList()), 'g')
|
||||
|
||||
"first error/warning line num
|
||||
let output = substitute(output, '\C%F', s:LocList()[0]['lnum'], 'g')
|
||||
|
||||
"first error line num
|
||||
let output = substitute(output, '\C%fe', len(errors) ? errors[0]['lnum'] : '', 'g')
|
||||
|
||||
"first warning line num
|
||||
let output = substitute(output, '\C%fw', len(warnings) ? warnings[0]['lnum'] : '', 'g')
|
||||
|
||||
return output
|
||||
else
|
||||
return ''
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"A wrapper for the :lmake command. Sets up the make environment according to
|
||||
"the options given, runs make, resets the environment, returns the location
|
||||
"list
|
||||
"
|
||||
"a:options can contain the following keys:
|
||||
" 'makeprg'
|
||||
" 'errorformat'
|
||||
"
|
||||
"The corresponding options are set for the duration of the function call. They
|
||||
"are set with :let, so dont escape spaces.
|
||||
"
|
||||
"a:options may also contain:
|
||||
" 'defaults' - a dict containing default values for the returned errors
|
||||
function! SyntasticMake(options)
|
||||
let old_loclist = getloclist(0)
|
||||
let old_makeprg = &makeprg
|
||||
let old_shellpipe = &shellpipe
|
||||
let old_shell = &shell
|
||||
let old_errorformat = &errorformat
|
||||
|
||||
if !s:running_windows && (s:uname !~ "FreeBSD")
|
||||
"this is a hack to stop the screen needing to be ':redraw'n when
|
||||
"when :lmake is run. Otherwise the screen flickers annoyingly
|
||||
let &shellpipe='&>'
|
||||
let &shell = '/bin/bash'
|
||||
endif
|
||||
|
||||
if has_key(a:options, 'makeprg')
|
||||
let &makeprg = a:options['makeprg']
|
||||
endif
|
||||
|
||||
if has_key(a:options, 'errorformat')
|
||||
let &errorformat = a:options['errorformat']
|
||||
endif
|
||||
|
||||
silent lmake!
|
||||
let errors = getloclist(0)
|
||||
|
||||
call setloclist(0, old_loclist)
|
||||
let &makeprg = old_makeprg
|
||||
let &errorformat = old_errorformat
|
||||
let &shellpipe=old_shellpipe
|
||||
let &shell=old_shell
|
||||
|
||||
if !s:running_windows && s:uname =~ "FreeBSD"
|
||||
redraw!
|
||||
endif
|
||||
|
||||
if has_key(a:options, 'defaults')
|
||||
call SyntasticAddToErrors(errors, a:options['defaults'])
|
||||
endif
|
||||
|
||||
return errors
|
||||
endfunction
|
||||
|
||||
"get the error balloon for the current mouse position
|
||||
function! SyntasticErrorBalloonExpr()
|
||||
if !exists('b:syntastic_balloons')
|
||||
return ''
|
||||
endif
|
||||
return get(b:syntastic_balloons, v:beval_lnum, '')
|
||||
endfunction
|
||||
|
||||
"highlight the list of errors (a:errors) using matchadd()
|
||||
"
|
||||
"a:termfunc is provided to highlight errors that do not have a 'col' key (and
|
||||
"hence cant be done automatically). This function must take one arg (an error
|
||||
"item) and return a regex to match that item in the buffer.
|
||||
"
|
||||
"an optional boolean third argument can be provided to force a:termfunc to be
|
||||
"used regardless of whether a 'col' key is present for the error
|
||||
function! SyntasticHighlightErrors(errors, termfunc, ...)
|
||||
if !g:syntastic_enable_highlighting
|
||||
return
|
||||
endif
|
||||
|
||||
call s:ClearErrorHighlights()
|
||||
|
||||
let force_callback = a:0 && a:1
|
||||
for item in a:errors
|
||||
let group = item['type'] == 'E' ? 'SyntasticError' : 'SyntasticWarning'
|
||||
if item['col'] && !force_callback
|
||||
let lastcol = col([item['lnum'], '$'])
|
||||
let lcol = min([lastcol, item['col']])
|
||||
call matchadd(group, '\%'.item['lnum'].'l\%'.lcol.'c')
|
||||
else
|
||||
let term = a:termfunc(item)
|
||||
if len(term) > 0
|
||||
call matchadd(group, '\%' . item['lnum'] . 'l' . term)
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
"take a list of errors and add default values to them from a:options
|
||||
function! SyntasticAddToErrors(errors, options)
|
||||
for i in range(0, len(a:errors)-1)
|
||||
for key in keys(a:options)
|
||||
if empty(a:errors[i][key])
|
||||
let a:errors[i][key] = a:options[key]
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
return a:errors
|
||||
endfunction
|
||||
|
||||
" vim: set et sts=4 sw=4:
|
||||
@@ -1,43 +0,0 @@
|
||||
"==============================================================================
|
||||
" FileName: applescript.vim
|
||||
" Desc: Syntax checking plugin for syntastic.vim
|
||||
" Author: Zhao Cai
|
||||
" Email: caizhaoff@gmail.com
|
||||
" Version: 0.2.1
|
||||
" Date Created: Thu 09 Sep 2011 10:30:09 AM EST
|
||||
" Last Modified: Fri 09 Dec 2011 01:10:24 PM EST
|
||||
"
|
||||
" History: 0.1.0 - working, but it will run the script everytime to check
|
||||
" syntax. Should use osacompile but strangely it does not give
|
||||
" errors.
|
||||
"
|
||||
" 0.2.0 - switch to osacompile, it gives less errors compared
|
||||
" with osascript.
|
||||
"
|
||||
" 0.2.1 - remove g:syntastic_applescript_tempfile. use
|
||||
" tempname() instead.
|
||||
"
|
||||
" License: This program is free software. It comes without any
|
||||
" warranty, to the extent permitted by applicable law. You can
|
||||
" redistribute it and/or modify it under the terms of the Do What The
|
||||
" Fuck You Want To Public License, Version 2, as published by Sam
|
||||
" Hocevar. See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists("loaded_applescript_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_applescript_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have osacompile installed
|
||||
if !executable("osacompile")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_applescript_GetLocList()
|
||||
let makeprg = 'osacompile -o ' . tempname() . '.scpt '. shellescape(expand('%'))
|
||||
let errorformat = '%f:%l:%m'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,156 +0,0 @@
|
||||
"============================================================================
|
||||
"File: c.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
" In order to also check header files add this to your .vimrc:
|
||||
" (this usually creates a .gch file in your source directory)
|
||||
"
|
||||
" let g:syntastic_c_check_header = 1
|
||||
"
|
||||
" To disable the search of included header files after special
|
||||
" libraries like gtk and glib add this line to your .vimrc:
|
||||
"
|
||||
" let g:syntastic_c_no_include_search = 1
|
||||
"
|
||||
" To enable header files being re-checked on every file write add the
|
||||
" following line to your .vimrc. Otherwise the header files are checked only
|
||||
" one time on initially loading the file.
|
||||
" In order to force syntastic to refresh the header includes simply
|
||||
" unlet b:syntastic_c_includes. Then the header files are being re-checked on
|
||||
" the next file write.
|
||||
"
|
||||
" let g:syntastic_c_auto_refresh_includes = 1
|
||||
"
|
||||
" Alternatively you can set the buffer local variable b:syntastic_c_cflags.
|
||||
" If this variable is set for the current buffer no search for additional
|
||||
" libraries is done. I.e. set the variable like this:
|
||||
"
|
||||
" let b:syntastic_c_cflags = ' -I/usr/include/libsoup-2.4'
|
||||
"
|
||||
" In order to add some custom include directories that should be added to the
|
||||
" gcc command line you can add those to the global variable
|
||||
" g:syntastic_c_include_dirs. This list can be used like this:
|
||||
"
|
||||
" let g:syntastic_c_include_dirs = [ 'includes', 'headers' ]
|
||||
"
|
||||
" Moreover it is possible to add additional compiler options to the syntax
|
||||
" checking execution via the variable 'g:syntastic_c_compiler_options':
|
||||
"
|
||||
" let g:syntastic_c_compiler_options = ' -ansi'
|
||||
"
|
||||
" Using the global variable 'g:syntastic_c_remove_include_errors' you can
|
||||
" specify whether errors of files included via the g:syntastic_c_include_dirs'
|
||||
" setting are removed from the result set:
|
||||
"
|
||||
" let g:syntastic_c_remove_include_errors = 1
|
||||
|
||||
if exists('loaded_c_syntax_checker')
|
||||
finish
|
||||
endif
|
||||
let loaded_c_syntax_checker = 1
|
||||
|
||||
if !executable('gcc')
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
" default include directories
|
||||
let s:default_includes = [ '.', '..', 'include', 'includes',
|
||||
\ '../include', '../includes' ]
|
||||
|
||||
" uniquify the input list
|
||||
function! s:Unique(list)
|
||||
let l = []
|
||||
for elem in a:list
|
||||
if index(l, elem) == -1
|
||||
let l = add(l, elem)
|
||||
endif
|
||||
endfor
|
||||
return l
|
||||
endfunction
|
||||
|
||||
" get the gcc include directory argument depending on the default
|
||||
" includes and the optional user-defined 'g:syntastic_c_include_dirs'
|
||||
function! s:GetIncludeDirs()
|
||||
let include_dirs = s:default_includes
|
||||
|
||||
if exists('g:syntastic_c_include_dirs')
|
||||
call extend(include_dirs, g:syntastic_c_include_dirs)
|
||||
endif
|
||||
|
||||
return join(map(s:Unique(include_dirs), '"-I" . v:val'), ' ')
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_c_GetLocList()
|
||||
let makeprg = 'gcc -fsyntax-only -std=gnu99 '.shellescape(expand('%')).
|
||||
\ ' '.s:GetIncludeDirs()
|
||||
let errorformat = '%-G%f:%s:,%-G%f:%l: %#error: %#(Each undeclared '.
|
||||
\ 'identifier is reported only%.%#,%-G%f:%l: %#error: %#for '.
|
||||
\ 'each function it appears%.%#,%-GIn file included%.%#,'.
|
||||
\ '%-G %#from %f:%l\,,%f:%l:%c: %m,%f:%l: %trror: %m,%f:%l: %m'
|
||||
|
||||
" determine whether to parse header files as well
|
||||
if expand('%') =~? '.h$'
|
||||
if exists('g:syntastic_c_check_header')
|
||||
let makeprg = 'gcc -c '.shellescape(expand('%')).
|
||||
\ ' '.s:GetIncludeDirs()
|
||||
else
|
||||
return []
|
||||
endif
|
||||
endif
|
||||
|
||||
" add optional user-defined compiler options
|
||||
if exists('g:syntastic_c_compiler_options')
|
||||
let makeprg .= g:syntastic_c_compiler_options
|
||||
endif
|
||||
|
||||
" check if the user manually set some cflags
|
||||
if !exists('b:syntastic_c_cflags')
|
||||
" check whether to search for include files at all
|
||||
if !exists('g:syntastic_c_no_include_search') ||
|
||||
\ g:syntastic_c_no_include_search != 1
|
||||
" refresh the include file search if desired
|
||||
if exists('g:syntastic_c_auto_refresh_includes') &&
|
||||
\ g:syntastic_c_auto_refresh_includes != 0
|
||||
let makeprg .= syntastic#c#SearchHeaders()
|
||||
else
|
||||
" search for header includes if not cached already
|
||||
if !exists('b:syntastic_c_includes')
|
||||
let b:syntastic_c_includes = syntastic#c#SearchHeaders()
|
||||
endif
|
||||
let makeprg .= b:syntastic_c_includes
|
||||
endif
|
||||
endif
|
||||
else
|
||||
" use the user-defined cflags
|
||||
let makeprg .= b:syntastic_c_cflags
|
||||
endif
|
||||
|
||||
" process makeprg
|
||||
let errors = SyntasticMake({ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
|
||||
" filter the processed errors if desired
|
||||
if exists('g:syntastic_c_remove_include_errors') &&
|
||||
\ g:syntastic_c_remove_include_errors != 0
|
||||
return filter(errors,
|
||||
\ 'has_key(v:val, "bufnr") && v:val["bufnr"]=='.bufnr(''))
|
||||
else
|
||||
return errors
|
||||
endif
|
||||
endfunction
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set et sts=4 sw=4:
|
||||
@@ -1,27 +0,0 @@
|
||||
"============================================================================
|
||||
"File: coffee.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Lincoln Stoll <l@lds.li>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_coffee_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_coffee_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have coffee installed
|
||||
if !executable("coffee")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_coffee_GetLocList()
|
||||
let makeprg = 'coffee -c -l -o /tmp '.shellescape(expand('%'))
|
||||
let errorformat = 'Syntax%trror: In %f\, %m on line %l,%EError: In %f\, Parse error on line %l: %m,%EError: In %f\, %m on line %l,%W%f(%l): lint warning: %m,%-Z%p^,%W%f(%l): warning: %m,%-Z%p^,%E%f(%l): SyntaxError: %m,%-Z%p^,%-G%.%#'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,94 +0,0 @@
|
||||
"============================================================================
|
||||
"File: cpp.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
" in order to also check header files add this to your .vimrc:
|
||||
" (this usually creates a .gch file in your source directory)
|
||||
"
|
||||
" let g:syntastic_cpp_check_header = 1
|
||||
"
|
||||
" To disable the search of included header files after special
|
||||
" libraries like gtk and glib add this line to your .vimrc:
|
||||
"
|
||||
" let g:syntastic_cpp_no_include_search = 1
|
||||
"
|
||||
" To enable header files being re-checked on every file write add the
|
||||
" following line to your .vimrc. Otherwise the header files are checked only
|
||||
" one time on initially loading the file.
|
||||
" In order to force syntastic to refresh the header includes simply
|
||||
" unlet b:syntastic_cpp_includes. Then the header files are being re-checked
|
||||
" on the next file write.
|
||||
"
|
||||
" let g:syntastic_cpp_auto_refresh_includes = 1
|
||||
"
|
||||
" Alternatively you can set the buffer local variable b:syntastic_cpp_cflags.
|
||||
" If this variable is set for the current buffer no search for additional
|
||||
" libraries is done. I.e. set the variable like this:
|
||||
"
|
||||
" let b:syntastic_cpp_cflags = ' -I/usr/include/libsoup-2.4'
|
||||
"
|
||||
" Moreover it is possible to add additional compiler options to the syntax
|
||||
" checking execution via the variable 'g:syntastic_cpp_compiler_options':
|
||||
"
|
||||
" let g:syntastic_cpp_compiler_options = ' -std=c++0x'
|
||||
|
||||
if exists('loaded_cpp_syntax_checker')
|
||||
finish
|
||||
endif
|
||||
let loaded_cpp_syntax_checker = 1
|
||||
|
||||
if !executable('g++')
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_cpp_GetLocList()
|
||||
let makeprg = 'g++ -fsyntax-only '.shellescape(expand('%'))
|
||||
let errorformat = '%-G%f:%s:,%f:%l:%c: %m,%f:%l: %m'
|
||||
|
||||
if expand('%') =~? '\%(.h\|.hpp\|.hh\)$'
|
||||
if exists('g:syntastic_cpp_check_header')
|
||||
let makeprg = 'g++ -c '.shellescape(expand('%'))
|
||||
else
|
||||
return []
|
||||
endif
|
||||
endif
|
||||
|
||||
if exists('g:syntastic_cpp_compiler_options')
|
||||
let makeprg .= g:syntastic_cpp_compiler_options
|
||||
endif
|
||||
|
||||
if !exists('b:syntastic_cpp_cflags')
|
||||
if !exists('g:syntastic_cpp_no_include_search') ||
|
||||
\ g:syntastic_cpp_no_include_search != 1
|
||||
if exists('g:syntastic_cpp_auto_refresh_includes') &&
|
||||
\ g:syntastic_cpp_auto_refresh_includes != 0
|
||||
let makeprg .= syntastic#c#SearchHeaders()
|
||||
else
|
||||
if !exists('b:syntastic_cpp_includes')
|
||||
let b:syntastic_cpp_includes = syntastic#c#SearchHeaders()
|
||||
endif
|
||||
let makeprg .= b:syntastic_cpp_includes
|
||||
endif
|
||||
endif
|
||||
else
|
||||
let makeprg .= b:syntastic_cpp_cflags
|
||||
endif
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set et sts=4 sw=4:
|
||||
@@ -1,31 +0,0 @@
|
||||
"============================================================================
|
||||
"File: css.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim using `csslint` CLI tool (http://csslint.net).
|
||||
"Maintainer: Ory Band <oryband at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"============================================================================
|
||||
if exists("loaded_css_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_css_syntax_checker = 1
|
||||
|
||||
" Bail if the user doesn't have `csslint` installed.
|
||||
if !executable("csslint")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_css_GetLocList()
|
||||
let makeprg = 'csslint --format=compact '.shellescape(expand('%'))
|
||||
|
||||
" Print CSS Lint's error/warning messages from compact format. Ignores blank lines.
|
||||
let errorformat = '%-G,%-G%f: lint free!,%f: line %l\, col %c\, %trror - %m,%f: line %l\, col %c\, %tarning - %m,%f: line %l\, col %c\, %m,'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': {'bufnr': bufnr("")} })
|
||||
|
||||
endfunction
|
||||
@@ -1,27 +0,0 @@
|
||||
"============================================================================
|
||||
"File: cucumber.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_cucumber_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_cucumber_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have cucumber installed
|
||||
if !executable("cucumber")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_cucumber_GetLocList()
|
||||
let makeprg = 'cucumber --dry-run --quiet --strict --format pretty '.shellescape(expand('%'))
|
||||
let errorformat = '%f:%l:%c:%m,%W %.%# (%m),%-Z%f:%l:%.%#,%-G%.%#'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,37 +0,0 @@
|
||||
"============================================================================
|
||||
"File: cuda.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"
|
||||
"Author: Hannes Schulz <schulz at ais dot uni-bonn dot de>
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
" in order to also check header files add this to your .vimrc:
|
||||
" (this creates an empty .syntastic_dummy.cu file in your source directory)
|
||||
"
|
||||
" let g:syntastic_cuda_check_header = 1
|
||||
|
||||
if exists('loaded_cuda_syntax_checker')
|
||||
finish
|
||||
endif
|
||||
let loaded_cuda_syntax_checker = 1
|
||||
|
||||
if !executable('nvcc')
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_cuda_GetLocList()
|
||||
let makeprg = 'nvcc --cuda -O0 -I . -Xcompiler -fsyntax-only '.shellescape(expand('%')).' -o /dev/null'
|
||||
"let errorformat = '%-G%f:%s:,%f:%l:%c: %m,%f:%l: %m'
|
||||
let errorformat = '%*[^"]"%f"%*\D%l: %m,"%f"%*\D%l: %m,%-G%f:%l: (Each undeclared identifier is reported only once,%-G%f:%l: for each function it appears in.),%f:%l:%c:%m,%f(%l):%m,%f:%l:%m,"%f"\, line %l%*\D%c%*[^ ] %m,%D%*\a[%*\d]: Entering directory `%f'',%X%*\a[%*\d]: Leaving directory `%f'',%D%*\a: Entering directory `%f'',%X%*\a: Leaving directory `%f'',%DMaking %*\a in %f,%f|%l| %m'
|
||||
|
||||
if expand('%') =~? '\%(.h\|.hpp\|.cuh\)$'
|
||||
if exists('g:syntastic_cuda_check_header')
|
||||
let makeprg = 'echo > .syntastic_dummy.cu ; nvcc --cuda -O0 -I . .syntastic_dummy.cu -Xcompiler -fsyntax-only -include '.shellescape(expand('%')).' -o /dev/null'
|
||||
else
|
||||
return []
|
||||
endif
|
||||
endif
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,29 +0,0 @@
|
||||
"============================================================================
|
||||
"File: docbk.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_docbk_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_docbk_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have tidy or grep installed
|
||||
if !executable("xmllint")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_docbk_GetLocList()
|
||||
|
||||
let makeprg="xmllint --xinclude --noout --postvalid ".shellescape(expand(%:p))
|
||||
let errorformat='%E%f:%l: parser error : %m,%W%f:%l: parser warning : %m,%E%f:%l:%.%# validity error : %m,%W%f:%l:%.%# validity warning : %m,%-Z%p^,%-C%.%#,%-G%.%#'
|
||||
let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
@@ -1,42 +0,0 @@
|
||||
"============================================================================
|
||||
"File: erlang.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Pawel Salata <rockplayer.pl at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_erlang_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_erlang_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have escript installed
|
||||
if !executable("escript")
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:check_file = expand('<sfile>:p:h') . '/erlang_check_file.erl'
|
||||
|
||||
function! SyntaxCheckers_erlang_GetLocList()
|
||||
let extension = expand('%:e')
|
||||
if match(extension, 'hrl') >= 0
|
||||
return []
|
||||
endif
|
||||
let shebang = getbufline(bufnr('%'), 1)[0]
|
||||
if len(shebang) > 0
|
||||
if match(shebang, 'escript') >= 0
|
||||
let makeprg = 'escript -s '.shellescape(expand('%:p'))
|
||||
else
|
||||
let makeprg = s:check_file . ' '. shellescape(expand('%:p'))
|
||||
endif
|
||||
else
|
||||
let makeprg = s:check_file . ' ' . shellescape(expand('%:p'))
|
||||
endif
|
||||
let errorformat = '%f:%l:\ %tarning:\ %m,%E%f:%l:\ %m'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,12 +0,0 @@
|
||||
#!/usr/bin/env escript
|
||||
-export([main/1]).
|
||||
|
||||
main([FileName]) ->
|
||||
compile:file(FileName, [warn_obsolete_guard,
|
||||
warn_unused_import,
|
||||
warn_shadow_vars,
|
||||
warn_export_vars,
|
||||
strong_validation,
|
||||
report,
|
||||
{i, filename:dirname(FileName) ++ "/../include"}
|
||||
]).
|
||||
@@ -1,34 +0,0 @@
|
||||
"============================================================================
|
||||
"File: eruby.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_eruby_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_eruby_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have ruby or cat installed
|
||||
if !executable("ruby") || !executable("cat")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_eruby_GetLocList()
|
||||
if has('win32') || has('win64')
|
||||
let makeprg='sed "s/<\%=/<\%/g" '. shellescape(expand("%")) . ' \| ruby -e "require \"erb\"; puts ERB.new(ARGF.read, nil, \"-\").src" \| ruby -c'
|
||||
else
|
||||
let makeprg='sed "s/<\%=/<\%/g" '. shellescape(expand("%")) . ' \| RUBYOPT= ruby -e "require \"erb\"; puts ERB.new(ARGF.read, nil, \"-\").src" \| RUBYOPT= ruby -c'
|
||||
endif
|
||||
|
||||
let errorformat='%-GSyntax OK,%E-:%l: syntax error\, %m,%Z%p^,%W-:%l: warning: %m,%Z%p^,%-C%.%#'
|
||||
return SyntasticMake({ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': {'bufnr': bufnr("")} })
|
||||
|
||||
endfunction
|
||||
@@ -1,44 +0,0 @@
|
||||
"============================================================================
|
||||
"File: fortran.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Karl Yngve Lervåg <karl.yngve@lervag.net>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"Note: This syntax checker uses gfortran with the option -fsyntax-only
|
||||
" to check for errors and warnings. Additional flags may be
|
||||
" supplied through both local and global variables,
|
||||
" b:syntastic_fortran_flags,
|
||||
" g:syntastic_fortran_flags.
|
||||
" This is particularly useful when the source requires module files
|
||||
" in order to compile (that is when it needs modules defined in
|
||||
" separate files).
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists("loaded_fortran_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_fortran_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have fortran installed
|
||||
if !executable("gfortran")
|
||||
finish
|
||||
endif
|
||||
|
||||
if !exists('g:syntastic_fortran_flags')
|
||||
let g:syntastic_fortran_flags = ''
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_fortran_GetLocList()
|
||||
let makeprg = 'gfortran -fsyntax-only'
|
||||
let makeprg .= g:syntastic_fortran_flags
|
||||
if exists('b:syntastic_fortran_flags')
|
||||
let makeprg .= b:syntastic_fortran_flags
|
||||
endif
|
||||
let makeprg .= ' ' . shellescape(expand('%'))
|
||||
let errorformat = '%-C %#,%-C %#%.%#,%A%f:%l.%c:,%Z%m,%G%.%#'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,37 +0,0 @@
|
||||
"============================================================================
|
||||
"File: gentoo-metadata.vim
|
||||
"Description: Syntax checking plugin for Gentoo's metadata.xml files
|
||||
"Maintainer: James Rowe <jnrowe at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
" The DTDs required to validate metadata.xml files are available in
|
||||
" $PORTDIR/metadata/dtd, and these local files can be used to significantly
|
||||
" speed up validation. You can create a catalog file with:
|
||||
"
|
||||
" xmlcatalog --create --add rewriteURI http://www.gentoo.org/dtd/ \
|
||||
" ${PORTDIR:-/usr/portage}/metadata/dtd/ /etc/xml/gentoo
|
||||
"
|
||||
" See xmlcatalog(1) and http://www.xmlsoft.org/catalog.html for more
|
||||
" information.
|
||||
|
||||
if exists("loaded_gentoo_metadata_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_gentoo_metadata_syntax_checker = 1
|
||||
|
||||
"bail if the user doesn't have xmllint installed
|
||||
if !executable("xmllint")
|
||||
finish
|
||||
endif
|
||||
|
||||
runtime syntax_checkers/xml.vim
|
||||
|
||||
function! SyntaxCheckers_gentoo_metadata_GetLocList()
|
||||
return SyntaxCheckers_xml_GetLocList()
|
||||
endfunction
|
||||
@@ -1,27 +0,0 @@
|
||||
"============================================================================
|
||||
"File: go.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Sam Nguyen <samxnguyen@gmail.com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_go_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_go_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have 6g installed
|
||||
if !executable("6g")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_go_GetLocList()
|
||||
let makeprg = '6g -o /dev/null %'
|
||||
let errorformat = '%E%f:%l: %m'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,26 +0,0 @@
|
||||
"============================================================================
|
||||
"File: haml.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_haml_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_haml_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have the haml binary installed
|
||||
if !executable("haml")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_haml_GetLocList()
|
||||
let makeprg = "haml -c " . shellescape(expand("%"))
|
||||
let errorformat = 'Haml error on line %l: %m,Syntax error on line %l: %m,%-G%.%#'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,37 +0,0 @@
|
||||
"============================================================================
|
||||
"File: haskell.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Anthony Carapetis <anthony.carapetis at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_haskell_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_haskell_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have ghc-mod installed
|
||||
if !executable("ghc-mod")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_haskell_GetLocList()
|
||||
let makeprg =
|
||||
\ "{ ".
|
||||
\ "ghc-mod check ". shellescape(expand('%')) . "; " .
|
||||
\ "ghc-mod lint " . shellescape(expand('%')) . ";" .
|
||||
\ " }"
|
||||
let errorformat = '%-G\\s%#,%f:%l:%c:%trror: %m,%f:%l:%c:%tarning: %m,'.
|
||||
\ '%f:%l:%c: %trror: %m,%f:%l:%c: %tarning: %m,%f:%l:%c:%m,'.
|
||||
\ '%E%f:%l:%c:,%Z%m,'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_lhaskell_GetLocList()
|
||||
return SyntaxCheckers_haskell_GetLocList()
|
||||
endfunction
|
||||
@@ -1,55 +0,0 @@
|
||||
"============================================================================
|
||||
"File: haxe.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: David Bernard <david.bernard.31 at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_haxe_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_haxe_syntax_checker = 1
|
||||
|
||||
"bail if the user doesn't have haxe installed
|
||||
if !executable("haxe")
|
||||
finish
|
||||
endif
|
||||
|
||||
" s:FindInParent
|
||||
" find the file argument and returns the path to it.
|
||||
" Starting with the current working dir, it walks up the parent folders
|
||||
" until it finds the file, or it hits the stop dir.
|
||||
" If it doesn't find it, it returns "Nothing"
|
||||
function! s:FindInParent(fln,flsrt,flstp)
|
||||
let here = a:flsrt
|
||||
while ( strlen( here) > 0 )
|
||||
let p = split(globpath(here, a:fln), '\n')
|
||||
if len(p) > 0
|
||||
return ['ok', here, fnamemodify(p[0], ':p:t')]
|
||||
endif
|
||||
let fr = match(here, '/[^/]*$')
|
||||
if fr == -1
|
||||
break
|
||||
endif
|
||||
let here = strpart(here, 0, fr)
|
||||
if here == a:flstp
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
return ['fail', '', '']
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_haxe_GetLocList()
|
||||
let [success, hxmldir, hxmlname] = s:FindInParent('*.hxml', expand('%:p:h'), '/')
|
||||
if success == 'ok'
|
||||
let makeprg = 'cd ' . hxmldir . '; haxe ' . hxmlname
|
||||
let errorformat = '%E%f:%l: characters %c-%*[0-9] : %m'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
else
|
||||
return SyntasticMake({})
|
||||
endif
|
||||
endfunction
|
||||
@@ -1,86 +0,0 @@
|
||||
"============================================================================
|
||||
"File: html.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_html_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_html_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have tidy or grep installed
|
||||
if !executable("tidy") || !executable("grep")
|
||||
finish
|
||||
endif
|
||||
|
||||
" TODO: join this with xhtml.vim for DRY's sake?
|
||||
function! s:TidyEncOptByFenc()
|
||||
let tidy_opts = {
|
||||
\'utf-8' : '-utf8',
|
||||
\'ascii' : '-ascii',
|
||||
\'latin1' : '-latin1',
|
||||
\'iso-2022-jp' : '-iso-2022',
|
||||
\'cp1252' : '-win1252',
|
||||
\'macroman' : '-mac',
|
||||
\'utf-16le' : '-utf16le',
|
||||
\'utf-16' : '-utf16',
|
||||
\'big5' : '-big5',
|
||||
\'sjis' : '-shiftjis',
|
||||
\'cp850' : '-ibm858',
|
||||
\}
|
||||
return get(tidy_opts, &fileencoding, '-utf8')
|
||||
endfunction
|
||||
|
||||
let s:ignore_html_errors = [
|
||||
\ "<table> lacks \"summary\" attribute",
|
||||
\ "not approved by W3C",
|
||||
\ "attribute \"placeholder\"",
|
||||
\ "<meta> proprietary attribute \"charset\"",
|
||||
\ "<meta> lacks \"content\" attribute",
|
||||
\ "inserting \"type\" attribute",
|
||||
\ "proprietary attribute \"data-"
|
||||
\]
|
||||
|
||||
function! s:ValidateError(text)
|
||||
let valid = 0
|
||||
for i in s:ignore_html_errors
|
||||
if stridx(a:text, i) != -1
|
||||
let valid = 1
|
||||
break
|
||||
endif
|
||||
endfor
|
||||
return valid
|
||||
endfunction
|
||||
|
||||
|
||||
function! SyntaxCheckers_html_GetLocList()
|
||||
|
||||
let encopt = s:TidyEncOptByFenc()
|
||||
let makeprg="tidy ".encopt." --new-blocklevel-tags ".shellescape('section, article, aside, hgroup, header, footer, nav, figure, figcaption')." --new-inline-tags ".shellescape('video, audio, embed, mark, progress, meter, time, ruby, rt, rp, canvas, command, details, datalist')." --new-empty-tags ".shellescape('wbr, keygen')." -e ".shellescape(expand('%'))." 2>&1"
|
||||
let errorformat='%Wline %l column %c - Warning: %m,%Eline %l column %c - Error: %m,%-G%.%#,%-G%.%#'
|
||||
let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
|
||||
" process loclist since we need to add some info and filter out valid HTML5
|
||||
" from the errors
|
||||
let n = len(loclist) - 1
|
||||
let bufnum = bufnr("")
|
||||
while n >= 0
|
||||
let i = loclist[n]
|
||||
" filter out valid HTML5
|
||||
if s:ValidateError(i['text']) == 1
|
||||
unlet loclist[n]
|
||||
else
|
||||
"the file name isnt in the output so stick in the buf num manually
|
||||
let i['bufnr'] = bufnum
|
||||
endif
|
||||
let n -= 1
|
||||
endwhile
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
@@ -1,41 +0,0 @@
|
||||
"============================================================================
|
||||
"File: javascript.vim
|
||||
"Description: Figures out which javascript syntax checker (if any) to load
|
||||
" from the javascript directory.
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
" Use g:syntastic_javascript_checker option to specify which jslint executable
|
||||
" should be used (see below for a list of supported checkers).
|
||||
" If g:syntastic_javascript_checker is not set, just use the first syntax
|
||||
" checker that we find installed.
|
||||
"============================================================================
|
||||
if exists("loaded_javascript_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_javascript_syntax_checker = 1
|
||||
|
||||
let s:supported_checkers = ["gjslint", "jslint", "jsl", "jshint"]
|
||||
|
||||
function! s:load_checker(checker)
|
||||
exec "runtime syntax_checkers/javascript/" . a:checker . ".vim"
|
||||
endfunction
|
||||
|
||||
if exists("g:syntastic_javascript_checker")
|
||||
if index(s:supported_checkers, g:syntastic_javascript_checker) != -1 && executable(g:syntastic_javascript_checker)
|
||||
call s:load_checker(g:syntastic_javascript_checker)
|
||||
else
|
||||
echoerr "Javascript syntax not supported or not installed."
|
||||
endif
|
||||
else
|
||||
for checker in s:supported_checkers
|
||||
if executable(checker)
|
||||
call s:load_checker(checker)
|
||||
break
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
@@ -1,20 +0,0 @@
|
||||
"============================================================================
|
||||
"File: gjslint.vim
|
||||
"Description: Javascript syntax checker - using gjslint
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"============================================================================
|
||||
if !exists("g:syntastic_javascript_gjslint_conf")
|
||||
let g:syntastic_javascript_gjslint_conf = ""
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_javascript_GetLocList()
|
||||
let makeprg = "gjslint " . g:syntastic_javascript_gjslint_conf . " --nosummary --unix_mode --nodebug_indentation --nobeep " . shellescape(expand('%'))
|
||||
let errorformat="%f:%l:(New Error -%\\?\%n) %m,%f:%l:(-%\\?%n) %m,%-G1 files checked, no errors found.,%-G%.%#"
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
"============================================================================
|
||||
"File: jshint.vim
|
||||
"Description: Javascript syntax checker - using jshint
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"============================================================================
|
||||
if !exists("g:syntastic_javascript_jshint_conf")
|
||||
let g:syntastic_javascript_jshint_conf = ""
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_javascript_GetLocList()
|
||||
" node-jshint uses .jshintrc as config unless --config arg is present
|
||||
let args = g:syntastic_javascript_jshint_conf? ' --config ' . g:syntastic_javascript_jshint_conf : ''
|
||||
let makeprg = 'jshint ' . shellescape(expand("%")) . args
|
||||
let errorformat = '%ELine %l:%c,%Z\\s%#Reason: %m,%C%.%#,%f: line %l\, col %c\, %m,%-G%.%#'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr('')} })
|
||||
endfunction
|
||||
@@ -1,20 +0,0 @@
|
||||
"============================================================================
|
||||
"File: jsl.vim
|
||||
"Description: Javascript syntax checker - using jsl
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"============================================================================
|
||||
if !exists("g:syntastic_javascript_jsl_conf")
|
||||
let g:syntastic_javascript_jsl_conf = ""
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_javascript_GetLocList()
|
||||
let makeprg = "jsl " . g:syntastic_javascript_jsl_conf . " -nologo -nofilelisting -nosummary -nocontext -process ".shellescape(expand('%'))
|
||||
let errorformat='%W%f(%l): lint warning: %m,%-Z%p^,%W%f(%l): warning: %m,%-Z%p^,%E%f(%l): SyntaxError: %m,%-Z%p^,%-G'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
"============================================================================
|
||||
"File: jslint.vim
|
||||
"Description: Javascript syntax checker - using jslint
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"Tested with jslint 0.1.4.
|
||||
"============================================================================
|
||||
if !exists("g:syntastic_javascript_jslint_conf")
|
||||
let g:syntastic_javascript_jslint_conf = "--white --undef --nomen --regexp --plusplus --bitwise --newcap --sloppy --vars"
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_javascript_HighlightTerm(error)
|
||||
let unexpected = matchstr(a:error['text'], 'Expected.*and instead saw \'\zs.*\ze\'')
|
||||
if len(unexpected) < 1 | return '' | end
|
||||
return '\V'.split(unexpected, "'")[1]
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_javascript_GetLocList()
|
||||
let makeprg = "jslint " . g:syntastic_javascript_jslint_conf . " " . shellescape(expand('%'))
|
||||
let errorformat='%E %##%n %m,%-Z%.%#Line %l\, Pos %c,%-G%.%#'
|
||||
let errors = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr("")} })
|
||||
call SyntasticHighlightErrors(errors, function('SyntaxCheckers_javascript_HighlightTerm'))
|
||||
|
||||
return errors
|
||||
endfunction
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
"============================================================================
|
||||
"File: json.vim
|
||||
"Description: Figures out which json syntax checker (if any) to load
|
||||
" from the json directory.
|
||||
"Maintainer: Miller Medeiros <contact at millermedeiros dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
" Use g:syntastic_json_checker option to specify which jsonlint executable
|
||||
" should be used (see below for a list of supported checkers).
|
||||
" If g:syntastic_json_checker is not set, just use the first syntax
|
||||
" checker that we find installed.
|
||||
"============================================================================
|
||||
if exists("loaded_json_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_json_syntax_checker = 1
|
||||
|
||||
let s:supported_checkers = ["jsonlint", "jsonval"]
|
||||
|
||||
function! s:load_checker(checker)
|
||||
exec "runtime syntax_checkers/json/" . a:checker . ".vim"
|
||||
endfunction
|
||||
|
||||
if exists("g:syntastic_json_checker")
|
||||
if index(s:supported_checkers, g:syntastic_json_checker) != -1 && executable(g:syntastic_json_checker)
|
||||
call s:load_checker(g:syntastic_json_checker)
|
||||
else
|
||||
echoerr "JSON syntax not supported or not installed."
|
||||
endif
|
||||
else
|
||||
for checker in s:supported_checkers
|
||||
if executable(checker)
|
||||
call s:load_checker(checker)
|
||||
break
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
@@ -1,16 +0,0 @@
|
||||
"============================================================================
|
||||
"File: jsonlint.vim
|
||||
"Description: JSON syntax checker - using jsonlint
|
||||
"Maintainer: Miller Medeiros <contact at millermedeiros dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"============================================================================
|
||||
|
||||
function! SyntaxCheckers_json_GetLocList()
|
||||
let makeprg = 'jsonlint ' . shellescape(expand("%")) . ' --compact'
|
||||
let errorformat = '%ELine %l:%c,%Z\\s%#Reason: %m,%C%.%#,%f: line %l\, col %c\, %m,%-G%.%#'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr('')} })
|
||||
endfunction
|
||||
@@ -1,17 +0,0 @@
|
||||
"============================================================================
|
||||
"File: jsonval.vim
|
||||
"Description: JSON syntax checker - using jsonval
|
||||
"Maintainer: Miller Medeiros <contact at millermedeiros dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"============================================================================
|
||||
|
||||
function! SyntaxCheckers_json_GetLocList()
|
||||
" based on https://gist.github.com/1196345
|
||||
let makeprg = 'jsonval '. shellescape(expand('%'))
|
||||
let errorformat = '%E%f:\ %m\ at\ line\ %l,%-G%.%#'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr('')} })
|
||||
endfunction
|
||||
@@ -1,38 +0,0 @@
|
||||
"============================================================================
|
||||
"File: less.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Julien Blanchard <julien at sideburns dot eu>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_less_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_less_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have the lessc binary installed
|
||||
if !executable("lessc")
|
||||
finish
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_less_options")
|
||||
let g:syntastic_less_options = "--no-color"
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_less_GetLocList()
|
||||
let makeprg = 'lessc '. g:syntastic_less_options .' '. shellescape(expand('%')) . ' /dev/null'
|
||||
|
||||
"lessc >= 1.2
|
||||
let errorformat = 'ParseError: Syntax Error on line %[0-9]%# in %f:%l:%c'
|
||||
"lessc < 1.2
|
||||
let errorformat .= ', Syntax %trror on line %l in %f,Syntax %trror on line %l,! Syntax %trror: on line %l: %m,%-G%.%#'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': {'bufnr': bufnr(""), 'text': "Syntax error"} })
|
||||
endfunction
|
||||
|
||||
@@ -1,58 +0,0 @@
|
||||
"============================================================================
|
||||
"File: lua.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('loaded_lua_syntax_checker')
|
||||
finish
|
||||
endif
|
||||
let loaded_lua_syntax_checker = 1
|
||||
|
||||
" check if the lua compiler is installed
|
||||
if !executable('luac')
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_lua_Term(pos)
|
||||
let near = matchstr(a:pos['text'], "near '[^']\\+'")
|
||||
let result = ''
|
||||
if len(near) > 0
|
||||
let near = split(near, "'")[1]
|
||||
if near == '<eof>'
|
||||
let p = getpos('$')
|
||||
let a:pos['lnum'] = p[1]
|
||||
let a:pos['col'] = p[2]
|
||||
let result = '\%'.p[2].'c'
|
||||
else
|
||||
let result = '\V'.near
|
||||
endif
|
||||
let open = matchstr(a:pos['text'], "(to close '[^']\\+' at line [0-9]\\+)")
|
||||
if len(open) > 0
|
||||
let oline = split(open, "'")[1:2]
|
||||
let line = 0+strpart(oline[1], 9)
|
||||
call matchadd('SpellCap', '\%'.line.'l\V'.oline[0])
|
||||
endif
|
||||
endif
|
||||
return result
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_lua_GetLocList()
|
||||
let makeprg = 'luac -p ' . shellescape(expand('%'))
|
||||
let errorformat = 'luac: %#%f:%l: %m'
|
||||
|
||||
let loclist = SyntasticMake({ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': { 'bufnr': bufnr(''), 'type': 'E' } })
|
||||
|
||||
call SyntasticHighlightErrors(loclist, function("SyntaxCheckers_lua_Term"))
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
@@ -1,28 +0,0 @@
|
||||
"============================================================================
|
||||
"File: matlab.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Jason Graham <jason at the-graham dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists("loaded_matlab_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_matlab_syntax_checker = 1
|
||||
|
||||
"bail if the user doesn't have mlint installed
|
||||
if !executable("mlint")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_matlab_GetLocList()
|
||||
let makeprg = 'mlint -id $* '.shellescape(expand('%'))
|
||||
let errorformat = 'L %l (C %c): %*[a-zA-Z0-9]: %m,L %l (C %c-%*[0-9]): %*[a-zA-Z0-9]: %m'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr("")} })
|
||||
endfunction
|
||||
|
||||
@@ -1,89 +0,0 @@
|
||||
"============================================================================
|
||||
"File: ocaml.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Török Edwin <edwintorok at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
"
|
||||
" By default the camlp4o preprocessor is used to check the syntax of .ml, and .mli files,
|
||||
" ocamllex is used to check .mll files and menhir is used to check .mly files.
|
||||
" The output is all redirected to /dev/null, nothing is written to the disk.
|
||||
"
|
||||
" If your source code needs camlp4r then you can define this in your .vimrc:
|
||||
"
|
||||
" let g:syntastic_ocaml_camlp4r = 1
|
||||
"
|
||||
" If you used some syntax extensions, or you want to also typecheck the source
|
||||
" code, then you can define this:
|
||||
"
|
||||
" let g:syntastic_ocaml_use_ocamlbuild = 1
|
||||
"
|
||||
" This will run ocamlbuild <name>.inferred.mli, so it will write to your _build
|
||||
" directory (and possibly rebuild your myocamlbuild.ml plugin), only enable this
|
||||
" if you are ok with that.
|
||||
"
|
||||
" If you are using syntax extensions / external libraries and have a properly
|
||||
" set up _tags (and myocamlbuild.ml file) then it should just work
|
||||
" to enable this flag and get syntax / type checks through syntastic.
|
||||
"
|
||||
" For best results your current directory should be the project root
|
||||
" (same situation if you want useful output from :make).
|
||||
|
||||
if exists("loaded_ocaml_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_ocaml_syntax_checker = 1
|
||||
|
||||
if exists('g:syntastic_ocaml_camlp4r') &&
|
||||
\ g:syntastic_ocaml_camlp4r != 0
|
||||
let s:ocamlpp="camlp4r"
|
||||
else
|
||||
let s:ocamlpp="camlp4o"
|
||||
endif
|
||||
|
||||
"bail if the user doesnt have the preprocessor
|
||||
if !executable(s:ocamlpp)
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_ocaml_GetLocList()
|
||||
if exists('g:syntastic_ocaml_use_ocamlbuild') &&
|
||||
\ g:syntastic_ocaml_use_ocamlbuild != 0 &&
|
||||
\ executable("ocamlbuild") &&
|
||||
\ isdirectory('_build')
|
||||
let makeprg = "ocamlbuild -quiet -no-log -tag annot,". s:ocamlpp. " -no-links -no-hygiene -no-sanitize ".
|
||||
\ shellescape(expand('%:r')).".cmi"
|
||||
else
|
||||
let extension = expand('%:e')
|
||||
if match(extension, 'mly') >= 0
|
||||
" ocamlyacc output can't be redirected, so use menhir
|
||||
if !executable("menhir")
|
||||
return []
|
||||
endif
|
||||
let makeprg = "menhir --only-preprocess ".shellescape(expand('%')) . " >/dev/null"
|
||||
elseif match(extension,'mll') >= 0
|
||||
if !executable("ocamllex")
|
||||
return []
|
||||
endif
|
||||
let makeprg = "ocamllex -q -o /dev/null ".shellescape(expand('%'))
|
||||
else
|
||||
let makeprg = "camlp4o -o /dev/null ".shellescape(expand('%'))
|
||||
endif
|
||||
endif
|
||||
let errorformat = '%AFile "%f"\, line %l\, characters %c-%*\d:,'.
|
||||
\ '%AFile "%f"\, line %l\, characters %c-%*\d (end at line %*\d\, character %*\d):,'.
|
||||
\ '%AFile "%f"\, line %l\, character %c:,'.
|
||||
\ '%AFile "%f"\, line %l\, character %c:%m,'.
|
||||
\ '%-GPreprocessing error %.%#,'.
|
||||
\ '%-GCommand exited %.%#,'.
|
||||
\ '%C%tarning %n: %m,'.
|
||||
\ '%C%m,'.
|
||||
\ '%-G+%.%#'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,35 +0,0 @@
|
||||
"============================================================================
|
||||
"File: perl.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Anthony Carapetis <anthony.carapetis at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
" This checker requires efm_perl.pl, which is distributed with Vim version
|
||||
" seven and greater, as far as I know.
|
||||
|
||||
if exists("loaded_perl_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_perl_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have perl installed
|
||||
if !executable("perl")
|
||||
finish
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_perl_efm_program")
|
||||
let g:syntastic_perl_efm_program = 'perl '.$VIMRUNTIME.'/tools/efm_perl.pl -c'
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_perl_GetLocList()
|
||||
let makeprg = g:syntastic_perl_efm_program . ' ' . shellescape(expand('%'))
|
||||
let errorformat = '%f:%l:%m'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,57 +0,0 @@
|
||||
"============================================================================
|
||||
"File: php.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_php_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_php_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have php installed
|
||||
if !executable("php")
|
||||
finish
|
||||
endif
|
||||
|
||||
"Support passing configuration directives to phpcs
|
||||
if !exists("g:syntastic_phpcs_conf")
|
||||
let g:syntastic_phpcs_conf = ""
|
||||
endif
|
||||
|
||||
if !exists("g:syntastic_phpcs_disable")
|
||||
let g:syntastic_phpcs_disable = 0
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_php_Term(item)
|
||||
let unexpected = matchstr(a:item['text'], "unexpected '[^']\\+'")
|
||||
if len(unexpected) < 1 | return '' | end
|
||||
return '\V'.split(unexpected, "'")[1]
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_php_GetLocList()
|
||||
|
||||
let errors = []
|
||||
if !g:syntastic_phpcs_disable && executable("phpcs")
|
||||
let errors = s:GetPHPCSErrors()
|
||||
endif
|
||||
|
||||
let makeprg = "php -l ".shellescape(expand('%'))
|
||||
let errorformat='%-GNo syntax errors detected in%.%#,PHP Parse error: %#syntax %trror\, %m in %f on line %l,PHP Fatal %trror: %m in %f on line %l,%-GErrors parsing %.%#,%-G\s%#,Parse error: %#syntax %trror\, %m in %f on line %l,Fatal %trror: %m in %f on line %l'
|
||||
let errors = errors + SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
|
||||
call SyntasticHighlightErrors(errors, function('SyntaxCheckers_php_Term'))
|
||||
|
||||
return errors
|
||||
endfunction
|
||||
|
||||
function! s:GetPHPCSErrors()
|
||||
let makeprg = "phpcs " . g:syntastic_phpcs_conf . " --report=csv ".shellescape(expand('%'))
|
||||
let errorformat = '%-GFile\,Line\,Column\,Type\,Message\,Source\,Severity,"%f"\,%l\,%c\,%t%*[a-zA-Z]\,"%m"\,%*[a-zA-Z0-9_.-]\,%*[0-9]'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,38 +0,0 @@
|
||||
"============================================================================
|
||||
"File: puppet.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Eivind Uggedal <eivind at uggedal dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_puppet_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_puppet_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have puppet installed
|
||||
if !executable("puppet")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_puppet_GetLocList()
|
||||
let l:puppetVersion = system("puppet --version")
|
||||
let l:digits = split(l:puppetVersion, "\\.")
|
||||
"
|
||||
" If it is on the 2.7 series... use new executable
|
||||
if l:digits[0] == '2' && l:digits[1] == '7'
|
||||
let makeprg = 'puppet parser validate ' .
|
||||
\ shellescape(expand('%')) .
|
||||
\ ' --color=false --ignoreimport'
|
||||
else
|
||||
let makeprg = 'puppet --color=false --parseonly --ignoreimport '.shellescape(expand('%'))
|
||||
endif
|
||||
|
||||
let errorformat = 'err: Could not parse for environment %*[a-z]: %m at %f:%l'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,77 +0,0 @@
|
||||
"============================================================================
|
||||
"File: python.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"
|
||||
"Authors: Martin Grenfell <martin.grenfell@gmail.com>
|
||||
" kstep <me@kstep.me>
|
||||
" Parantapa Bhattacharya <parantapa@gmail.com>
|
||||
"
|
||||
"============================================================================
|
||||
"
|
||||
" For forcing the use of flake8, pyflakes, or pylint set
|
||||
"
|
||||
" let g:syntastic_python_checker = 'pyflakes'
|
||||
"
|
||||
" in your .vimrc. Default is flake8.
|
||||
|
||||
if exists("loaded_python_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_python_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have his favorite checker or flake8 or pyflakes installed
|
||||
if !exists('g:syntastic_python_checker') || !executable('g:syntastic_python_checker')
|
||||
if executable("flake8")
|
||||
let g:syntastic_python_checker = 'flake8'
|
||||
elseif executable("pyflakes")
|
||||
let g:syntastic_python_checker = 'pyflakes'
|
||||
elseif executable("pylint")
|
||||
let g:syntastic_python_checker = 'pylint'
|
||||
else
|
||||
finish
|
||||
endif
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_python_Term(i)
|
||||
if a:i['type'] ==# 'E'
|
||||
let a:i['text'] = "Syntax error"
|
||||
endif
|
||||
if match(a:i['text'], 'is assigned to but never used') > -1
|
||||
\ || match(a:i['text'], 'imported but unused') > -1
|
||||
\ || match(a:i['text'], 'undefined name') > -1
|
||||
\ || match(a:i['text'], 'redefinition of') > -1
|
||||
\ || match(a:i['text'], 'referenced before assignment') > -1
|
||||
\ || match(a:i['text'], 'duplicate argument') > -1
|
||||
\ || match(a:i['text'], 'after other statements') > -1
|
||||
\ || match(a:i['text'], 'shadowed by loop variable') > -1
|
||||
|
||||
let term = split(a:i['text'], "'", 1)[1]
|
||||
return '\V\<'.term.'\>'
|
||||
endif
|
||||
return ''
|
||||
endfunction
|
||||
|
||||
if g:syntastic_python_checker == 'pylint'
|
||||
function! SyntaxCheckers_python_GetLocList()
|
||||
let makeprg = 'pylint -f parseable -r n -i y ' .
|
||||
\ shellescape(expand('%')) .
|
||||
\ ' \| sed ''s_: \[[RC]_: \[W_''' .
|
||||
\ ' \| sed ''s_: \[[F]_:\ \[E_'''
|
||||
let errorformat = '%f:%l: [%t%n] %m,%-GNo config%m'
|
||||
let errors = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
|
||||
return errors
|
||||
endfunction
|
||||
else
|
||||
function! SyntaxCheckers_python_GetLocList()
|
||||
let makeprg = g:syntastic_python_checker.' '.shellescape(expand('%'))
|
||||
let errorformat =
|
||||
\ '%E%f:%l: could not compile,%-Z%p^,%W%f:%l:%c: %m,%W%f:%l: %m,%-G%.%#'
|
||||
|
||||
let errors = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
|
||||
call SyntasticHighlightErrors(errors, function('SyntaxCheckers_python_Term'))
|
||||
|
||||
return errors
|
||||
endfunction
|
||||
endif
|
||||
@@ -1,37 +0,0 @@
|
||||
"============================================================================
|
||||
"File: rst.vim
|
||||
"Description: Syntax checking plugin for docutil's reStructuredText files
|
||||
"Maintainer: James Rowe <jnrowe at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
" We use rst2pseudoxml.py, as it is ever so marginally faster than the other
|
||||
" rst2${x} tools in docutils.
|
||||
|
||||
if exists("loaded_rst_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_rst_syntax_checker = 1
|
||||
|
||||
"bail if the user doesn't have rst2pseudoxml.py installed
|
||||
if !executable("rst2pseudoxml.py")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_rst_GetLocList()
|
||||
let makeprg = 'rst2pseudoxml.py --report=1 --exit-status=1 ' .
|
||||
\ shellescape(expand('%')) . ' /dev/null'
|
||||
|
||||
let errorformat = '%f:%l:\ (%tNFO/1)\ %m,
|
||||
\%f:%l:\ (%tARNING/2)\ %m,
|
||||
\%f:%l:\ (%tRROR/3)\ %m,
|
||||
\%f:%l:\ (%tEVERE/4)\ %m,
|
||||
\%-G%.%#'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,32 +0,0 @@
|
||||
"============================================================================
|
||||
"File: ruby.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_ruby_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_ruby_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have ruby installed
|
||||
if !executable("ruby")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_ruby_GetLocList()
|
||||
" we cannot set RUBYOPT on windows like that
|
||||
if has('win32') || has('win64')
|
||||
let makeprg = 'ruby -W1 -T1 -c '.shellescape(expand('%'))
|
||||
else
|
||||
let makeprg = 'RUBYOPT= ruby -W1 -c '.shellescape(expand('%'))
|
||||
endif
|
||||
let errorformat = '%-GSyntax OK,%E%f:%l: syntax error\, %m,%Z%p^,%W%f:%l: warning: %m,%Z%p^,%W%f:%l: %m,%-C%.%#'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,35 +0,0 @@
|
||||
"============================================================================
|
||||
"File: sass.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_sass_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_sass_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have the sass binary installed
|
||||
if !executable("sass")
|
||||
finish
|
||||
endif
|
||||
|
||||
"use compass imports if available
|
||||
let s:imports = ""
|
||||
if executable("compass")
|
||||
let s:imports = "--compass"
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_sass_GetLocList()
|
||||
let makeprg='sass '.s:imports.' --check '.shellescape(expand('%'))
|
||||
let errorformat = '%ESyntax %trror:%m,%C on line %l of %f,%Z%.%#'
|
||||
let errorformat .= ',%Wwarning on line %l:,%Z%m,Syntax %trror on line %l: %m'
|
||||
let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
@@ -1,27 +0,0 @@
|
||||
|
||||
"============================================================================
|
||||
"File: scss.vim
|
||||
"Description: scss syntax checking plugin for syntastic
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_scss_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_scss_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have the sass binary installed
|
||||
if !executable("sass")
|
||||
finish
|
||||
endif
|
||||
|
||||
runtime syntax_checkers/sass.vim
|
||||
|
||||
function! SyntaxCheckers_scss_GetLocList()
|
||||
return SyntaxCheckers_sass_GetLocList()
|
||||
endfunction
|
||||
@@ -1,52 +0,0 @@
|
||||
"============================================================================
|
||||
"File: sh.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists('loaded_sh_syntax_checker')
|
||||
finish
|
||||
endif
|
||||
let loaded_sh_syntax_checker = 1
|
||||
|
||||
function! s:GetShell()
|
||||
if !exists('b:shell') || b:shell == ""
|
||||
let b:shell = ''
|
||||
let shebang = getbufline(bufnr('%'), 1)[0]
|
||||
if len(shebang) > 0
|
||||
if match(shebang, 'bash') >= 0
|
||||
let b:shell = 'bash'
|
||||
elseif match(shebang, 'zsh') >= 0
|
||||
let b:shell = 'zsh'
|
||||
elseif match(shebang, 'sh') >= 0
|
||||
let b:shell = 'sh'
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
return b:shell
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_sh_GetLocList()
|
||||
if len(s:GetShell()) == 0 || !executable(s:GetShell())
|
||||
return []
|
||||
endif
|
||||
let output = split(system(s:GetShell().' -n '.shellescape(expand('%'))), '\n')
|
||||
if v:shell_error != 0
|
||||
let result = []
|
||||
for err_line in output
|
||||
let line = substitute(err_line, '^[^:]*:\D\{-}\(\d\+\):.*', '\1', '')
|
||||
let msg = substitute(err_line, '^[^:]*:\D\{-}\d\+: \(.*\)', '\1', '')
|
||||
call add(result, {'lnum' : line,
|
||||
\ 'text' : msg,
|
||||
\ 'bufnr': bufnr(''),
|
||||
\ 'type': 'E' })
|
||||
endfor
|
||||
return result
|
||||
endif
|
||||
return []
|
||||
endfunction
|
||||
@@ -1,28 +0,0 @@
|
||||
"============================================================================
|
||||
"File: tcl.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Eric Thomas <eric.l.m.thomas at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists("loaded_tcl_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_tcl_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have tclsh installed
|
||||
if !executable("tclsh")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_tcl_GetLocList()
|
||||
let makeprg = 'tclsh '.shellescape(expand('%'))
|
||||
let errorformat = '%f:%l:%m'
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,26 +0,0 @@
|
||||
"============================================================================
|
||||
"File: tex.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_tex_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_tex_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have lacheck installed
|
||||
if !executable("lacheck")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_tex_GetLocList()
|
||||
let makeprg = 'lacheck '.shellescape(expand('%'))
|
||||
let errorformat = '%-G** %f:,%E"%f"\, line %l: %m'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
@@ -1,56 +0,0 @@
|
||||
"============================================================================
|
||||
"File: vala.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Konstantin Stepanov (me@kstep.me)
|
||||
"Notes: Add special comment line into your vala file starting with
|
||||
" "// modules: " and containing space delimited list of vala
|
||||
" modules, used by the file, so this script can build correct
|
||||
" --pkg arguments.
|
||||
" Valac compiler is not the fastest thing in the world, so you
|
||||
" may want to disable this plugin with
|
||||
" let g:syntastic_vala_check_disabled = 1 command in your .vimrc or
|
||||
" command line. Unlet this variable to set it to 0 to reenable
|
||||
" this checker.
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('loaded_vala_syntax_checker')
|
||||
finish
|
||||
endif
|
||||
let loaded_vala_syntax_checker = 1
|
||||
|
||||
if !executable('valac')
|
||||
finish
|
||||
endif
|
||||
|
||||
if exists('g:syntastic_vala_check_disabled') && g:syntastic_vala_check_disabled
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_vala_Term(pos)
|
||||
let strlength = strlen(matchstr(a:pos['text'], '\^\+$'))
|
||||
return '\%>'.(a:pos.col-1).'c.*\%<'.(a:pos.col+strlength+1).'c'
|
||||
endfunction
|
||||
|
||||
function! s:GetValaModules()
|
||||
let modules_line = search('^// modules: ', 'n')
|
||||
let modules_str = getline(modules_line)
|
||||
let modules = split(strpart(modules_str, 12), '\s\+')
|
||||
return modules
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_vala_GetLocList()
|
||||
let vala_pkg_args = join(map(s:GetValaModules(), '"--pkg ".v:val'), ' ')
|
||||
let makeprg = 'valac -C ' . vala_pkg_args . ' ' .shellescape(expand('%'))
|
||||
let errorformat = '%A%f:%l.%c-%\d%\+.%\d%\+: %t%[a-z]%\+: %m,%C%m,%Z%m'
|
||||
|
||||
let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
call SyntasticHighlightErrors(loclist, function("SyntaxCheckers_vala_Term"), 1)
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
@@ -1,46 +0,0 @@
|
||||
"============================================================================
|
||||
"File: xhtml.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_xhtml_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_xhtml_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have tidy or grep installed
|
||||
if !executable("tidy")
|
||||
finish
|
||||
endif
|
||||
|
||||
" TODO: join this with html.vim DRY's sake?
|
||||
function! s:TidyEncOptByFenc()
|
||||
let tidy_opts = {
|
||||
\'utf-8' : '-utf8',
|
||||
\'ascii' : '-ascii',
|
||||
\'latin1' : '-latin1',
|
||||
\'iso-2022-jp' : '-iso-2022',
|
||||
\'cp1252' : '-win1252',
|
||||
\'macroman' : '-mac',
|
||||
\'utf-16le' : '-utf16le',
|
||||
\'utf-16' : '-utf16',
|
||||
\'big5' : '-big5',
|
||||
\'sjis' : '-shiftjis',
|
||||
\'cp850' : '-ibm858',
|
||||
\}
|
||||
return get(tidy_opts, &fileencoding, '-utf8')
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_xhtml_GetLocList()
|
||||
|
||||
let encopt = s:TidyEncOptByFenc()
|
||||
let makeprg="tidy ".encopt." -xml -e ".shellescape(expand('%'))
|
||||
let errorformat='%Wline %l column %c - Warning: %m,%Eline %l column %c - Error: %m,%-G%.%#,%-G%.%#'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat, 'defaults': {'bufnr': bufnr("")} })
|
||||
endfunction
|
||||
@@ -1,42 +0,0 @@
|
||||
"============================================================================
|
||||
"File: xml.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Sebastian Kusnier <sebastian at kusnier dot net>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
" You can use a local installation of DTDs to significantly speed up validation
|
||||
" and allow you to validate XML data without network access, see xmlcatalog(1)
|
||||
" and http://www.xmlsoft.org/catalog.html for more information.
|
||||
|
||||
if exists("loaded_xml_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_xml_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have tidy or grep installed
|
||||
if !executable("xmllint")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_xml_GetLocList()
|
||||
|
||||
let makeprg="xmllint --xinclude --noout --postvalid " . shellescape(expand("%:p"))
|
||||
let errorformat='%E%f:%l:\ error\ :\ %m,
|
||||
\%-G%f:%l:\ validity\ error\ :\ Validation\ failed:\ no\ DTD\ found\ %m,
|
||||
\%W%f:%l:\ warning\ :\ %m,
|
||||
\%W%f:%l:\ validity\ warning\ :\ %m,
|
||||
\%E%f:%l:\ validity\ error\ :\ %m,
|
||||
\%E%f:%l:\ parser\ error\ :\ %m,
|
||||
\%E%f:%l:\ %m,
|
||||
\%-Z%p^,
|
||||
\%-G%.%#'
|
||||
let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
@@ -1,38 +0,0 @@
|
||||
"============================================================================
|
||||
"File: xslt.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Sebastian Kusnier <sebastian at kusnier dot net>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_xslt_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_xslt_syntax_checker = 1
|
||||
|
||||
"bail if the user doesnt have tidy or grep installed
|
||||
if !executable("xmllint")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_xslt_GetLocList()
|
||||
|
||||
let makeprg="xmllint --xinclude --noout --postvalid " . shellescape(expand("%:p"))
|
||||
let errorformat='%E%f:%l:\ error\ :\ %m,
|
||||
\%-G%f:%l:\ validity\ error\ :\ Validation\ failed:\ no\ DTD\ found\ %m,
|
||||
\%W%f:%l:\ warning\ :\ %m,
|
||||
\%W%f:%l:\ validity\ warning\ :\ %m,
|
||||
\%E%f:%l:\ validity\ error\ :\ %m,
|
||||
\%E%f:%l:\ parser\ error\ :\ %m,
|
||||
\%E%f:%l:\ namespace\ error\ :\ %m,
|
||||
\%E%f:%l:\ %m,
|
||||
\%-Z%p^,
|
||||
\%-G%.%#'
|
||||
let loclist = SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
@@ -1,30 +0,0 @@
|
||||
"============================================================================
|
||||
"File: yaml.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"
|
||||
"Installation: $ npm install -g js-yaml.bin
|
||||
"
|
||||
"============================================================================
|
||||
if exists("loaded_yaml_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_yaml_syntax_checker = 1
|
||||
|
||||
if !executable("js-yaml")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_yaml_GetLocList()
|
||||
let makeprg='js-yaml --compact ' . shellescape(expand('%'))
|
||||
let errorformat='Error on line %l\, col %c:%m,%-G%.%#'
|
||||
return SyntasticMake({ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': {'bufnr': bufnr("")} })
|
||||
endfunction
|
||||
@@ -1,36 +0,0 @@
|
||||
"============================================================================
|
||||
"File: zpt.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: claytron <robots at claytron dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
" In order for this plugin to be useful, you will need to set up the
|
||||
" zpt filetype in your vimrc
|
||||
"
|
||||
" " set up zope page templates as the zpt filetype
|
||||
" au BufNewFile,BufRead *.pt,*.cpt,*.zpt set filetype=zpt syntax=xml
|
||||
"
|
||||
" Then install the zptlint program, found on pypi:
|
||||
" http://pypi.python.org/pypi/zptlint
|
||||
|
||||
if exists("loaded_zpt_syntax_checker")
|
||||
finish
|
||||
endif
|
||||
let loaded_zpt_syntax_checker = 1
|
||||
|
||||
" Bail if the user doesn't have zptlint installed
|
||||
if !executable("zptlint")
|
||||
finish
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_zpt_GetLocList()
|
||||
let makeprg="zptlint ".shellescape(expand('%'))
|
||||
let errorformat='%-P*** Error in: %f,%Z%*\s\, at line %l\, column %c,%E%*\s%m,%-Q'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
4
vim/bundle/vim-coffee-script/.gitignore
vendored
4
vim/bundle/vim-coffee-script/.gitignore
vendored
@@ -1,4 +0,0 @@
|
||||
.*.sw[a-z]
|
||||
.*.un~
|
||||
doc/tags
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
Version 2, December 2004
|
||||
|
||||
Copyright (C) 2010 to 2011 Mick Koch <kchmck@gmail.com>
|
||||
|
||||
Everyone is permitted to copy and distribute verbatim or modified
|
||||
copies of this license document, and changing it is allowed as long
|
||||
as the name is changed.
|
||||
|
||||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. You just DO WHAT THE FUCK YOU WANT TO.
|
||||
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
REF = HEAD
|
||||
VERSION = $(shell git describe --always $(REF))
|
||||
|
||||
ARCHIVE = vim-coffee-script-$(VERSION).zip
|
||||
ARCHIVE_DIRS = after compiler ftdetect ftplugin indent syntax
|
||||
|
||||
# Don't do anything by default.
|
||||
all:
|
||||
|
||||
# Make vim.org zipball.
|
||||
archive:
|
||||
git archive $(REF) -o $(ARCHIVE) -- $(ARCHIVE_DIRS)
|
||||
|
||||
# Remove zipball.
|
||||
clean:
|
||||
-rm -f $(ARCHIVE)
|
||||
|
||||
# Build the list of syntaxes for @coffeeAll.
|
||||
coffeeAll:
|
||||
@grep -E 'syn (match|region)' syntax/coffee.vim |\
|
||||
grep -v 'contained' |\
|
||||
awk '{print $$3}' |\
|
||||
uniq
|
||||
|
||||
.PHONY: all archive clean hash coffeeAll
|
||||
@@ -1,14 +0,0 @@
|
||||
### Version 001 (October 18, 2011)
|
||||
|
||||
Removed deprecated `coffee_folding` option, added `coffee_compile_vert` option,
|
||||
split out compiler, fixed indentation and syntax bugs, and added Haml support
|
||||
and omnicompletion.
|
||||
|
||||
- The coffee compiler is now a proper vim compiler that can be loaded with
|
||||
`:compiler coffee`.
|
||||
- The `coffee_compile_vert` option can now be set to split the CoffeeCompile
|
||||
buffer vertically by default.
|
||||
- CoffeeScript is now highlighted inside the `:coffeescript` filter in Haml.
|
||||
- Omnicompletion (`:help compl-omni`) now uses JavaScript's dictionary to
|
||||
complete words.
|
||||
- We now have a fancy version number.
|
||||
@@ -1,241 +0,0 @@
|
||||
This project adds [CoffeeScript] support to the vim editor. It handles syntax,
|
||||
indenting, and compiling. Also included is an [eco] syntax and support for
|
||||
CoffeeScript in Haml and HTML.
|
||||
|
||||
|
||||
|
||||
[CoffeeScript]: http://jashkenas.github.com/coffee-script/
|
||||
[eco]: https://github.com/sstephenson/eco
|
||||
|
||||
### Install from a Zipball
|
||||
|
||||
This is the quickest way to get things running.
|
||||
|
||||
1. Download the latest zipball from [vim.org][zipball-vim] or
|
||||
[github][zipball-github]. The latest version on github is under Download
|
||||
Packages (don't use the Download buttons.)
|
||||
|
||||
2. Extract the archive into `~/.vim/`:
|
||||
|
||||
unzip -od ~/.vim vim-coffee-script-HASH.zip
|
||||
|
||||
These steps are also used to update the plugin.
|
||||
|
||||
[zipball-vim]: http://www.vim.org/scripts/script.php?script_id=3590
|
||||
[zipball-github]: https://github.com/kchmck/vim-coffee-script/downloads
|
||||
|
||||
### Install with Pathogen
|
||||
|
||||
Since this plugin has rolling versions based on git commits, using pathogen and
|
||||
git is the preferred way to install. The plugin ends up contained in its own
|
||||
directory and updates are just a `git pull` away.
|
||||
|
||||
1. Install tpope's [pathogen] into `~/.vim/autoload/` and add this line to your
|
||||
`vimrc`:
|
||||
|
||||
call pathogen#infect()
|
||||
|
||||
To get the all the features of this plugin, make sure you also have a
|
||||
`filetype plugin indent on` line in there.
|
||||
|
||||
[pathogen]: http://www.vim.org/scripts/script.php?script_id=2332
|
||||
|
||||
2. Create and change into `~/.vim/bundle/`:
|
||||
|
||||
$ mkdir ~/.vim/bundle
|
||||
$ cd ~/.vim/bundle
|
||||
|
||||
3. Make a clone of the `vim-coffee-script` repository:
|
||||
|
||||
$ git clone https://github.com/kchmck/vim-coffee-script.git
|
||||
|
||||
#### Updating
|
||||
|
||||
1. Change into `~/.vim/bundle/vim-coffee-script/`:
|
||||
|
||||
$ cd ~/.vim/bundle/vim-coffee-script
|
||||
|
||||
2. Pull in the latest changes:
|
||||
|
||||
$ git pull
|
||||
|
||||
### CoffeeMake: Compile the Current File
|
||||
|
||||
The `CoffeeMake` command compiles the current file and parses any errors:
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
The full signature of the command is:
|
||||
|
||||
:[silent] CoffeeMake[!] [COFFEE-OPTIONS]...
|
||||
|
||||
By default, `CoffeeMake` shows all compiler output and jumps to the first line
|
||||
reported as an error by `coffee`:
|
||||
|
||||
:CoffeeMake
|
||||
|
||||
Compiler output can be hidden with `silent`:
|
||||
|
||||
:silent CoffeeMake
|
||||
|
||||
Line-jumping can be turned off by adding a bang:
|
||||
|
||||
:CoffeeMake!
|
||||
|
||||
Options given to `CoffeeMake` are passed along to `coffee`:
|
||||
|
||||
:CoffeeMake --bare
|
||||
|
||||
`CoffeeMake` can be manually loaded for a file with:
|
||||
|
||||
:compiler coffee
|
||||
|
||||
#### Recompile on write
|
||||
|
||||
To recompile a file when it's written, add an `autocmd` like this to your
|
||||
`vimrc`:
|
||||
|
||||
au BufWritePost *.coffee silent CoffeeMake!
|
||||
|
||||
All of the customizations above can be used, too. This one compiles silently
|
||||
and with the `-b` option, but shows any errors:
|
||||
|
||||
au BufWritePost *.coffee silent CoffeeMake! -b | cwindow | redraw!
|
||||
|
||||
The `redraw!` command is needed to fix a redrawing quirk in terminal vim, but
|
||||
can removed for gVim.
|
||||
|
||||
#### Default compiler options
|
||||
|
||||
The `CoffeeMake` command passes any options in the `coffee_make_options`
|
||||
variable along to the compiler. You can use this to set default options:
|
||||
|
||||
let coffee_make_options = "--bare"
|
||||
|
||||
### CoffeeCompile: Compile Snippets of CoffeeScript
|
||||
|
||||
The `CoffeeCompile` command shows how the current file or a snippet of
|
||||
CoffeeScript is compiled to JavaScript. The full signature of the command is:
|
||||
|
||||
:[RANGE] CoffeeCompile [watch|unwatch] [vert[ical]] [WINDOW-SIZE]
|
||||
|
||||
Calling `CoffeeCompile` without a range compiles the whole file:
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Calling `CoffeeCompile` with a range, like in visual mode, compiles the selected
|
||||
snippet of CoffeeScript:
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
This scratch buffer can be quickly closed by hitting the `q` key.
|
||||
|
||||
Using `vert` splits the CoffeeCompile buffer vertically instead of horizontally:
|
||||
|
||||
:CoffeeCompile vert
|
||||
|
||||
Set the `coffee_compile_vert` variable to split the buffer vertically by
|
||||
default:
|
||||
|
||||
let coffee_compile_vert = 1
|
||||
|
||||
The initial size of the CoffeeCompile buffer can be given as a number:
|
||||
|
||||
:CoffeeCompile 4
|
||||
|
||||
#### Watch (live preview) mode
|
||||
|
||||
Watch mode is like the Try CoffeeScript preview box on the CoffeeScript
|
||||
homepage:
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Writing some code and then exiting insert mode automatically updates the
|
||||
compiled JavaScript buffer.
|
||||
|
||||
Use `watch` to start watching a buffer (`vert` is also recommended):
|
||||
|
||||
:CoffeeCompile watch vert
|
||||
|
||||
After making some changes in insert mode, hit escape and the CoffeeScript will
|
||||
be recompiled. Changes made outside of insert mode don't trigger this recompile,
|
||||
but calling `CoffeeCompile` will compile these changes without any bad effects.
|
||||
|
||||
To get synchronized scrolling of a CoffeeScript and CoffeeCompile buffer, set
|
||||
`scrollbind` on each:
|
||||
|
||||
:setl scrollbind
|
||||
|
||||
Use `unwatch` to stop watching a buffer:
|
||||
|
||||
:CoffeeCompile unwatch
|
||||
|
||||
### CoffeeRun: Run some CoffeeScript
|
||||
|
||||
The `CoffeeRun` command compiles the current file or selected snippet and runs
|
||||
the resulting JavaScript. Output is shown at the bottom of the screen:
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
### Configure Syntax Highlighting
|
||||
|
||||
Add these lines to your `vimrc` to disable the relevant syntax group.
|
||||
|
||||
#### Disable trailing whitespace error
|
||||
|
||||
Trailing whitespace is highlighted as an error by default. This can be disabled
|
||||
with:
|
||||
|
||||
hi link coffeeSpaceError NONE
|
||||
|
||||
#### Disable trailing semicolon error
|
||||
|
||||
Trailing semicolons are also considered an error (for help transitioning from
|
||||
JavaScript.) This can be disabled with:
|
||||
|
||||
hi link coffeeSemicolonError NONE
|
||||
|
||||
#### Disable reserved words error
|
||||
|
||||
Reserved words like `function` and `var` are highlighted as an error where
|
||||
they're not allowed in CoffeeScript. This can be disabled with:
|
||||
|
||||
hi link coffeeReservedError NONE
|
||||
|
||||
### Tune Vim for CoffeeScript
|
||||
|
||||
Changing these core settings can make vim more CoffeeScript friendly.
|
||||
|
||||
#### Fold by indentation
|
||||
|
||||
Folding by indentation works well for CoffeeScript functions and classes:
|
||||
|
||||
|
||||
|
||||
To fold by indentation in CoffeeScript files, add this line to your `vimrc`:
|
||||
|
||||
au BufNewFile,BufReadPost *.coffee setl foldmethod=indent nofoldenable
|
||||
|
||||
With this, folding is disabled by default but can be quickly toggled per-file
|
||||
by hitting `zi`. To enable folding by default, remove `nofoldenable`:
|
||||
|
||||
au BufNewFile,BufReadPost *.coffee setl foldmethod=indent
|
||||
|
||||
#### Two-space indentation
|
||||
|
||||
To get standard two-space indentation in CoffeeScript files, add this line to
|
||||
your `vimrc`:
|
||||
|
||||
au BufNewFile,BufReadPost *.coffee setl shiftwidth=2 expandtab
|
||||
@@ -1,44 +0,0 @@
|
||||
Thanks to all bug reporters, and special thanks to those who have contributed
|
||||
code:
|
||||
|
||||
Brian Egan (brianegan):
|
||||
Initial compiling support
|
||||
|
||||
Ches Martin (ches):
|
||||
Initial vim docs
|
||||
|
||||
Chris Hoffman (cehoffman):
|
||||
Add new keywoards from, to, and do
|
||||
Highlight the - in negative integers
|
||||
Add here regex highlighting, increase fold level for here docs
|
||||
|
||||
David Wilhelm (bigfish):
|
||||
CoffeeRun command
|
||||
|
||||
Jay Adkisson (jayferd):
|
||||
Support for eco templates
|
||||
|
||||
Karl Guertin (grayrest)
|
||||
Cakefiles are coffeescript
|
||||
|
||||
Maciej Konieczny (narfdotpl):
|
||||
Fix funny typo
|
||||
|
||||
Matt Sacks (mattsa):
|
||||
Javascript omni-completion
|
||||
coffee_compile_vert option
|
||||
|
||||
Nick Stenning (nickstenning):
|
||||
Fold by indentation for coffeescript
|
||||
|
||||
Simon Lipp (sloonz):
|
||||
Trailing spaces are not error on lines containing only spaces
|
||||
|
||||
Stéphan Kochen (stephank):
|
||||
Initial HTML CoffeeScript highlighting
|
||||
|
||||
Sven Felix Oberquelle (Svelix):
|
||||
Haml CoffeeScript highlighting
|
||||
|
||||
Wei Dai (clvv):
|
||||
Fix the use of Vim built-in make command.
|
||||
@@ -1 +0,0 @@
|
||||
- Don't highlight bad operator combinations
|
||||
@@ -1,9 +0,0 @@
|
||||
" Language: CoffeeScript
|
||||
" Maintainer: Sven Felix Oberquelle <Svelix.Github@gmail.com>
|
||||
" URL: http://github.com/kchmck/vim-coffee-script
|
||||
" License: WTFPL
|
||||
|
||||
" Inherit coffee from html so coffeeComment isn't redefined and given higher
|
||||
" priority than hamlInterpolation.
|
||||
syn cluster hamlCoffeescript contains=@htmlCoffeeScript
|
||||
syn region hamlCoffeescriptFilter matchgroup=hamlFilter start="^\z(\s*\):coffeescript\s*$" end="^\%(\z1 \| *$\)\@!" contains=@hamlCoffeeScript,hamlInterpolation keepend
|
||||
@@ -1,10 +0,0 @@
|
||||
" Language: CoffeeScript
|
||||
" Maintainer: Mick Koch <kchmck@gmail.com>
|
||||
" URL: http://github.com/kchmck/vim-coffee-script
|
||||
" License: WTFPL
|
||||
|
||||
" Syntax highlighting for text/coffeescript script tags
|
||||
syn include @htmlCoffeeScript syntax/coffee.vim
|
||||
syn region coffeeScript start=+<script [^>]*type *=[^>]*text/coffeescript[^>]*>+
|
||||
\ end=+</script>+me=s-1 keepend
|
||||
\ contains=@htmlCoffeeScript,htmlScriptTag,@htmlPreproc
|
||||
@@ -1,68 +0,0 @@
|
||||
" Language: CoffeeScript
|
||||
" Maintainer: Mick Koch <kchmck@gmail.com>
|
||||
" URL: http://github.com/kchmck/vim-coffee-script
|
||||
" License: WTFPL
|
||||
|
||||
if exists('current_compiler')
|
||||
finish
|
||||
endif
|
||||
|
||||
let current_compiler = 'coffee'
|
||||
" Pattern to check if coffee is the compiler
|
||||
let s:pat = '^' . current_compiler
|
||||
|
||||
" Extra options passed to CoffeeMake
|
||||
if !exists("coffee_make_options")
|
||||
let coffee_make_options = ""
|
||||
endif
|
||||
|
||||
" Get a `makeprg` for the current filename. This is needed to support filenames
|
||||
" with spaces and quotes, but also not break generic `make`.
|
||||
function! s:GetMakePrg()
|
||||
return 'coffee -c ' . g:coffee_make_options . ' $* ' . fnameescape(expand('%'))
|
||||
endfunction
|
||||
|
||||
" Set `makeprg` and return 1 if coffee is still the compiler, else return 0.
|
||||
function! s:SetMakePrg()
|
||||
if &l:makeprg =~ s:pat
|
||||
let &l:makeprg = s:GetMakePrg()
|
||||
elseif &g:makeprg =~ s:pat
|
||||
let &g:makeprg = s:GetMakePrg()
|
||||
else
|
||||
return 0
|
||||
endif
|
||||
|
||||
return 1
|
||||
endfunction
|
||||
|
||||
" Set a dummy compiler so we can check whether to set locally or globally.
|
||||
CompilerSet makeprg=coffee
|
||||
call s:SetMakePrg()
|
||||
|
||||
CompilerSet errorformat=Error:\ In\ %f\\,\ %m\ on\ line\ %l,
|
||||
\Error:\ In\ %f\\,\ Parse\ error\ on\ line\ %l:\ %m,
|
||||
\SyntaxError:\ In\ %f\\,\ %m,
|
||||
\%-G%.%#
|
||||
|
||||
" Compile the current file.
|
||||
command! -bang -bar -nargs=* CoffeeMake make<bang> <args>
|
||||
|
||||
" Set `makeprg` on rename since we embed the filename in the setting.
|
||||
augroup CoffeeUpdateMakePrg
|
||||
autocmd!
|
||||
|
||||
" Update `makeprg` if coffee is still the compiler, else stop running this
|
||||
" function.
|
||||
function! s:UpdateMakePrg()
|
||||
if !s:SetMakePrg()
|
||||
autocmd! CoffeeUpdateMakePrg
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" Set autocmd locally if compiler was set locally.
|
||||
if &l:makeprg =~ s:pat
|
||||
autocmd BufFilePost,BufWritePost <buffer> call s:UpdateMakePrg()
|
||||
else
|
||||
autocmd BufFilePost,BufWritePost call s:UpdateMakePrg()
|
||||
endif
|
||||
augroup END
|
||||
@@ -1,116 +0,0 @@
|
||||
*coffee-script.txt* For Vim version 7.3
|
||||
|
||||
=============================================================================
|
||||
Author: Mick Koch <kchmck@gmail.com> *coffee-script-author*
|
||||
License: WTFPL (see |coffee-script-license|)
|
||||
=============================================================================
|
||||
|
||||
CONTENTS *coffee-script-contents*
|
||||
|
||||
|coffee-script-introduction| Introduction and Feature Summary
|
||||
|coffee-script-commands| Commands
|
||||
|coffee-script-settings| Settings
|
||||
|
||||
{Vi does not have any of this}
|
||||
|
||||
=============================================================================
|
||||
|
||||
INTRODUCTION *coffee-script*
|
||||
*coffee-script-introduction*
|
||||
|
||||
This plugin adds support for CoffeeScript syntax, indenting, and compiling.
|
||||
Also included is an eco syntax and support for CoffeeScript in Haml and HTML.
|
||||
|
||||
COMMANDS *coffee-script-commands*
|
||||
|
||||
*:CoffeeMake*
|
||||
:CoffeeMake[!] {opts} Wrapper around |:make| that also passes options in
|
||||
|g:coffee_make_options| to the compiler. Use |:silent|
|
||||
to hide compiler output. See |:make| for more
|
||||
information about the bang and other helpful commands.
|
||||
|
||||
*:CoffeeCompile*
|
||||
:[range]CoffeeCompile [vertical] [{win-size}]
|
||||
Shows how the current file or [range] is compiled
|
||||
to JavaScript. [vertical] (or vert) splits the
|
||||
compile buffer vertically instead of horizontally, and
|
||||
{win-size} sets the initial size of the buffer. It can
|
||||
be closed quickly with the "q" key.
|
||||
|
||||
:CoffeeCompile {watch} [vertical] [{win-size}]
|
||||
The watch mode of :CoffeeCompile emulates the "Try
|
||||
CoffeeScript" live preview on the CoffeeScript web
|
||||
site. After making changes to the source file,
|
||||
exiting insert mode will cause the preview buffer to
|
||||
update automatically. {watch} should be given as
|
||||
"watch" or "unwatch," where the latter will stop the
|
||||
automatic updating. [vertical] is recommended, and
|
||||
'scrollbind' is useful.
|
||||
|
||||
*:CoffeeRun*
|
||||
:[range]CoffeeRun Compiles the file or [range] and runs the resulting
|
||||
JavaScript, displaying the output.
|
||||
|
||||
SETTINGS *coffee-script-settings*
|
||||
|
||||
You can configure plugin behavior using global variables and syntax commands
|
||||
in your |vimrc|.
|
||||
|
||||
Global Settings~
|
||||
|
||||
*g:coffee_make_options*
|
||||
Set default options |CoffeeMake| should pass to the compiler.
|
||||
>
|
||||
let coffee_make_options = '--bare'
|
||||
<
|
||||
*g:coffee_compile_vert*
|
||||
Split the CoffeeCompile buffer vertically by default.
|
||||
>
|
||||
let coffee_compile_vert = 1
|
||||
|
||||
Syntax Highlighting~
|
||||
*ft-coffee-script-syntax*
|
||||
Trailing whitespace is highlighted as an error by default. This can be
|
||||
disabled with:
|
||||
>
|
||||
hi link coffeeSpaceError NONE
|
||||
|
||||
Trailing semicolons are also considered an error (for help transitioning from
|
||||
JavaScript.) This can be disabled with:
|
||||
>
|
||||
hi link coffeeSemicolonError NONE
|
||||
|
||||
Reserved words like {function} and {var} are highlighted where they're not
|
||||
allowed in CoffeeScript. This can be disabled with:
|
||||
>
|
||||
hi link coffeeReservedError NONE
|
||||
|
||||
COMPILER *compiler-coffee-script*
|
||||
|
||||
A CoffeeScript compiler is provided as a wrapper around {coffee} and can be
|
||||
loaded with;
|
||||
>
|
||||
compiler coffee
|
||||
|
||||
This is done automatically when a CoffeeScript file is opened if no other
|
||||
compiler is loaded.
|
||||
|
||||
=============================================================================
|
||||
|
||||
LICENSE *coffee-script-license*
|
||||
|
||||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
Version 2, December 2004
|
||||
|
||||
Copyright (C) 2010 to 2011 Mick Koch <kchmck@gmail.com>
|
||||
|
||||
Everyone is permitted to copy and distribute verbatim or modified
|
||||
copies of this license document, and changing it is allowed as long
|
||||
as the name is changed.
|
||||
|
||||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. You just DO WHAT THE FUCK YOU WANT TO.
|
||||
|
||||
vim:tw=78:ts=8:ft=help:norl:
|
||||
@@ -1,8 +0,0 @@
|
||||
" Language: CoffeeScript
|
||||
" Maintainer: Mick Koch <kchmck@gmail.com>
|
||||
" URL: http://github.com/kchmck/vim-coffee-script
|
||||
" License: WTFPL
|
||||
|
||||
autocmd BufNewFile,BufRead *.coffee set filetype=coffee
|
||||
autocmd BufNewFile,BufRead *Cakefile set filetype=coffee
|
||||
autocmd BufNewFile,BufRead *.coffeekup set filetype=coffee
|
||||
@@ -1 +0,0 @@
|
||||
autocmd BufNewFile,BufRead *.eco set filetype=eco
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user