diff --git a/.gitignore b/.gitignore index 6524f395..54c5dfd6 100644 --- a/.gitignore +++ b/.gitignore @@ -3,5 +3,4 @@ sources_non_forked/ack.vim/.netrwhist temp_dirs/yankring_history_v2.txt sources_forked/yankring/doc/tags sources_non_forked/tlib/doc/tags -my_configs.vim tags diff --git a/my_configs.vim b/my_configs.vim new file mode 100644 index 00000000..9c4ee2b6 --- /dev/null +++ b/my_configs.vim @@ -0,0 +1,140 @@ +try + colorscheme zenburn +catch +endtry + +set t_Co=256 +" UltiSnips configuration +function! g:UltiSnips_Complete() + call UltiSnips#ExpandSnippet() + if g:ulti_expand_res == 0 + if pumvisible() + return "\" + else + call UltiSnips#JumpForwards() + if g:ulti_jump_forwards_res == 0 + return "\" + endif + endif + endif + return "" +endfunction + +au BufEnter * exec "inoremap " . g:UltiSnipsExpandTrigger . " =g:UltiSnips_Complete()" +let g:UltiSnipsJumpForwardTrigger="" +let g:UltiSnipsListSnippets="" +" this mapping Enter key to to chose the current highlight item +" and close the selection list, same as other IDEs. +" CONFLICT with some plugins like tpope/Endwise +inoremap pumvisible() ? "\" : "\u\" + +" If you want :UltiSnipsEdit to split your window. +let g:UltiSnipsEditSplit="vertical" +" Trigger configuration. Do not use if you use +" https://github.com/Valloric/YouCompleteMe. +let g:UltiSnipsJumpForwardTrigger="" +let g:UltiSnipsJumpBackwardTrigger="" + +" relative numbers and absolute numbers on current line +set relativenumber +set number + +" Highlight current line +set cursorline + + +" IndentGuides options +let g:indent_guides_auto_colors = 0 +let g:indent_guides_enable_on_vim_startup = 1 +let g:indent_guides_exclude_filetypes = ['help', 'nerdtree'] + +set ts=4 sw=4 et +let g:indent_guides_start_level = 2 +let g:indent_guides_guide_size = 1 + +autocmd VimEnter,Colorscheme * :hi IndentGuidesOdd ctermbg=238 +autocmd VimEnter,Colorscheme * :hi IndentGuidesEven ctermbg=238 + + +" Syntastic configuration +execute pathogen#infect() +let g:syntastic_enable_signs=1 +" let g:syntastic_auto_jump=1 +let g:syntastic_stl_format = '[%E{Err: %fe #%e}%B{, }%W{Warn: %fw #%w}]' + +set statusline+=%#warningmsg# +set statusline+=%{SyntasticStatuslineFlag()} +set statusline+=%* +let g:syntastic_check_on_open = 1 +let g:syntastic_aggregate_errors = 1 +let g:syntastic_python_checkers = ['flake8', 'frosted'] +let g:syntastic_javascript_checkers = ['jshint'] + +" Ropevim configuration +let g:ropevim_autoimport_modules = ["os", "shutil", 'django', 'rest_framework', 'moody365'] + +" Mappings to access buffers (don't use "\p" because a +" delay before pressing "p" would accidentally paste). +" \g : go last-used +nnoremap / :e# + +" No wordwrap +set nowrap + +" NERDTree ignore *.pyc +let NERDTreeIgnore = ['\.pyc$'] + +" Enable TagBar +nmap :TagbarToggle +nmap f :TagbarOpen fj + + +""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" +" => Ag searching and cope displaying +" requires ag.vim - it's much better than vimgrep/grep +""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" +let g:ackprg = 'ag --nogroup --nocolor --column' + +map cc :botright cope +map co ggVGy:tabnew:set syntax=qfpgg +map n :cn +map p :cp + + +" Pymode vim settings + +let g:pymode_trim_whitespaces = 0 +let g:pymode_run = 0 +let g:pymode_lint_checkers = ['mccabe'] +let g:pymode_rope_completion = 0 +let g:pymode_rope_complete_on_dot = 0 +let g:pymode_rope_autoimport_modules = ["os.*","traceback","django.*","lxml.etree","lxml.*", "rest_framework.*"] +let g:pymode_rope_autoimport_import_after_complete = 1 + + +" Remove trailing space on save +fun! StripTrailingWhitespaces() + let l = line(".") + let c = col(".") + %s/\s\+$//e + call cursor(l, c) +endfun +autocmd BufWritePre * :call StripTrailingWhitespaces() + +"Set tabs to spaces +set tabstop=4 +set shiftwidth=4 +set expandtab + +"UltiSnipets in Tagbar +let g:tagbar_type_snippets = { + \ 'ctagstype' : 'snippets', + \ 'kinds' : [ + \ 's:snippets', + \ ] +\ } + +" " Mark the max length line limit +set textwidth=80 +set cc=80 +hi ColorColumn ctermbg=238 diff --git a/sources_non_forked/Minimap~ b/sources_non_forked/Minimap~ new file mode 160000 index 00000000..eb257e53 --- /dev/null +++ b/sources_non_forked/Minimap~ @@ -0,0 +1 @@ +Subproject commit eb257e53f9b99e38eba04040078079c63c708ada diff --git a/sources_non_forked/Syntactic~ b/sources_non_forked/Syntactic~ new file mode 160000 index 00000000..82bff20b --- /dev/null +++ b/sources_non_forked/Syntactic~ @@ -0,0 +1 @@ +Subproject commit 82bff20b0200c3ccb292a9261d565b5bbc609ac2 diff --git a/sources_non_forked/UltiSnips b/sources_non_forked/UltiSnips new file mode 160000 index 00000000..b6d545ec --- /dev/null +++ b/sources_non_forked/UltiSnips @@ -0,0 +1 @@ +Subproject commit b6d545ecdfbfeb991d2555cb61df365e674ba8a9 diff --git a/sources_non_forked/YouCompleteMe b/sources_non_forked/YouCompleteMe new file mode 160000 index 00000000..f054fcfc --- /dev/null +++ b/sources_non_forked/YouCompleteMe @@ -0,0 +1 @@ +Subproject commit f054fcfc0a270c4154a9ac5965126bead5c713b3 diff --git a/sources_non_forked/ag b/sources_non_forked/ag new file mode 160000 index 00000000..d3a00f8a --- /dev/null +++ b/sources_non_forked/ag @@ -0,0 +1 @@ +Subproject commit d3a00f8affb091e7a14eb34f1beb9db9bb57a4bf diff --git a/sources_non_forked/delimitMate b/sources_non_forked/delimitMate new file mode 160000 index 00000000..38487bbe --- /dev/null +++ b/sources_non_forked/delimitMate @@ -0,0 +1 @@ +Subproject commit 38487bbec8ba50834e257940b357de03991fa8f9 diff --git a/sources_non_forked/html5.vim b/sources_non_forked/html5.vim new file mode 160000 index 00000000..b1b184e0 --- /dev/null +++ b/sources_non_forked/html5.vim @@ -0,0 +1 @@ +Subproject commit b1b184e0b395089b5fba122c73fd3f461dcdc08d diff --git a/sources_non_forked/indent-lines~/after/plugin/indentLine.vim b/sources_non_forked/indent-lines~/after/plugin/indentLine.vim new file mode 100644 index 00000000..9a53e9cb --- /dev/null +++ b/sources_non_forked/indent-lines~/after/plugin/indentLine.vim @@ -0,0 +1,169 @@ +" Script Name: indentLine.vim +" Version: 1.0.5 +" Last Change: April 1, 2013 +" Author: Yggdroot +" +" Description: To show the indention levels with thin vertical lines + +"{{{1 global variables +if !has("conceal") || exists("g:indentLine_loaded") + finish +endif +let g:indentLine_loaded = 1 + +" | ¦ ┆ ┊ │ +if !exists("g:indentLine_char") + if &encoding ==? "utf-8" + let g:indentLine_char = "¦" + else + let g:indentLine_char = "|" + endif +endif + +if !exists("g:indentLine_first_char") + if &encoding ==? "utf-8" + let g:indentLine_first_char = "¦" + else + let g:indentLine_first_char = "|" + endif +endif + +if !exists("g:indentLine_indentLevel") + let g:indentLine_indentLevel = 10 +endif + +if !exists("g:indentLine_enabled") + let g:indentLine_enabled = 1 +endif + +if !exists("g:indentLine_fileType") + let g:indentLine_fileType = [] +endif + +if !exists("g:indentLine_fileTypeExclude") + let g:indentLine_fileTypeExclude = [] +endif + +if !exists("g:indentLine_bufNameExclude") + let g:indentLine_bufNameExclude = [] +endif + +if !exists("g:indentLine_showFirstIndentLevel") + let g:indentLine_showFirstIndentLevel = 0 +endif + +if !exists("g:indentLine_maxLines") + let g:indentLine_maxLines = 3000 +endif + +set conceallevel=1 +set concealcursor=inc + +"{{{1 function! InitColor() +function! InitColor() + if !exists("g:indentLine_color_term") + if &bg ==? "light" + let term_color = 249 + else + let term_color = 239 + endif + else + let term_color = g:indentLine_color_term + endif + + if !exists("g:indentLine_color_gui") + if &bg ==? "light" + let gui_color = "Grey70" + else + let gui_color = "Grey30" + endif + else + let gui_color = g:indentLine_color_gui + endif + + exec "hi Conceal ctermfg=" . term_color . " ctermbg=NONE" + exec "hi Conceal guifg=" . gui_color . " guibg=NONE" +endfunction + +"{{{1 function! SetIndentLine() +function! SetIndentLine() + let b:indentLine_enabled = 1 + let space = &l:shiftwidth + + if g:indentLine_showFirstIndentLevel + exec 'syn match IndentLine /^ / containedin=ALL conceal cchar=' . g:indentLine_first_char + endif + + let pattern = line('$') < g:indentLine_maxLines ? 'v' : 'c' + for i in range(space+1, space * g:indentLine_indentLevel + 1, space) + exec 'syn match IndentLine /\%(^\s\+\)\@<=\%'.i.pattern.' / containedin=ALL conceal cchar=' . g:indentLine_char + endfor +endfunction + +"{{{1 function! ResetWidth(...) +function! ResetWidth(...) + if a:0 > 0 + let &l:shiftwidth = a:1 + endif + + if exists("b:indentLine_enabled") + syn clear IndentLine + endif + call SetIndentLine() +endfunction + +"{{{1 function! IndentLinesToggle() +function! IndentLinesToggle() + if !exists("b:indentLine_enabled") + let b:indentLine_enabled = 0 + endif + + if b:indentLine_enabled + let b:indentLine_enabled = 0 + syn clear IndentLine + else + call SetIndentLine() + endif +endfunction + +"{{{1 function! Setup() +function! Setup() + if !getbufvar("%","&hidden") || !exists("b:indentLine_set") + let b:indentLine_set = 1 + + if &ft == "" + call InitColor() + endif + + if index(g:indentLine_fileTypeExclude, &ft) != -1 + return + endif + + if len(g:indentLine_fileType) != 0 && index(g:indentLine_fileType, &ft) == -1 + return + end + + for name in g:indentLine_bufNameExclude + if matchstr(bufname(''), name) == bufname('') + return + endif + endfor + + if !exists("b:indentLine_enabled") + let b:indentLine_enabled = g:indentLine_enabled + endif + + if b:indentLine_enabled + call SetIndentLine() + endif + endif +endfunction + +"{{{1 commands +autocmd BufWinEnter * call Setup() +autocmd BufRead,ColorScheme * call InitColor() + +command! -nargs=? IndentLinesReset call ResetWidth() +command! IndentLinesToggle call IndentLinesToggle() + +" vim:et:ts=4:sw=4:fdm=marker:fmr={{{,}}} diff --git a/sources_non_forked/indent-lines~/doc/indentLine.txt b/sources_non_forked/indent-lines~/doc/indentLine.txt new file mode 100644 index 00000000..0dcac7ea --- /dev/null +++ b/sources_non_forked/indent-lines~/doc/indentLine.txt @@ -0,0 +1,118 @@ +*indentLine.txt* Show vertical lines for indent with conceal feature + +CONTENTS *indentLine-contents* +Introduction |indentLine-introduction| +Config |indentLine-config| +Variables |indentLine-variables| +Commands |indentLine-commands| +FAQ |indentLine-faq| +Changelog |indentLine-changelog| +Credits |indentLine-credits| +============================================================================== +INTRODUCTION *indentLine-introduction* +This plugin is used for displaying thin vertical lines at each indentation +level for code indented with spaces. For code indented with tabs, I think +there is no need to support it, using :set list lcs=tab:\|\ (here is a space) +can achieve it. +============================================================================== +CONFIG *indentLine-config* + +============================================================================== +VARIABLES *indentLine-variables* + +g:indentLine_loaded *g:loaded_indentLine* + Whether load indentLine plugin. + Default value is 0. + +g:indentLine_char *g:indentLine_char* + Specify a character to be used as indent line. + You also can use other characters: + | ¦ ┆ │ + Default value is "|". + +g:indentLine_first_char *g:indentLine_first_char* + Specify a character to be used as indent line + on the first level. + You also can use other characters: + | ¦ ┆ │ + Default value is "|". + +g:indentLine_color_term *g:indentLine_color_term* + Specify terminal vim indent line color. + e.g. let g:indentLine_color_term = 239 + + +g:indentLine_color_gui *g:indentLine_color_gui* + Specify GUI vim indent line color. + e.g. let g:indentLine_color_gui = '#A4E57E' + +g:indentLine_indentLevel *g:indentLine_indentLevel* + Specify how much indent level do you want to use for + indentLine. Most program will not has bigger indent level than + 10. + Default value is 10. + +g:indentLine_showFirstIndentLevel *g:indentLine_showFirstIndentLevel* + Specify whether the first indent level should be shown. + This is useful if you use indentLine in comination with + |listchars| in order to show tabs. + Default value is 0. + +g:indentLine_enabled *g:indentLine_enabled* + Specify whether to enable indentLine plugin by default. + If value is not 0, the plugin is on by default, otherwise off. + Default value is 1. + +g:indentLine_fileType *g:indentLine_fileType* + This variable specify a list of file types. + When opening these types of files, the plugin is enabled by + default. + e.g. let g:indentLine_fileType = ['c', 'cpp'] + Default value is [] which means all file types is supported. + +g:indentLine_fileTypeExclude *g:indentLine_fileTypeExclude* + This variable specify a list of file types. + When opening these types of files, the plugin is disabled by + default. + e.g. let g:indentLine_fileType = ['text', 'sh'] + Default value is [] which means no file types is excluded. + +g:indentLine_bufNameExclude *g:indentLine_bufNameExclude* + This variable specify a list of buffer names, which can be + regular expression. If the buffer's name fall into this list, + the indentLine won't display. + e.g. let g:indentLine_bufNameExclude = ['_.*', 'NERD_tree.*'] + Default value is []. + +g:indentLine_maxLines *g:indentLine_maxLines* + This variable specify a number, when the number of buffer's + lines exceed it, the plugin try to use another pattern to make + the performance better. + Default value is 3000. + +============================================================================== +COMMANDS *indentLine-commands* + +IndentLinesReset [number] + if 'shiftwidth' changes, using this command can redraw the + indentLines. number is optional, it means the width between + two indent level, if ommited, value of 'shiftwidth' is used. + +IndentLinesToggle + toggle the indent lines of the current buffer. +============================================================================== +FAQ *indentLine-faq* + +============================================================================== +CHANGELOG *indentLine-changelog* + +============================================================================== +CREDITS *indentLine-credits* + +Thanks to the following people for suggestions and patches: + +NagatoPain +Salman Halim +Christophe +============================================================================== +vim:tw=78:ts=8:ft=help:norl diff --git a/sources_non_forked/javascript-libraries-syntax.vim b/sources_non_forked/javascript-libraries-syntax.vim new file mode 160000 index 00000000..c3e09cc8 --- /dev/null +++ b/sources_non_forked/javascript-libraries-syntax.vim @@ -0,0 +1 @@ +Subproject commit c3e09cc87417f41047d4b324160ed42277757a4a diff --git a/sources_non_forked/pycomplexity b/sources_non_forked/pycomplexity new file mode 160000 index 00000000..1343a2ed --- /dev/null +++ b/sources_non_forked/pycomplexity @@ -0,0 +1 @@ +Subproject commit 1343a2eddde1b8893c4de2a95cb39b66b3af1822 diff --git a/sources_non_forked/python-mode b/sources_non_forked/python-mode new file mode 160000 index 00000000..b5b03ff1 --- /dev/null +++ b/sources_non_forked/python-mode @@ -0,0 +1 @@ +Subproject commit b5b03ff1810b7a7ce5ea006842fa1033823a14a5 diff --git a/sources_non_forked/ropevim~ b/sources_non_forked/ropevim~ new file mode 160000 index 00000000..af0c98dc --- /dev/null +++ b/sources_non_forked/ropevim~ @@ -0,0 +1 @@ +Subproject commit af0c98dc4dd3efbc9f194e007979e37b2ed74a87 diff --git a/sources_non_forked/syntactic/.gitignore b/sources_non_forked/syntactic/.gitignore new file mode 100644 index 00000000..cc07c931 --- /dev/null +++ b/sources_non_forked/syntactic/.gitignore @@ -0,0 +1,4 @@ +*~ +*.swp +tags +.DS_Store diff --git a/sources_non_forked/syntactic/CONTRIBUTING.md b/sources_non_forked/syntactic/CONTRIBUTING.md new file mode 100644 index 00000000..764ffffc --- /dev/null +++ b/sources_non_forked/syntactic/CONTRIBUTING.md @@ -0,0 +1,49 @@ +# Bug reports / Github issues + +When reporting a bug make sure you search the existing github issues for the +same/similar issues. If you find one, feel free to add a `+1` comment with any +additional information that may help us solve the issue. + +When creating a new issue be sure to state the following: + +* Steps to reproduce the bug. +* The version of vim you are using. +* The version of syntastic you are using. + +For syntax checker bugs also state the version of the checker executable that you are using. + +# Submitting a patch + +* Fork the repo on github +* Make a [topic branch](https://github.com/dchelimsky/rspec/wiki/Topic-Branches#using-topic-branches-when-contributing-patches) and start hacking +* Submit a pull request based off your topic branch + +Small focused patches are preferred. + +Large changes to the code should be discussed with the core team first. Create an issue and explain your plan and see what we say. + +# General style notes + +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. + +# Syntax checker style notes + +The preferred style for error format strings is one "clause" per line. E.g. +(from the coffeelint checker): + +```viml +let errorformat = '%E%f:%l:%c: %trror: %m,' . + \ '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,' . + \ '%W%f(%l): warning: %m,' . + \ '%E%f(%l): SyntaxError: %m,' . + \ '%-Z%p^,' . + \ '%-G%.%#' +``` diff --git a/sources_non_forked/syntactic/LICENCE b/sources_non_forked/syntactic/LICENCE new file mode 100644 index 00000000..8b1a9d81 --- /dev/null +++ b/sources_non_forked/syntactic/LICENCE @@ -0,0 +1,13 @@ + DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE + Version 2, December 2004 + +Copyright (C) 2004 Sam Hocevar + +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. diff --git a/sources_non_forked/syntactic/README.markdown b/sources_non_forked/syntactic/README.markdown new file mode 100644 index 00000000..653bd7c6 --- /dev/null +++ b/sources_non_forked/syntactic/README.markdown @@ -0,0 +1,252 @@ + , + / \,,_ .'| + ,{{| /}}}}/_.' _____________________________________________ + }}}}` '{{' '. / \ + {{{{{ _ ;, \ / Ladies and Gentlemen, \ + ,}}}}}} /o`\ ` ;) | | + {{{{{{ / ( | this is ... | + }}}}}} | \ | | + {{{{{{{{ \ \ | | + }}}}}}}}} '.__ _ | | _____ __ __ _ | + {{{{{{{{ /`._ (_\ / | / ___/__ ______ / /_____ ______/ /_(_)____ | + }}}}}}' | //___/ --=: \__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ | + jgs `{{{{` | '--' | ___/ / /_/ / / / / /_/ /_/ (__ ) /_/ / /__ | + }}}` | /____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/ | + | /____/ | + | / + \_____________________________________________/ + + +- - - +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][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. +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. + + + +## 2\. Installation + +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). + + + + +### 2.1\. Step 1: Install pathogen.vim + +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() +``` + + + +### 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: + +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. + + + + +## 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: 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: +```vim +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 `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: +```vim +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?__ + +A. Stick a line like this in your vimrc: +```vim +let g:syntastic__checkers = [''] +``` + +To see the list of supported checkers for your filetype look at the +[wiki][3]. + +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'] +``` + +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'] +``` + +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?__ + +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][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][3] to see what +options are available. + +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: + +```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/sources_non_forked/syntactic/_assets/screenshot_1.png b/sources_non_forked/syntactic/_assets/screenshot_1.png new file mode 100644 index 00000000..c1b69f4b Binary files /dev/null and b/sources_non_forked/syntactic/_assets/screenshot_1.png differ diff --git a/sources_non_forked/syntactic/autoload/syntastic/c.vim b/sources_non_forked/syntactic/autoload/syntastic/c.vim new file mode 100644 index 00000000..4bd79472 --- /dev/null +++ b/sources_non_forked/syntactic/autoload/syntastic/c.vim @@ -0,0 +1,332 @@ +if exists("g:loaded_syntastic_c_autoload") || !exists("g:loaded_syntastic_plugin") + finish +endif +let g:loaded_syntastic_c_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" Public functions {{{1 + +" convenience function to determine the 'null device' parameter +" based on the current operating system +function! syntastic#c#NullOutput() " {{{2 + let known_os = has('unix') || has('mac') || syntastic#util#isRunningWindows() + return known_os ? '-o ' . syntastic#util#DevNull() : '' +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) " {{{2 + " search in the current file's directory upwards + let config = findfile(a:file, '.;') + if config == '' || !filereadable(config) + return '' + endif + + " convert filename into absolute path + let filepath = fnamemodify(config, ':p:h') + + " try to read config file + try + let lines = readfile(config) + catch /\m^Vim\%((\a\+)\)\=:E48[45]/ + return '' + endtry + + " filter out empty lines and comments + call filter(lines, 'v:val !~ ''\v^(\s*#|$)''') + + " remove leading and trailing spaces + call map(lines, 'substitute(v:val, ''\m^\s\+'', "", "")') + call map(lines, 'substitute(v:val, ''\m\s\+$'', "", "")') + + let parameters = [] + for line in lines + let matches = matchstr(line, '\m\C^\s*-I\s*\zs.\+') + if matches != '' + " this one looks like an absolute path + if match(matches, '\m^\%(/\|\a:\)') != -1 + call add(parameters, '-I' . matches) + else + call add(parameters, '-I' . filepath . syntastic#util#Slash() . matches) + endif + else + call add(parameters, line) + endif + endfor + + return join(map(parameters, 'syntastic#util#shescape(v:val)')) +endfunction " }}}2 + +" GetLocList() for C-like compilers +function! syntastic#c#GetLocList(filetype, subchecker, options) " {{{2 + try + let flags = s:getCflags(a:filetype, a:subchecker, a:options) + catch /\m\C^Syntastic: skip checks$/ + return [] + endtry + + 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 postprocess = s:getCheckerVar('g', a:filetype, a:subchecker, 'remove_include_errors', 0) ? + \ ['filterForeignErrors'] : [] + + " process makeprg + return SyntasticMake({ + \ 'makeprg': makeprg, + \ 'errorformat': errorformat, + \ 'postprocess': postprocess }) +endfunction " }}}2 + +" }}}1 + +" Private functions {{{1 + +" initialize c/cpp syntax checker handlers +function! s:init() " {{{2 + let s:handlers = [] + let s:cflags = {} + + 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/sources_non_forked/syntactic/autoload/syntastic/postprocess.vim b/sources_non_forked/syntactic/autoload/syntastic/postprocess.vim new file mode 100644 index 00000000..1558f0f8 --- /dev/null +++ b/sources_non_forked/syntactic/autoload/syntastic/postprocess.vim @@ -0,0 +1,71 @@ +if exists("g:loaded_syntastic_postprocess_autoload") || !exists("g:loaded_syntastic_plugin") + finish +endif +let g:loaded_syntastic_postprocess_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" 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'] + elseif a:a['lnum'] != a:b['lnum'] + return a:a['lnum'] - a:b['lnum'] + elseif a:a['type'] !=? a:b['type'] + " errors take precedence over warnings + return a:a['type'] ==? 'e' ? -1 : 1 + else + return get(a:a, 'col', 0) - get(a:b, 'col', 0) + endif +endfunction " }}}2 + +" natural sort +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') + endfor + + return a:errors +endfunction " }}}2 + +" remove spurious CR under Cygwin +function! syntastic#postprocess#cygwinRemoveCR(errors) " {{{2 + if has('win32unix') + for e in a:errors + let e['text'] = substitute(e['text'], '\r', '', 'g') + endfor + endif + + return a:errors +endfunction " }}}2 + +" decode XML entities +function! syntastic#postprocess#decodeXMLEntities(errors) " {{{2 + for e in a:errors + let e['text'] = syntastic#util#decodeXMLEntities(e['text']) + endfor + + return a:errors +endfunction " }}}2 + +" filter out errors referencing other files +function! syntastic#postprocess#filterForeignErrors(errors) " {{{2 + return filter(copy(a:errors), 'get(v:val, "bufnr") == ' . bufnr('')) +endfunction " }}}2 + +" }}}1 + +let &cpo = s:save_cpo +unlet s:save_cpo + +" vim: set sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntactic/autoload/syntastic/preprocess.vim b/sources_non_forked/syntactic/autoload/syntastic/preprocess.vim new file mode 100644 index 00000000..f1af35be --- /dev/null +++ b/sources_non_forked/syntactic/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/sources_non_forked/syntactic/autoload/syntastic/util.vim b/sources_non_forked/syntactic/autoload/syntastic/util.vim new file mode 100644 index 00000000..d1dc2618 --- /dev/null +++ b/sources_non_forked/syntactic/autoload/syntastic/util.vim @@ -0,0 +1,262 @@ +if exists('g:loaded_syntastic_util_autoload') || !exists("g:loaded_syntastic_plugin") + finish +endif +let g:loaded_syntastic_util_autoload = 1 + +let s:save_cpo = &cpo +set cpo&vim + +" Public functions {{{1 + +function! syntastic#util#isRunningWindows() " {{{2 + return has('win16') || has('win32') || has('win64') +endfunction " }}}2 + +function! syntastic#util#DevNull() " {{{2 + if syntastic#util#isRunningWindows() + return 'NUL' + endif + return '/dev/null' +endfunction " }}}2 + +" Get directory separator +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 +" +"e.g. +" +"#!/usr/bin/perl -f -bar +" +"returns +" +"{'exe': '/usr/bin/perl', 'args': ['-f', '-bar']} +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 } + endif + endfor + + 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) " {{{2 + return split(matchstr( a:version, '\v^\D*\zs\d+(\.\d+)+\ze' ), '\m\.') +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) " {{{2 + return syntastic#util#parseVersion(system(a:command)) +endfunction " }}}2 + +" Verify that the 'installed' version is at least the 'required' version. +" +" 'installed' and 'required' must be arrays. If they have different lengths, +" 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) " {{{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 " }}}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) " {{{2 + let old_ruler = &ruler + let old_showcmd = &showcmd + + "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") + + "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 " }}}2 + +" Check whether a buffer is loaded, listed, and not hidden +function! syntastic#util#bufIsActive(buffer) " {{{2 + " convert to number, or hell breaks loose + let buf = str2nr(a:buffer) + + if !bufloaded(buf) || !buflisted(buf) + return 0 + endif + + " get rid of hidden buffers + for tab in range(1, tabpagenr('$')) + if index(tabpagebuflist(tab), buf) >= 0 + return 1 + endif + endfor + + return 0 +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) " {{{2 + let here = fnamemodify(a:where, ':p') + + 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 ==? 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 " }}}2 + +" Returns unique elements in a list +function! syntastic#util#unique(list) " {{{2 + let seen = {} + let uniques = [] + for e in a:list + if !has_key(seen, e) + let seen[e] = 1 + call add(uniques, e) + endif + endfor + return uniques +endfunction " }}}2 + +" A less noisy shellescape() +function! syntastic#util#shescape(string) " {{{2 + return a:string =~ '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string) +endfunction " }}}2 + +" A less noisy shellescape(expand()) +function! syntastic#util#shexpand(string) " {{{2 + return syntastic#util#shescape(expand(a:string)) +endfunction " }}}2 + +" decode XML entities +function! syntastic#util#decodeXMLEntities(string) " {{{2 + let str = a:string + let str = substitute(str, '\m<', '<', 'g') + let str = substitute(str, '\m>', '>', 'g') + let str = substitute(str, '\m"', '"', 'g') + let str = substitute(str, '\m'', "'", 'g') + let str = substitute(str, '\m&', '\&', 'g') + return str +endfunction " }}}2 + +function! syntastic#util#redraw(full) " {{{2 + if a:full + redraw! + else + redraw + endif +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 sw=4 sts=4 et fdm=marker: diff --git a/sources_non_forked/syntactic/doc/syntastic.txt b/sources_non_forked/syntactic/doc/syntastic.txt new file mode 100644 index 00000000..86a5ed2b --- /dev/null +++ b/sources_non_forked/syntactic/doc/syntastic.txt @@ -0,0 +1,684 @@ +*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| + 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| + + +============================================================================== +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. 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. + +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'| 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 +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 + * Erroneous parts of lines can be highlighted (this functionality is only + 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* + +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. + +Signs are colored using the Error and Todo syntax highlight groups by default. +If you wish to customize the colors for the signs, you can use the following +groups: + SyntasticErrorSign - For syntax errors, links to 'error' by default + SyntasticWarningSign - For syntax warnings, links to 'todo' by default + SyntasticStyleErrorSign - For style errors, links to 'SyntasticErrorSign' + by default + SyntasticStyleWarningSign - For style warnings, links to + 'SyntasticWarningSign' by default + +Example: > + highlight SyntasticErrorSign guifg=white guibg=red +< +To set up highlighting for the line where a sign resides, you can use the +following highlight groups: + SyntasticErrorLine + SyntasticWarningLine + SyntasticStyleErrorLine - Links to 'SyntasticErrorLine' by default + SyntasticStyleWarningLine - Links to 'SyntasticWarningLine' by default + +Example: > + highlight SyntasticErrorLine guibg=#2f0000 +< +------------------------------------------------------------------------------ +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. + +------------------------------------------------------------------------------ +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* + +: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. 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* + +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* + + + *'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_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 +< + *'syntastic_aggregate_errors'* +Default: 0 +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 +< + *'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_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 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 = '⚠' +< + *'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_always_populate_loc_list'* +Default: 0 +Enable this option to tell syntastic to always stick any detected errors into +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 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 +< +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_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 +< + *'syntastic_ignore_files'* +Default: [] +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 +checkers are mapped accordingly, which allows syntastic to check files with +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": [], + "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_messages'* +Default: {} + +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: + %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 can't 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] +< + *'syntastic_full_redraws'* +Default: 0 in GUI Vim and MacVim, 1 otherwise +Controls whether syntastic calls |:redraw| or |:redraw!| for screen redraws. +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_debug'* +Default: 0 +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 +< +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 Choosing which checkers to use *syntastic-filetype-checkers* + + *'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'] +< + *'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. + +Take a look at the wiki to find out what checkers and filetypes are supported +by syntastic: + + https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers + +Use |:SyntasticInfo| to see which checkers are available for a given filetype. + +------------------------------------------------------------------------------ +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 'makeprgBuild()' function and provide many options by +default - in fact you can customise every part of the command that gets called. + + *'syntastic___