diff --git a/bundle/syntastic/CONTRIBUTING.md b/bundle/syntastic/CONTRIBUTING.md index 764ffffc..2eac8325 100644 --- a/bundle/syntastic/CONTRIBUTING.md +++ b/bundle/syntastic/CONTRIBUTING.md @@ -29,7 +29,7 @@ Following the coding conventions/styles used in the syntastic core: * Use 4 space indents. * Don't use abbreviated keywords - e.g. use `endfunction`, not `endfun` (there's always room for more fun!). * Don't use `l:` prefixes for variables unless actually required (i.e. almost never). -* Code for maintainability. We would rather a function be a couple of lines longer and have (for example) some [explaining variables](http://www.refactoring.com/catalog/introduceExplainingVariable.html) to aid readability. +* Code for maintainability. We would rather a function be a couple of lines longer and have (for example) some [explaining variables](http://www.refactoring.com/catalog/extractVariable.html) to aid readability. # Syntax checker style notes diff --git a/bundle/syntastic/README.markdown b/bundle/syntastic/README.markdown index c88cdfd9..653bd7c6 100644 --- a/bundle/syntastic/README.markdown +++ b/bundle/syntastic/README.markdown @@ -17,31 +17,39 @@ \_____________________________________________/ - - -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 Ada, -AppleScript, AsciiDoc, Bourne shell, C, C++, C#, Chef, CoffeeScript, Coco, -Coq, CSS, Cucumber, CUDA, D, Dart, DocBook, Dust, Elixir, Erlang, eRuby, -Fortran, Gentoo metadata, Go, Haml, Haskell, Haxe, Handlebars, HSS, HTML, -Java, JavaScript, JSON, LESS, LISP, LLVM intermediate language, Lua, MATLAB, -NASM, Objective-C, Objective-C++, OCaml, Perl, Perl POD, PHP, Puppet, Python, -reStructuredText, Ruby, Rust, SASS/SCSS, Scala, Slim, Tcl, TeX, Twig, -TypeScript, Vala, Verilog, VHDL, xHtml, XML, XSLT, YAML, z80, Zope page -templates, zsh. - -## Screenshot +- - - +1\. [Introduction](#introduction) +2\. [Installation](#installation) +3\. [FAQ](#faq) +4\. [Other resources](#otherresources) +- - - + + + +## 1\. Introduction + +Syntastic is a syntax checking plugin for Vim 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 ActionScript, +Ada, AppleScript, AsciiDoc, ASM, BEMHTML, Bourne shell, C, C++, C#, Chef, +CoffeeScript, Coco, Coq, CSS, Cucumber, CUDA, D, Dart, DocBook, Dust, Elixir, +Erlang, eRuby, Fortran, Gentoo metadata, GLSL, Go, Haml, Haskell, Haxe, +Handlebars, HSS, HTML, Java, JavaScript, JSON, JSX, LESS, Lex, Limbo, LISP, +LLVM intermediate language, Lua, MATLAB, NASM, Objective-C, Objective-C++, +OCaml, Perl, Perl POD, PHP, gettext Portable Object, Puppet, Python, Racket, +reStructuredText, Ruby, Rust, SASS/SCSS, Scala, Slim, Tcl, TeX, Texinfo, Twig, +TypeScript, Vala, Verilog, VHDL, VimL, xHtml, XML, XSLT, YACC, YAML, z80, Zope +page templates, and zsh. 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. -![Screenshot 1](https://github.com/scrooloose/syntastic/raw/master/_assets/screenshot_1.png) +![Screenshot 1][0] 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. @@ -50,126 +58,195 @@ enabled. 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 - -Installing syntastic is easy but first you need to have the pathogen plugin installed. If you already -have pathogen working then skip Step 1 and go to Step 2. + -### Step 1: Install pathogen.vim +## 2\. Installation -First I'll show you how to install tpope's [pathogen.vim](https://github.com/tpope/vim-pathogen) so that -it's easy to install syntastic. Do this in your Terminal so that you get the pathogen.vim file -and the directories it needs: +Installing syntastic is easy but first you need to have the [pathogen][1] +plugin installed. If you already have [pathogen][1] working then skip +[Step 1](#step1) and go to [Step 2](#step2). - mkdir -p ~/.vim/autoload ~/.vim/bundle; \ - curl -so ~/.vim/autoload/pathogen.vim \ - https://raw.github.com/tpope/vim-pathogen/master/autoload/pathogen.vim -Next you *need to add this* to your ~/.vimrc: + - execute pathogen#infect() +### 2.1\. Step 1: Install pathogen.vim -### Step 2: Install syntastic as a pathogen bundle +First I'll show you how to install Tim Pope's [pathogen][1] so that it's easy to +install syntastic. Do this in your terminal so that you get the `pathogen.vim` +file and the directories it needs: +```sh +mkdir -p ~/.vim/autoload ~/.vim/bundle; \ +curl -so ~/.vim/autoload/pathogen.vim \ + https://raw.github.com/tpope/vim-pathogen/master/autoload/pathogen.vim +``` +Next you *need* to add this to your `~/.vimrc`: +```vim +execute pathogen#infect() +``` -You now have pathogen installed and can put syntastic into ~/.vim/bundle like this: - + - cd ~/.vim/bundle - git clone https://github.com/scrooloose/syntastic.git +### 2.2\. Step 2: Install syntastic as a pathogen bundle +You now have pathogen installed and can put syntastic into `~/.vim/bundle` like +this: +```sh +cd ~/.vim/bundle +git clone https://github.com/scrooloose/syntastic.git +``` Quit vim and start it back up to reload it, then type: +```vim +:Helptags +``` +If you get an error when you do this, then you probably didn't install +[pathogen][1] right. Go back to [Step 1](#step1) and make sure you did the following: - :Helptags - -If you get an error when you do this, then you probably didn't install pathogen right. Go back to -step 1 and make sure you did the following: - -1. Created both the ~/.vim/autoload and ~/.vim/bundle directories. -2. Added the "call pathogen#infect()" line to your ~/.vimrc file -3. Did the git clone of syntastic inside ~/.vim/bundle +1. Created both the `~/.vim/autoload` and `~/.vim/bundle` directories. +2. Added the `call pathogen#infect()` line to your `~/.vimrc` file +3. Did the `git clone` of syntastic inside `~/.vim/bundle` 4. Have permissions to access all of these directories. -## Google group + -To get information or make suggestions check out the [google group](https://groups.google.com/group/vim-syntastic). - - -## FAQ +## 3\. FAQ __Q. I installed syntastic but it isn't reporting any errors...__ -A. The most likely reason is that none of the syntax checkers that it requires is installed. For example: python requires either `flake8`, `pyflakes` or `pylint` to be installed and in `$PATH`. To see which executables are supported, just look in `syntax_checkers//*.vim`. Note that aliases do not work; the actual executable must be available in your `$PATH`. Symbolic links are okay. You can see syntastic's idea of available checkers by running `:SyntasticInfo`. - -Another reason it could fail is that either the command line options or the error output for a syntax checker may have changed. In this case, make sure you have the latest version of the syntax checker installed. If it still fails then create an issue - or better yet, create a pull request. - -__Q. Recently some of my syntax checker options have stopped working...__ - -A. The options are still there, they have just been renamed. Recently, almost all syntax checkers were refactored to use the new `syntastic#makeprg#build()` function. This made a lot of the old explicit options redundant - as they are now implied. The new implied options usually have slightly different names to the old options. - -e.g. Previously there was `g:syntastic_phpcs_conf`, now you must use `g:syntastic_php_phpcs_args`. This completely overrides the arguments of the checker, including any defaults, so you may need to look up the default arguments of the checker and add these in. - -See `:help syntastic-checker-options` for more information. +A. The most likely reason is that none of the syntax checkers that it requires +is installed. For example: by default, python requires either `flake8` or +`pylint` to be installed and in your `$PATH`. To see which executables are +supported, look at the [wiki][3]. Note that aliases do not work; the actual +executables must be available in your `$PATH`. Symbolic links are okay though. +You can see syntastic's idea of available checkers by running `:SyntasticInfo`. + +Another reason it could fail is that either the command line options or the +error output for a syntax checker may have changed. In this case, make sure you +have the latest version of the syntax checker installed. If it still fails then +create an issue - or better yet, create a pull request. + +__Q. The `perl` checker has stopped working...__ + +A. The `perl` checker runs `perl -c` against your file, which in turn +__executes__ any `BEGIN`, `UNITCHECK`, and `CHECK` blocks, and any `use` +statements in your file (cf. [perlrun][10]). This is probably fine if you +wrote the file yourself, but it's a security problem if you're checking third +party files. Since there is currently no way to disable this behaviour while +still producing useful results, the checker is now disabled by default. To +(re-)enable it, set `g:syntastic_enable_perl_checker` to 1 in your vimrc: +```vim +let g:syntastic_enable_perl_checker = 1 +``` __Q. I run a checker and the location list is not updated...__ -A. By default, the location list is changed only when you run the `:Errors` command, in order to minimise conflicts with other plugins. If you want the location list to always be updated when you run the checkers, add this line to your vimrc: +A. By default the location list is changed only when you run the `:Errors` +command, in order to minimise conflicts with other plugins. If you want the +location list to always be updated when you run the checkers, add this line to +your vimrc: ```vim -let g:syntastic_always_populate_loc_list=1 +let g:syntastic_always_populate_loc_list = 1 ``` __Q. How can I pass additional arguments to a checker?__ -A. Almost all syntax checkers use the `syntastic#makeprg#build()` function. Those checkers that do can be configured using global variables. The general form of the global args variables are: -```vim -syntastic___args -``` +A. Almost all syntax checkers use the `makeprgBuild()` function. Those checkers +that do can be configured using global variables. The general form of the +global `args` variables is `syntastic___args`. -So, If you wanted to pass "--my --args --here" to the ruby mri checker you would add this line to your vimrc: +So, If you wanted to pass "--my --args --here" to the ruby mri checker you +would add this line to your vimrc: ```vim -let g:syntastic_ruby_mri_args="--my --args --here" +let g:syntastic_ruby_mri_args = "--my --args --here" ``` See `:help syntastic-checker-options` for more information. -__Q. Syntastic supports several checkers for my filetype - how do I tell it which one(s) to use?__ +__Q. Syntastic supports several checkers for my filetype - how do I tell it +which one(s) to use?__ A. Stick a line like this in your vimrc: ```vim -let g:syntastic__checkers=[''] +let g:syntastic__checkers = [''] ``` -To see the list of checkers for your filetype, look in `syntax_checkers//`. +To see the list of supported checkers for your filetype look at the +[wiki][3]. -e.g. Python has the following checkers: `flake8`, `pyflakes`, `pylint` and a native `python` checker. +e.g. Python has the following checkers, among others: `flake8`, `pyflakes`, +`pylint` and a native `python` checker. To tell syntastic to use `pylint`, you would use this setting: ```vim -let g:syntastic_python_checkers=['pylint'] +let g:syntastic_python_checkers = ['pylint'] ``` -Some filetypes, like PHP, have style checkers as well as syntax checkers. These can be chained together like this: +Some filetypes, like PHP, have style checkers as well as syntax checkers. These +can be chained together like this: ```vim -let g:syntastic_php_checkers=['php', 'phpcs', 'phpmd'] +let g:syntastic_php_checkers = ['php', 'phpcs', 'phpmd'] ``` -This is telling syntastic to run the `php` checker first, and if no errors are found, run `phpcs`, and then `phpmd`. +This is telling syntastic to run the `php` checker first, and if no errors are +found, run `phpcs`, and then `phpmd`. -__Q. How can I jump between the different errors without using the location list at the bottom of the window?__ +__Q. How can I jump between the different errors without using the location +list at the bottom of the window?__ -A. Vim provides several built in commands for this. See `:help :lnext` and `:help :lprev`. +A. Vim provides several built in commands for this. See `:help :lnext` and +`:help :lprev`. -If you use these commands a lot then you may want to add shortcut mappings to your vimrc, or install something like [unimpaired](https://github.com/tpope/vim-unimpaired), which provides such mappings (among other things). +If you use these commands a lot then you may want to add shortcut mappings to +your vimrc, or install something like [unimpaired][2], which provides such +mappings (among other things). __Q. A syntax checker is giving me unwanted/strange style tips?__ -A. Some filetypes (e.g. php) have style checkers as well as syntax checkers. You can usually configure the options that are passed to the style checkers, or just disable them. Take a look at the [wiki](https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers) to see what options are available. +A. Some filetypes (e.g. php) have style checkers as well as syntax +checkers. You can usually configure the options that are passed to the style +checkers, or just disable them. Take a look at the [wiki][3] to see what +options are available. -__Q. The error window is closed automatically when I :quit the current buffer but not when I :bdelete it?__ +Alternatively, you can use `g:syntastic_quiet_messages` to filter out the +messages you don't want to see. e.g. To turn off all style messages: +```vim +let g:syntastic_quiet_messages = { "type": "style" } +``` +See `:help syntastic_quiet_messages` for details. + +__Q. The error window is closed automatically when I :quit the current buffer +but not when I :bdelete it?__ -A. There is no safe way to handle that situation automatically, but you can work around it: +A. There is no safe way to handle that situation automatically, but you can +work around it: ```vim nnoremap :lclose:bdelete cabbrev bd lclose\|bdelete ``` + + + + +## 4\. Other resources + +The preferred place for posting suggestions, reporting bugs, and general +discussions related to syntastic is the [issue tracker at GitHub][4]. There +are also a [google group][5], and a [syntastic tag at StackOverflow][6]. + +Syntastic aims to provide a common interface to syntax checkers for as many +languages as possible. For particular languages, there are, of course, other +plugins that provide more functionality than syntastic. You might want to take +a look at [jedi-vim][7], [python-mode][8], or [YouCompleteMe][9]. + +[0]: https://github.com/scrooloose/syntastic/raw/master/_assets/screenshot_1.png +[1]: https://github.com/tpope/vim-pathogen +[2]: https://github.com/tpope/vim-unimpaired +[3]: https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers +[4]: https://github.com/scrooloose/syntastic/issues +[5]: https://groups.google.com/group/vim-syntastic +[6]: http://stackoverflow.com/questions/tagged/syntastic +[7]: https://github.com/davidhalter/jedi-vim +[8]: https://github.com/klen/python-mode +[9]: https://github.com/Valloric/YouCompleteMe +[10]: http://perldoc.perl.org/perlrun.html#*-c* diff --git a/bundle/syntastic/autoload/syntastic/c.vim b/bundle/syntastic/autoload/syntastic/c.vim index a1c5c7ef..4bd79472 100644 --- a/bundle/syntastic/autoload/syntastic/c.vim +++ b/bundle/syntastic/autoload/syntastic/c.vim @@ -1,4 +1,4 @@ -if exists("g:loaded_syntastic_c_autoload") +if exists("g:loaded_syntastic_c_autoload") || !exists("g:loaded_syntastic_plugin") finish endif let g:loaded_syntastic_c_autoload = 1 @@ -10,14 +10,14 @@ set cpo&vim " convenience function to determine the 'null device' parameter " based on the current operating system -function! syntastic#c#NullOutput() - let known_os = has('win32') || has('unix') || has('mac') +function! syntastic#c#NullOutput() " {{{2 + let known_os = has('unix') || has('mac') || syntastic#util#isRunningWindows() return known_os ? '-o ' . syntastic#util#DevNull() : '' -endfunction +endfunction " }}}2 " read additional compiler flags from the given configuration file " the file format and its parsing mechanism is inspired by clang_complete -function! syntastic#c#ReadConfig(file) +function! syntastic#c#ReadConfig(file) " {{{2 " search in the current file's directory upwards let config = findfile(a:file, '.;') if config == '' || !filereadable(config) @@ -30,7 +30,7 @@ function! syntastic#c#ReadConfig(file) " try to read config file try let lines = readfile(config) - catch /^Vim\%((\a\+)\)\=:E484/ + catch /\m^Vim\%((\a\+)\)\=:E48[45]/ return '' endtry @@ -43,35 +43,36 @@ function! syntastic#c#ReadConfig(file) let parameters = [] for line in lines - let matches = matchlist(line, '\m\C^\s*-I\s*\(\S\+\)') - if matches != [] && matches[1] != '' + let matches = matchstr(line, '\m\C^\s*-I\s*\zs.\+') + if matches != '' " this one looks like an absolute path - if match(matches[1], '\m^\%(/\|\a:\)') != -1 - call add(parameters, '-I' . matches[1]) + if match(matches, '\m^\%(/\|\a:\)') != -1 + call add(parameters, '-I' . matches) else - call add(parameters, '-I' . filepath . syntastic#util#Slash() . matches[1]) + call add(parameters, '-I' . filepath . syntastic#util#Slash() . matches) endif else call add(parameters, line) endif endfor - return join(map(parameters, 'syntastic#util#shescape(fnameescape(v:val))'), ' ') -endfunction + return join(map(parameters, 'syntastic#util#shescape(v:val)')) +endfunction " }}}2 " GetLocList() for C-like compilers -function! syntastic#c#GetLocList(filetype, subchecker, options) +function! syntastic#c#GetLocList(filetype, subchecker, options) " {{{2 try - let flags = s:GetCflags(a:filetype, a:subchecker, a:options) + let flags = s:getCflags(a:filetype, a:subchecker, a:options) catch /\m\C^Syntastic: skip checks$/ return [] endtry - let makeprg = g:syntastic_{a:filetype}_compiler . ' ' . flags . ' ' . syntastic#util#shexpand('%') + let makeprg = syntastic#util#shexpand(g:syntastic_{a:filetype}_compiler) . + \ ' ' . flags . ' ' . syntastic#util#shexpand('%') - let errorformat = s:GetCheckerVar('g', a:filetype, a:subchecker, 'errorformat', a:options['errorformat']) + let errorformat = s:getCheckerVar('g', a:filetype, a:subchecker, 'errorformat', a:options['errorformat']) - let postprocess = s:GetCheckerVar('g', a:filetype, a:subchecker, 'remove_include_errors', 0) ? + let postprocess = s:getCheckerVar('g', a:filetype, a:subchecker, 'remove_include_errors', 0) ? \ ['filterForeignErrors'] : [] " process makeprg @@ -79,34 +80,45 @@ function! syntastic#c#GetLocList(filetype, subchecker, options) \ 'makeprg': makeprg, \ 'errorformat': errorformat, \ 'postprocess': postprocess }) -endfunction +endfunction " }}}2 + +" }}}1 " Private functions {{{1 " initialize c/cpp syntax checker handlers -function! s:Init() +function! s:init() " {{{2 let s:handlers = [] let s:cflags = {} - call s:RegHandler('cairo', 'syntastic#c#CheckPKG', ['cairo', 'cairo']) - call s:RegHandler('freetype', 'syntastic#c#CheckPKG', ['freetype', 'freetype2', 'freetype']) - call s:RegHandler('glade', 'syntastic#c#CheckPKG', ['glade', 'libglade-2.0', 'libglade']) - call s:RegHandler('glib', 'syntastic#c#CheckPKG', ['glib', 'glib-2.0', 'glib']) - call s:RegHandler('gtk', 'syntastic#c#CheckPKG', ['gtk', 'gtk+-2.0', 'gtk+', 'glib-2.0', 'glib']) - call s:RegHandler('libsoup', 'syntastic#c#CheckPKG', ['libsoup', 'libsoup-2.4', 'libsoup-2.2']) - call s:RegHandler('libxml', 'syntastic#c#CheckPKG', ['libxml', 'libxml-2.0', 'libxml']) - call s:RegHandler('pango', 'syntastic#c#CheckPKG', ['pango', 'pango']) - call s:RegHandler('SDL', 'syntastic#c#CheckPKG', ['sdl', 'sdl']) - call s:RegHandler('opengl', 'syntastic#c#CheckPKG', ['opengl', 'gl']) - call s:RegHandler('webkit', 'syntastic#c#CheckPKG', ['webkit', 'webkit-1.0']) - - call s:RegHandler('php\.h', 'syntastic#c#CheckPhp', []) - call s:RegHandler('Python\.h', 'syntastic#c#CheckPython', []) - call s:RegHandler('ruby', 'syntastic#c#CheckRuby', []) -endfunction + call s:regHandler('\m\', 'syntastic#c#checkPHP', []) + call s:regHandler('\m\', 'syntastic#c#checkPython', []) + call s:regHandler('\m\" + echohl ErrorMsg + echomsg "syntastic: error: " . a:msg + echohl None +endfunction " }}}2 + +function! syntastic#log#deprecationWarn(msg) " {{{2 + if index(s:deprecation_notices_issued, a:msg) >= 0 + return + endif + + call add(s:deprecation_notices_issued, a:msg) + call syntastic#log#warn(a:msg) +endfunction " }}}2 + +function! syntastic#log#debug(level, msg, ...) " {{{2 + if !s:isDebugEnabled(a:level) + return + endif + + let leader = s:logTimestamp() + call s:logRedirect(1) + + if a:0 > 0 + " filter out dictionary functions + echomsg leader . a:msg . ' ' . + \ strtrans(string(type(a:1) == type({}) || type(a:1) == type([]) ? + \ filter(copy(a:1), 'type(v:val) != type(function("tr"))') : a:1)) + else + echomsg leader . a:msg + endif + + call s:logRedirect(0) +endfunction " }}}2 + +function! syntastic#log#debugShowOptions(level, names) " {{{2 + if !s:isDebugEnabled(a:level) + return + endif + + let leader = s:logTimestamp() + call s:logRedirect(1) + + let vlist = copy(type(a:names) == type("") ? [a:names] : a:names) + if !empty(vlist) + call map(vlist, "'&' . v:val . ' = ' . strtrans(string(eval('&' . v:val)))") + echomsg leader . join(vlist, ', ') + endif + call s:logRedirect(0) +endfunction " }}}2 + +function! syntastic#log#debugShowVariables(level, names) " {{{2 + if !s:isDebugEnabled(a:level) + return + endif + + let leader = s:logTimestamp() + call s:logRedirect(1) + + let vlist = type(a:names) == type("") ? [a:names] : a:names + for name in vlist + let msg = s:formatVariable(name) + if msg != '' + echomsg leader . msg + endif + endfor + + call s:logRedirect(0) +endfunction " }}}2 + +function! syntastic#log#debugDump(level) " {{{2 + if !s:isDebugEnabled(a:level) + return + endif + + call syntastic#log#debugShowVariables( a:level, sort(keys(g:syntastic_defaults)) ) +endfunction " }}}2 + +" }}}1 + +" Private functions {{{1 + +function! s:isDebugEnabled_smart(level) " {{{2 + return and(g:syntastic_debug, a:level) +endfunction " }}}2 + +function! s:isDebugEnabled_dumb(level) " {{{2 + " poor man's bit test for bit N, assuming a:level == 2**N + return (g:syntastic_debug / a:level) % 2 +endfunction " }}}2 + +let s:isDebugEnabled = function(exists('*and') ? 's:isDebugEnabled_smart' : 's:isDebugEnabled_dumb') + +function! s:logRedirect(on) " {{{2 + if exists("g:syntastic_debug_file") + if a:on + try + execute 'redir >> ' . fnameescape(expand(g:syntastic_debug_file)) + catch /\m^Vim\%((\a\+)\)\=:/ + silent! redir END + unlet g:syntastic_debug_file + endtry + else + silent! redir END + endif + endif +endfunction " }}}2 + +function! s:logTimestamp_smart() " {{{2 + return 'syntastic: ' . split(reltimestr(reltime(g:syntastic_start)))[0] . ': ' +endfunction " }}}2 + +function! s:logTimestamp_dumb() " {{{2 + return 'syntastic: debug: ' +endfunction " }}}2 + +let s:logTimestamp = function(has('reltime') ? 's:logTimestamp_smart' : 's:logTimestamp_dumb') + +function! s:formatVariable(name) " {{{2 + let vals = [] + if exists('g:syntastic_' . a:name) + call add(vals, 'g:syntastic_' . a:name . ' = ' . strtrans(string(g:syntastic_{a:name}))) + endif + if exists('b:syntastic_' . a:name) + call add(vals, 'b:syntastic_' . a:name . ' = ' . strtrans(string(b:syntastic_{a:name}))) + endif + + return join(vals, ', ') +endfunction " }}}2 + +" }}}1 + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/autoload/syntastic/makeprg.vim b/bundle/syntastic/autoload/syntastic/makeprg.vim deleted file mode 100644 index 4d7a0331..00000000 --- a/bundle/syntastic/autoload/syntastic/makeprg.vim +++ /dev/null @@ -1,50 +0,0 @@ -if exists("g:loaded_syntastic_makeprg_autoload") - finish -endif -let g:loaded_syntastic_makeprg_autoload = 1 - -"Returns a makeprg of the form -" -"[exe] [args] [filename] [post_args] [tail] -" -"A (made up) example: -" ruby -a -b -c test_file.rb --more --args > /tmp/output -" -"To generate this you would call: -" -" let makeprg = syntastic#makeprg#build({ -" \ 'exe': 'ruby', -" \ 'args': '-a -b -c', -" \ 'post_args': '--more --args', -" \ 'tail': '> /tmp/output', -" \ 'filetype': 'ruby', -" \ 'subchecker': 'mri' }) -" -"Note that the current filename is added by default - but can be overridden by -"passing in an 'fname' arg. -" -"Arguments 'filetype' and 'subchecker' are mandatory, handling of composite -"types and user-defined variables breaks if you omit them. -" -"All other options can be overriden by the user with global variables - even -"when not specified by the checker in syntastic#makeprg#build(). -" -"E.g. They could override the checker exe with -" -" let g:syntastic_ruby_mri_exe="another_ruby_checker_exe.rb" -" -"The general form of the override option is: -" syntastic_[filetype]_[subchecker]_[option-name] -" -function! syntastic#makeprg#build(opts) - let builder = g:SyntasticMakeprgBuilder.New( - \ get(a:opts, 'exe', ''), - \ get(a:opts, 'args', ''), - \ get(a:opts, 'fname', ''), - \ get(a:opts, 'post_args', ''), - \ get(a:opts, 'tail', ''), - \ get(a:opts, 'filetype', ''), - \ get(a:opts, 'subchecker', '') ) - - return builder.makeprg() -endfunction diff --git a/bundle/syntastic/autoload/syntastic/postprocess.vim b/bundle/syntastic/autoload/syntastic/postprocess.vim index e1f62e8a..1558f0f8 100644 --- a/bundle/syntastic/autoload/syntastic/postprocess.vim +++ b/bundle/syntastic/autoload/syntastic/postprocess.vim @@ -1,4 +1,4 @@ -if exists("g:loaded_syntastic_postprocess_autoload") +if exists("g:loaded_syntastic_postprocess_autoload") || !exists("g:loaded_syntastic_plugin") finish endif let g:loaded_syntastic_postprocess_autoload = 1 @@ -6,7 +6,9 @@ let g:loaded_syntastic_postprocess_autoload = 1 let s:save_cpo = &cpo set cpo&vim -function! s:compareErrorItems(a, b) +" Public functions {{{1 + +function! s:compareErrorItems(a, b) " {{{2 if a:a['bufnr'] != a:b['bufnr'] " group by files return a:a['bufnr'] - a:b['bufnr'] @@ -16,61 +18,54 @@ function! s:compareErrorItems(a, b) " errors take precedence over warnings return a:a['type'] ==? 'e' ? -1 : 1 else - return get(a:a, 'col') - get(a:b, 'col') + return get(a:a, 'col', 0) - get(a:b, 'col', 0) endif -endfunction +endfunction " }}}2 " natural sort -function! syntastic#postprocess#sort(errors) - return sort(a:errors, 's:compareErrorItems') -endfunction - -function syntastic#postprocess#compressWhitespace(errors) - let llist = [] +function! syntastic#postprocess#sort(errors) " {{{2 + return sort(copy(a:errors), 's:compareErrorItems') +endfunction " }}}2 +" merge consecutive blanks +function! syntastic#postprocess#compressWhitespace(errors) " {{{2 for e in a:errors let e['text'] = substitute(e['text'], "\001", '', 'g') let e['text'] = substitute(e['text'], '\n', ' ', 'g') let e['text'] = substitute(e['text'], '\m\s\{2,}', ' ', 'g') - call add(llist, e) endfor - return llist -endfunction + return a:errors +endfunction " }}}2 " remove spurious CR under Cygwin -function! syntastic#postprocess#cygwinRemoveCR(errors) +function! syntastic#postprocess#cygwinRemoveCR(errors) " {{{2 if has('win32unix') - let llist = [] - for e in a:errors let e['text'] = substitute(e['text'], '\r', '', 'g') - call add(llist, e) endfor - else - let llist = a:errors endif - return llist -endfunction + return a:errors +endfunction " }}}2 " decode XML entities -function! syntastic#postprocess#decodeXMLEntities(errors) - let llist = [] - +function! syntastic#postprocess#decodeXMLEntities(errors) " {{{2 for e in a:errors let e['text'] = syntastic#util#decodeXMLEntities(e['text']) - call add(llist, e) endfor - return llist -endfunction + return a:errors +endfunction " }}}2 " filter out errors referencing other files -function! syntastic#postprocess#filterForeignErrors(errors) +function! syntastic#postprocess#filterForeignErrors(errors) " {{{2 return filter(copy(a:errors), 'get(v:val, "bufnr") == ' . bufnr('')) -endfunction +endfunction " }}}2 + +" }}}1 let &cpo = s:save_cpo unlet s:save_cpo -" vim: set et sts=4 sw=4: + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/autoload/syntastic/preprocess.vim b/bundle/syntastic/autoload/syntastic/preprocess.vim new file mode 100644 index 00000000..f1af35be --- /dev/null +++ b/bundle/syntastic/autoload/syntastic/preprocess.vim @@ -0,0 +1,79 @@ +if exists("g:loaded_syntastic_preprocess_autoload") || !exists("g:loaded_syntastic_plugin") + finish +endif +let g:loaded_syntastic_preprocess_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" Public functions {{{1 + +function! syntastic#preprocess#checkstyle(errors) " {{{2 + let out = [] + let fname = expand('%') + for err in a:errors + if match(err, '\m') > -1 + let line = str2nr(matchstr(err, '\m\ \[[^]]+\])+\ze:'', "", "")') +endfunction " }}}2 + +function! syntastic#preprocess#killEmpty(errors) " {{{2 + return filter(copy(a:errors), 'v:val != ""') +endfunction " }}}2 + +function! syntastic#preprocess#perl(errors) " {{{2 + let out = [] + + for e in a:errors + let parts = matchlist(e, '\v^(.*)\sat\s(.*)\sline\s(\d+)(.*)$') + if !empty(parts) + call add(out, parts[2] . ':' . parts[3] . ':' . parts[1] . parts[4]) + endif + endfor + + return syntastic#util#unique(out) +endfunction " }}}2 + +function! syntastic#preprocess#validator(errors) " {{{2 + let out = [] + for e in a:errors + let parts = matchlist(e, '\v^"([^"]+)"(.+)') + if len(parts) >= 3 + " URL decode, except leave alone any "+" + let parts[1] = substitute(parts[1], '\m%\(\x\x\)', '\=nr2char("0x".submatch(1))', 'g') + let parts[1] = substitute(parts[1], '\m\\"', '"', 'g') + let parts[1] = substitute(parts[1], '\m\\\\', '\\', 'g') + call add(out, '"' . parts[1] . '"' . parts[2]) + endif + endfor + return out +endfunction " }}}2 + +" }}}1 + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/autoload/syntastic/util.vim b/bundle/syntastic/autoload/syntastic/util.vim index 10c01303..d1dc2618 100644 --- a/bundle/syntastic/autoload/syntastic/util.vim +++ b/bundle/syntastic/autoload/syntastic/util.vim @@ -1,4 +1,4 @@ -if exists("g:loaded_syntastic_util_autoload") +if exists('g:loaded_syntastic_util_autoload') || !exists("g:loaded_syntastic_plugin") finish endif let g:loaded_syntastic_util_autoload = 1 @@ -6,42 +6,23 @@ let g:loaded_syntastic_util_autoload = 1 let s:save_cpo = &cpo set cpo&vim -if !exists("g:syntastic_debug") - let g:syntastic_debug = 0 -endif - -if !exists("g:syntastic_delayed_redraws") - let g:syntastic_delayed_redraws = 0 -endif +" Public functions {{{1 -let s:deprecationNoticesIssued = [] -let s:redraw_delayed = 0 -let s:redraw_full = 0 - -if g:syntastic_delayed_redraws - " CursorHold / CursorHoldI events are triggered if user doesn't press a - " key for &updatetime ms. We change it only if current value is the default - " value, that is 4000 ms. - if &updatetime == 4000 - let &updatetime = 500 - endif +function! syntastic#util#isRunningWindows() " {{{2 + return has('win16') || has('win32') || has('win64') +endfunction " }}}2 - augroup syntastic - autocmd CursorHold,CursorHoldI * call syntastic#util#redrawHandler() - augroup END -endif - -function! syntastic#util#DevNull() - if has('win32') +function! syntastic#util#DevNull() " {{{2 + if syntastic#util#isRunningWindows() return 'NUL' endif return '/dev/null' -endfunction +endfunction " }}}2 " Get directory separator -function! syntastic#util#Slash() abort - return !exists("+shellslash") || &shellslash ? '/' : '\' -endfunction +function! syntastic#util#Slash() abort " {{{2 + return (!exists("+shellslash") || &shellslash) ? '/' : '\' +endfunction " }}}2 "search the first 5 lines of the file for a magic number and return a map "containing the args and the executable @@ -53,30 +34,38 @@ endfunction "returns " "{'exe': '/usr/bin/perl', 'args': ['-f', '-bar']} -function! syntastic#util#parseShebang() +function! syntastic#util#parseShebang() " {{{2 for lnum in range(1,5) let line = getline(lnum) if line =~ '^#!' let exe = matchstr(line, '\m^#!\s*\zs[^ \t]*') let args = split(matchstr(line, '\m^#!\s*[^ \t]*\zs.*')) - return {'exe': exe, 'args': args} + return { 'exe': exe, 'args': args } endif endfor - return {'exe': '', 'args': []} -endfunction + return { 'exe': '', 'args': [] } +endfunction " }}}2 + +" Get the value of a variable. Allow local variables to override global ones. +function! syntastic#util#var(name, ...) " {{{2 + return + \ exists('b:syntastic_' . a:name) ? b:syntastic_{a:name} : + \ exists('g:syntastic_' . a:name) ? g:syntastic_{a:name} : + \ a:0 > 0 ? a:1 : '' +endfunction " }}}2 " Parse a version string. Return an array of version components. -function! syntastic#util#parseVersion(version) +function! syntastic#util#parseVersion(version) " {{{2 return split(matchstr( a:version, '\v^\D*\zs\d+(\.\d+)+\ze' ), '\m\.') -endfunction +endfunction " }}}2 " Run 'command' in a shell and parse output as a version string. " Returns an array of version components. -function! syntastic#util#getVersion(command) +function! syntastic#util#getVersion(command) " {{{2 return syntastic#util#parseVersion(system(a:command)) -endfunction +endfunction " }}}2 " Verify that the 'installed' version is at least the 'required' version. " @@ -84,53 +73,48 @@ endfunction " the "missing" elements will be assumed to be 0 for the purposes of checking. " " See http://semver.org for info about version numbers. -function! syntastic#util#versionIsAtLeast(installed, required) - for index in range(max([len(a:installed), len(a:required)])) - if len(a:installed) <= index - let installed_element = 0 - else - let installed_element = a:installed[index] - endif - if len(a:required) <= index - let required_element = 0 - else - let required_element = a:required[index] - endif +function! syntastic#util#versionIsAtLeast(installed, required) " {{{2 + for idx in range(max([len(a:installed), len(a:required)])) + let installed_element = get(a:installed, idx, 0) + let required_element = get(a:required, idx, 0) if installed_element != required_element return installed_element > required_element endif endfor " Everything matched, so it is at least the required version. return 1 -endfunction +endfunction " }}}2 + +" strwidth() was added in Vim 7.3; if it doesn't exist, we use strlen() +" and hope for the best :) +let s:width = function(exists('*strwidth') ? 'strwidth' : 'strlen') "print as much of a:msg as possible without "Press Enter" prompt appearing -function! syntastic#util#wideMsg(msg) +function! syntastic#util#wideMsg(msg) " {{{2 let old_ruler = &ruler let old_showcmd = &showcmd - "convert tabs to spaces so that the tabs count towards the window width - "as the proper amount of characters - let msg = substitute(a:msg, "\t", repeat(" ", &tabstop), "g") - let msg = strpart(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. + let msg = substitute(a:msg, "\n", "", "g") - "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") + "convert tabs to spaces so that the tabs count towards the window + "width as the proper amount of characters + let chunks = split(msg, "\t", 1) + let msg = join(map(chunks[:-2], 'v:val . repeat(" ", &ts - s:width(v:val) % &ts)'), '') . chunks[-1] + let msg = strpart(msg, 0, &columns - 1) set noruler noshowcmd call syntastic#util#redraw(0) echo msg - let &ruler=old_ruler - let &showcmd=old_showcmd -endfunction + let &ruler = old_ruler + let &showcmd = old_showcmd +endfunction " }}}2 " Check whether a buffer is loaded, listed, and not hidden -function! syntastic#util#bufIsActive(buffer) +function! syntastic#util#bufIsActive(buffer) " {{{2 " convert to number, or hell breaks loose let buf = str2nr(a:buffer) @@ -146,32 +130,43 @@ function! syntastic#util#bufIsActive(buffer) endfor return 0 -endfunction +endfunction " }}}2 " start in directory a:where and walk up the parent folders until it " finds a file matching a:what; return path to that file -function! syntastic#util#findInParent(what, where) +function! syntastic#util#findInParent(what, where) " {{{2 let here = fnamemodify(a:where, ':p') - while !empty(here) + let root = syntastic#util#Slash() + if syntastic#util#isRunningWindows() && here[1] == ':' + " The drive letter is an ever-green source of fun. That's because + " we don't care about running syntastic on Amiga these days. ;) + let root = fnamemodify(root, ':p') + let root = here[0] . root[1:] + endif + + let old = '' + while here != '' let p = split(globpath(here, a:what), '\n') if !empty(p) return fnamemodify(p[0], ':p') - elseif here == '/' + elseif here ==? root || here ==? old break endif + let old = here + " we use ':h:h' rather than ':h' since ':p' adds a trailing '/' " if 'here' is a directory let here = fnamemodify(here, ':p:h:h') endwhile return '' -endfunction +endfunction " }}}2 " Returns unique elements in a list -function! syntastic#util#unique(list) +function! syntastic#util#unique(list) " {{{2 let seen = {} let uniques = [] for e in a:list @@ -181,20 +176,20 @@ function! syntastic#util#unique(list) endif endfor return uniques -endfunction +endfunction " }}}2 " A less noisy shellescape() -function! syntastic#util#shescape(string) +function! syntastic#util#shescape(string) " {{{2 return a:string =~ '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string) -endfunction +endfunction " }}}2 " A less noisy shellescape(expand()) -function! syntastic#util#shexpand(string) +function! syntastic#util#shexpand(string) " {{{2 return syntastic#util#shescape(expand(a:string)) -endfunction +endfunction " }}}2 " decode XML entities -function! syntastic#util#decodeXMLEntities(string) +function! syntastic#util#decodeXMLEntities(string) " {{{2 let str = a:string let str = substitute(str, '\m<', '<', 'g') let str = substitute(str, '\m>', '>', 'g') @@ -202,76 +197,66 @@ function! syntastic#util#decodeXMLEntities(string) let str = substitute(str, '\m'', "'", 'g') let str = substitute(str, '\m&', '\&', 'g') return str -endfunction - -" On older Vim versions calling redraw while a popup is visible can make -" Vim segfault, so move redraws to a CursorHold / CursorHoldI handler. -function! syntastic#util#redraw(full) - if !g:syntastic_delayed_redraws || !pumvisible() - call s:Redraw(a:full) - let s:redraw_delayed = 0 - let s:redraw_full = 0 - else - let s:redraw_delayed = 1 - let s:redraw_full = s:redraw_full || a:full - endif -endfunction +endfunction " }}}2 -function! syntastic#util#redrawHandler() - if s:redraw_delayed && !pumvisible() - call s:Redraw(s:redraw_full) - let s:redraw_delayed = 0 - let s:redraw_full = 0 - endif -endfunction - -function! syntastic#util#debug(msg) - if g:syntastic_debug - echomsg "syntastic: debug: " . a:msg - endif -endfunction - -function! syntastic#util#info(msg) - echomsg "syntastic: info: " . a:msg -endfunction - -function! syntastic#util#warn(msg) - echohl WarningMsg - echomsg "syntastic: warning: " . a:msg - echohl None -endfunction - -function! syntastic#util#error(msg) - execute "normal \" - echohl ErrorMsg - echomsg "syntastic: error: " . a:msg - echohl None -endfunction - -function! syntastic#util#deprecationWarn(msg) - if index(s:deprecationNoticesIssued, a:msg) >= 0 - return - endif - - call add(s:deprecationNoticesIssued, a:msg) - call syntastic#util#warn(a:msg) -endfunction - -"Redraw in a way that doesnt make the screen flicker or leave anomalies behind. -" -"Some terminal versions of vim require `redraw!` - otherwise there can be -"random anomalies left behind. -" -"However, on some versions of gvim using `redraw!` causes the screen to -"flicker - so use redraw. -function! s:Redraw(full) +function! syntastic#util#redraw(full) " {{{2 if a:full redraw! else redraw endif -endfunction +endfunction " }}}2 + +function! syntastic#util#dictFilter(errors, filter) " {{{2 + let rules = s:translateFilter(a:filter) + " call syntastic#log#debug(g:SyntasticDebugFilters, "applying filter:", rules) + try + call filter(a:errors, rules) + catch /\m^Vim\%((\a\+)\)\=:E/ + let msg = matchstr(v:exception, '\m^Vim\%((\a\+)\)\=:\zs.*') + call syntastic#log#error('quiet_messages: ' . msg) + endtry +endfunction " }}}2 + +" }}}1 + +" Private functions {{{1 + +function! s:translateFilter(filters) " {{{2 + let conditions = [] + for k in keys(a:filters) + if type(a:filters[k]) == type([]) + call extend(conditions, map(copy(a:filters[k]), 's:translateElement(k, v:val)')) + else + call add(conditions, s:translateElement(k, a:filters[k])) + endif + endfor + + if conditions == [] + let conditions = ["1"] + endif + return len(conditions) == 1 ? conditions[0] : join(map(conditions, '"(" . v:val . ")"'), ' && ') +endfunction " }}}2 + +function! s:translateElement(key, term) " {{{2 + if a:key ==? 'level' + let ret = 'v:val["type"] !=? ' . string(a:term[0]) + elseif a:key ==? 'type' + let ret = a:term ==? 'style' ? 'get(v:val, "subtype", "") !=? "style"' : 'has_key(v:val, "subtype")' + elseif a:key ==? 'regex' + let ret = 'v:val["text"] !~? ' . string(a:term) + elseif a:key ==? 'file' + let ret = 'bufname(str2nr(v:val["bufnr"])) !~# ' . string(a:term) + else + call syntastic#log#warn('quiet_messages: ignoring invalid key ' . strtrans(string(a:key))) + let ret = "1" + endif + return ret +endfunction " }}}2 + +" }}}1 let &cpo = s:save_cpo unlet s:save_cpo -" vim: set et sts=4 sw=4: + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/bundle/syntastic/doc/syntastic.txt b/bundle/syntastic/doc/syntastic.txt index 4fd0c056..86a5ed2b 100644 --- a/bundle/syntastic/doc/syntastic.txt +++ b/bundle/syntastic/doc/syntastic.txt @@ -20,17 +20,25 @@ CONTENTS *syntastic-contents* 1.Intro........................................|syntastic-intro| + 1.1.Quick start............................|syntastic-quickstart| 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| + 2.4.Error highlighting.....................|syntastic-highlighting| + 2.5.Aggregating errors.....................|syntastic-aggregating-errors| + 2.6.Filtering errors.......................|syntastic-filtering-errors| 3.Commands.....................................|syntastic-commands| 4.Global Options...............................|syntastic-global-options| 5.Checker Options..............................|syntastic-checker-options| + 5.1.Choosing which checkers to use.........|syntastic-filetype-checkers| + 5.2.Choosing the executable................|syntastic-config-exec| + 5.3.Configuring specific checkers..........|syntastic-config-makeprg| 6.Notes........................................|syntastic-notes| 6.1.Handling of composite filetypes........|syntastic-composite| 6.2.Interaction with python-mode...........|syntastic-pymode| 6.3.Interaction with the fish shell........|syntastic-fish| + 6.4.Using syntastic with the fizsh shell...|syntastic-fizsh| 7.About........................................|syntastic-about| 8.License......................................|syntastic-license| @@ -38,11 +46,6 @@ CONTENTS *syntastic-contents* ============================================================================== 1. Intro *syntastic-intro* -Note: This doc only deals with using syntastic. To learn how to write syntax -checker integrations, see the guide on the github wiki: - - https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide - 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 @@ -54,15 +57,38 @@ 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. -Take a look in the syntax_checkers directory for a list of supported filetypes -and checkers. +Take a look at the wiki for a list of supported filetypes and checkers: + https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers + +Note: This doc only deals with using syntastic. To learn how to write syntax +checker integrations, see the guide on the github wiki: + + https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide + +------------------------------------------------------------------------------ +1.1. Quick start *syntastic-quickstart* + +Syntastic comes preconfigured with a default list of enabled checkers per +filetype. This list is kept reasonably short to prevent slowing down Vim or +trying to use conflicting checkers. + +You can see the list checkers available for the current filetype with the +|:SyntasticInfo| command. + +If you want to override the configured list of checkers for a filetype then +see |syntastic-checker-options| for details. You can also change the arguments +passed to a specific checker as well. + +Use |:SyntasticCheck| to manually check right now. Use |:SyntasticToggleMode| +to switch between active (checking on writting the buffer) and passive (manual) +checking. ============================================================================== 2. Functionality provided *syntastic-functionality* Syntax checking can be done automatically or on demand (see -|'syntastic_mode_map'| for configuring this). +|'syntastic_mode_map'| and |:SyntasticToggleMode| 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 @@ -71,12 +97,13 @@ activate/deactivate these features. * A statusline flag * Signs beside lines with errors * The |location-list| can be populated with the errors for the associated - buffer. + buffer * Erroneous 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. - + provided by some syntax checkers) + * Balloons (if the |+balloon_eval| feature is compiled in) can be used to + display error messages for erroneous lines when hovering the mouse over + them + * Error messages from multiple checkers can be aggregated in a single list ------------------------------------------------------------------------------ 2.1. The statusline flag *syntastic-statusline-flag* @@ -90,7 +117,8 @@ Something like this could be more useful: > 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 +is derived from the |syntastic_stl_format| option. + ------------------------------------------------------------------------------ 2.2. Error signs *syntastic-error-signs* @@ -121,9 +149,8 @@ following highlight groups: Example: > highlight SyntasticErrorLine guibg=#2f0000 < - ------------------------------------------------------------------------------ -2.3. The error window *:Errors* *syntastic-error-window* +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|. @@ -131,6 +158,44 @@ in the |location-list|. Note that when you use :Errors, the current location list is overwritten with Syntastic's own location list. +------------------------------------------------------------------------------ +2.4. Error highlighting *syntastic-highlighting* + +Some checkers provide enough information for syntastic to be able to highlight +errors. By default the SpellBad syntax highlight group is used to color errors, +and the SpellCap group is used for warnings. If you wish to customize the +colors for highlighting you can use the following groups: + SyntasticError - Links to 'SpellBad' by default + SyntasticWarning - Links to 'SpellCap' by default + +Example: > + highlight SyntasticError guibg=#2f0000 +< +------------------------------------------------------------------------------ +2.5. Aggregating errors *syntastic-aggregating-errors* + +By default, namely if |'syntastic_aggregate_errors'| is unset, syntastic runs +in turn the checkers corresponding to the filetype of the current file (see +|syntastic-filetype-checkers|), and stops as soon as a checker reports any +errors. It then notifies you of the errors using the notification mechanisms +above. In this mode error lists are always produced by a single checker, and, +if you open the error window, the name of the checker that generated the errors +is shown on the statusline of the error window. + +If |'syntastic_aggregate_errors'| is set, syntastic runs all checkers that +apply (still cf. |syntastic-filetype-checkers|), then aggregates errors found +by all checkers in a single list, and notifies you. In this mode each error +message is labeled with the name of the checker that generated it, but you can +disable these labels by unsetting '|syntastic_id_checkers|'. + +------------------------------------------------------------------------------ +2.6 Filtering errors *syntastic-filtering-errors* + +You can selectively disable some of the errors found by checkers either +using |'syntastic_quiet_messages'|, or by specifying a list of patterns in +|'syntastic_ignore_files'|. + +See also: |'syntastic___quiet_messages'|. ============================================================================== 3. Commands *syntastic-commands* @@ -140,27 +205,45 @@ Syntastic's own location list. 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. +Manually cause a syntax check to be done. By default the checkers in the +|'g:syntastic__checkers'| or |'b:syntastic_checkers'| lists are run, +cf. |syntastic-filetype-checkers|. If |syntastic_aggregate_errors| is unset +(which is the default), checking stops the first time a checker reports any +errors; if |syntastic_aggregate_errors| is set, all checkers that apply are run +in turn, and all errors found are aggregated in a single list. +The command may be followed by a (space separated) list of checkers. In this +case |'g:syntastic__checkers'| and |'b:syntastic_checkers'| are +ignored, and the checkers named by the command's arguments are run instead, in +the order specified. The rules of |syntastic_aggregate_errors| still apply. + +Example: > + :SyntasticCheck flake8 pylint +< :SyntasticInfo *:SyntasticInfo* -Output info about what checkers are available and in use for the current -filetype. +The command takes an optional argument, and outputs information about the +checkers available for the filetype named by said argument, or for the current +filetype if no argument was provided. :SyntasticReset *:SyntasticReset* Resets the list of errors and turns off all error notifiers. +:SyntasticSetLoclist *:SyntasticSetLoclist* + +If |'syntastic_always_populate_loc_list'| is not set, the |location-list| is +not filled in automatically with the list of errors detected by the checkers. +This is useful if you run syntastic along with other plugins that use location +lists. The |:SyntasticSetLoclist| command allows you to stick the errors into +the location list explicitly. ============================================================================== 4. Global Options *syntastic-global-options* @@ -170,61 +253,64 @@ Resets the list of errors and turns off all error notifiers. 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 + let g:syntastic_check_on_open = 1 < - *'syntastic_check_on_wq'* Default: 1 Normally syntastic runs syntax checks whenever buffers are written to disk. If you want to skip these checks when you issue |:wq|, |:x|, and |:ZZ|, set this variable to 0. > - let g:syntastic_check_on_wq=0 + let g:syntastic_check_on_wq = 0 < - *'syntastic_aggregate_errors'* Default: 0 -When enabled, |:SyntasticCheck| runs all checkers that apply, then aggregates -errors found by all checkers and displays them. When disabled, -|:SyntasticCheck| runs each checker in turn, and stops to display the results -the first time a checker finds any errors. > - let g:syntastic_aggregate_errors=1 +When enabled, syntastic runs all checkers that apply to the current filetype, +then aggregates errors found by all checkers and displays them. When disabled, +syntastic runs each checker in turn, and stops to display the results the first +time a checker finds any errors. > + let g:syntastic_aggregate_errors = 1 +< + *'syntastic_id_checkers'* +Default: 1 +When results from multiple checkers are aggregated in a single error list +(that is either when |syntastic_aggregate_errors| is enabled, or when checking +a file with a composite filetype), it might not be immediately obvious which +checker has produced a given error message. This variable instructs syntastic +to label error messages with the names of the checkers that created them. > + let g:syntastic_id_checkers = 0 < - *'syntastic_echo_current_error'* Default: 1 If enabled, syntastic will echo the error 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 + 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 + let g:syntastic_enable_signs = 1 < - *'syntastic_error_symbol'* *'syntastic_style_error_symbol'* *'syntastic_warning_symbol'* *'syntastic_style_warning_symbol'* Use this option to control what the syntastic |:sign| text contains. Several -error symobls can be customized: +error symbols can be customized: syntastic_error_symbol - For syntax errors, defaults to '>>' syntastic_style_error_symbol - For style errors, defaults to 'S>' syntastic_warning_symbol - For syntax warnings, defaults to '>>' syntastic_style_warning_symbol - For style warnings, defaults to 'S>' Example: > - let g:syntastic_error_symbol='✗' - let g:syntastic_warning_symbol='⚠' + let g:syntastic_error_symbol = '✗' + let g:syntastic_warning_symbol = '⚠' < - *'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|. +Note that Vim must be compiled with |+balloon_eval|. *'syntastic_enable_highlighting'* Default: 1 @@ -232,55 +318,57 @@ 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_always_populate_loc_list'* Default: 0 Enable this option to tell syntastic to always stick any detected errors into -the loclist: > - let g:syntastic_always_populate_loc_list=1 +the |location-list|: > + let g:syntastic_always_populate_loc_list = 1 < *'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 -< +Enable this option if you want the cursor to jump to the first detected issue +when saving or opening a file. +When set to 0 the cursor won't jump automatically. > + let g:syntastic_auto_jump = 0 +< +When set to 1 the cursor will always jump to the first issue detected. > + let g:syntastic_auto_jump = 1 +< +When set to 2 the cursor will jump to the first issue detected, but only if +this issue is an error. > + let g:syntastic_auto_jump = 2 +< *'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 + 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 + 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 + let g:syntastic_auto_loc_list = 2 < - *'syntastic_loc_list_height'* Default: 10 Use this option to specify the height of the location lists that syntastic opens. > - let g:syntastic_loc_list_height=5 + let g:syntastic_loc_list_height = 5 < - *'syntastic_ignore_files'* Default: [] -Use this option to specify files that syntastic should neither check, nor -include in error lists. It has to be a list of |regular-expression| patterns. -The full paths of files (see |::p|) are matched against these patterns, and -the matches are case sensitive. Use |\c| if you need case insensitive -patterns. > - let g:syntastic_ignore_files=['^/usr/include/', '\c\.h$'] +Use this option to specify files that syntastic should never check. It's a +list of |regular-expression| patterns. The full paths of files (see |::p|) are +matched against these patterns, and the matches are case sensitive. Use |\c| +to specify case insensitive patterns. Example: > + let g:syntastic_ignore_files = ['\m^/usr/include/', '\m\c\.h$'] < - *'syntastic_filetype_map'* Default: {} Use this option to map non-standard filetypes to standard ones. Corresponding @@ -289,12 +377,10 @@ non-standard filetypes: > let g:syntastic_filetype_map = { 'latex': 'tex', \ 'gentoo-metadata': 'xml' } < - Composite filetypes can also be mapped to simple types, which disables the default behaviour of running both checkers against the input file: > let g:syntastic_filetype_map = { 'handlebars.html': 'handlebars' } < - *'syntastic_mode_map'* Default: { "mode": "active", "active_filetypes": [], @@ -309,7 +395,6 @@ The option should be set to something like: > \ '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 @@ -327,21 +412,50 @@ 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'* + *'syntastic_quiet_messages'* +Default: {} -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 +Use this option to filter out some of the messages produced by checkers. The +option should be set to something like: > + let g:syntastic_quiet_messages = { "level": "warnings", + \ "type": "style", + \ "regex": '\m\[C03\d\d\]', + \ "file": ['\m^/usr/include/', '\m\c\.h$'] } +< +Each element turns off messages matching the patterns specified by the +corresponding value. Values are lists, but if a list consist of a single +element you can omit adding the brackets (e.g. you can write "style" instead +of ["style"]). Elements with values [] or '' are ignored (this is useful for +overriding filters, cf. |filter-overrides|). + + "level" - takes one of two values, "warnings" or "errors" + "type" - can be either "syntax" or "style" + "regex" - is matched against the messages' text as a case insensitive + |regular-expression| + "file" - is matched against the filename the error refers to, as a case + sensitive |regular-expression|. + +If |'syntastic_id_checkers'| is set, filters are applied before error messages +are labeled with the names of the checkers that created them. + +There are also checker-specific variants of this option, providing finer +control. They are named |'syntastic___quiet_messages'|. + +For a particular checker, if both a |'syntastic_quiet_messages'| filter and +a checker-specific filter are present, they are both applied (to the list of +errors produced by the said checker). In case of conflicting values for the +same keys, the values of the checker-specific filters take precedence. + + *filter-overrides* +Since filter elements with values [] or '' are ignored, you can disable global +filters for particular checkers, by setting the values of the corresponding +elements in |'syntastic___quiet_messages'| to [] or ''. For +example, the following setting will silence all warnings, except for the +ones produced by 'pylint': > + let g:syntastic_quiet_messages = { "level": "warnings" } + let g:syntastic_python_pylint_quiet_messages = { "level" : [] } < - *'syntastic_stl_format'* - Default: [Syntax: line:%F (%t)] Use this option to control what the syntastic statusline text contains. Several magic flags are available to insert information: @@ -357,7 +471,7 @@ Several additional flags are available to hide text under certain conditions: %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. +These flags can't be nested. Example: > let g:syntastic_stl_format = '[%E{Err: %fe #%e}%B{, }%W{Warn: %fw #%w}]' @@ -377,94 +491,129 @@ Changing it can in principle make screen redraws smoother, but it can also cause screen to flicker, or cause ghost characters. Leaving it to the default should be safe. - *'syntastic_delayed_redraws'* -Default: 0 -On older Vims, calling redraw when a popup menu is visible can cause Vim to -segfault. If your version of Vim is affected, the solution is of course to -upgrade Vim. If upgrading is not immediately feasible however, setting this -variable to 1 might help, by delaying redraws until they are safe. - *'syntastic_debug'* Default: 0 -Set this to 1 to enable debugging: > +Set this to the sum of one or more of the following flags to enable +debugging: + + 1 - trace checker calls + 2 - dump location lists + 4 - trace notifiers + 8 - trace autocommands + 16 - dump options + +Example: > let g:syntastic_debug = 1 < -Checkers will then add debugging messages to Vim's |message-history|. You can +Syntastic will then add debugging messages to Vim's |message-history|. You can examine these messages with |:mes|. + *'syntastic_debug_file'* +Default: unset +When set, debugging messages are written to the file named by its value, in +addition to being added to Vim's |message-history|: > + let g:syntastic_debug_file = '~/syntastic.log' +< + *'syntastic_extra_filetypes'* +Default: [] +List of filetypes handled by checkers external to syntastic. If you have a Vim +plugin that adds a checker for syntastic, and if the said checker deals with a +filetype that is unknown to syntastic, you might consider adding that filetype +to this list: > + let g:syntastic_extra_filetypes = [ 'make', 'gitcommit' ] +< +This will allow |:SyntasticInfo| to do proper tab completion for the new +filetypes. ============================================================================== 5. Checker Options *syntastic-checker-options* ------------------------------------------------------------------------------ -5.1 Telling syntastic which checker to use. +5.1 Choosing which checkers to use *syntastic-filetype-checkers* -Stick a line like this in your vimrc: > - let g:syntastic__checkers = [''] -< -e.g. > - let g:syntastic_python_checkers = ['flake8'] + *'g:syntastic__checkers'* +You can tell syntastic which checkers to run for a given filetype by setting a +variable 'g:syntastic__checkers' to a list of checkers, e.g. > + let g:syntastic_php_checkers = ['php', 'phpcs', 'phpmd'] < - -There's also a per-buffer version of this setting, b:syntastic_checkers. Use -this in an autocmd to configure specific checkers for particular paths: > + *'b:syntastic_checkers'* +There is also a per-buffer version of this setting, 'b:syntastic_checkers'. +When set, it takes precedence over |'g:syntastic__checkers'|. You can +use this in an autocmd to configure specific checkers for particular paths: > autocmd FileType python if stridx(expand('%:p'), '/some/path/') == 0 | \ let b:syntastic_checkers = ['pylint'] | endif < +If neither |'g:syntastic__checkers'| nor |'b:syntastic_checkers'| +is set, a default list of checker is used. Beware however that this list +deliberately kept minimal, for performance reasons. -To see the list of available checkers for your filetype, look in -`syntax_checkers//`. The names of the files here correspond to -'' above. +Take a look at the wiki to find out what checkers and filetypes are supported +by syntastic: -e.g. Python has the following checkers: flake8, pyflakes, pylint and a -native python checker. + https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers -Some filetypes, like PHP, have style checkers as well as syntax checkers. These -can be chained together like this: > - let g:syntastic_php_checkers=['php', 'phpcs', 'phpmd']` -< -This is telling syntastic to run the 'php' checker first, and if no errors are -found, run 'phpcs', and then 'phpmd'. +Use |:SyntasticInfo| to see which checkers are available for a given filetype. ------------------------------------------------------------------------------ -5.2 Configuring specific checkers *syntastic-config-makeprg* +5.2 Choosing the executable *syntastic-config-exec* + + *'syntastic___exec'* +The executable used by a checker is normally defined automatically, when the +checkers is registered. You can however override it by setting the variable +'g:syntastic___exec': > + let g:syntastic_ruby_mri_exec = '~/bin/ruby2' +< +------------------------------------------------------------------------------ +5.3 Configuring specific checkers *syntastic-config-makeprg* -Most checkers use the 'syntastic#makeprg#build()' function and provide many -options by default - in fact you can customise every part of the command -that gets called. +Most checkers use the 'makeprgBuild()' function and provide many options by +default - in fact you can customise every part of the command that gets called. -Checkers that use 'syntastic#makeprg#build()' look like this: > - let makeprg = syntastic#makeprg#build({ - \ 'exe': 'ruby', + *'syntastic___