Merge branch 'master' of https://github.com/BontaVlad/vimrc-1 into MO-63

README.md

@@ -81,6 +81,7 @@ I recommend reading the docs of these plugins to understand them better. Each of
 * [goyo.vim](https://github.com/junegunn/goyo.vim) and [vim-zenroom2](https://github.com/amix/vim-zenroom2): 
 Remove all clutter and focus only on the essential. Similar to iA Writer or Write Room [Read more here](http://amix.dk/blog/post/19744)
 * [vim-commentary](https://github.com/tpope/vim-commentary): Comment stuff out.  Use `gcc` to comment out a line (takes a count), `gc` to comment out the target of a motion. `gcu` uncomments a set of adjacent commented lines.
+* [syntastic](https://github.com/scrooloose/syntastic): Syntax checking hacks for vim
 
 
 ## Included color schemes

sources_non_forked/ack.vim/README.md

@@ -1,101 +1,60 @@
-# ack.vim #
+# ack.vim
 
 This plugin is a front for the Perl module
 [App::Ack](http://search.cpan.org/~petdance/ack/ack).  Ack can be used as a
 replacement for 99% of the uses of _grep_.  This plugin will allow you to run
 ack from vim, and shows the results in a split window.
 
-The *Official Version* of this plugin is available at [vim.org](http://www.vim.org/scripts/script.php?script_id=2572).
-
-## Installation ##
-
+## Installation
 
 ### Ack
 
-You have to install [ack](http://betterthangrep.com/), of course.
-
-Install on Debian / Ubuntu with:
-
-    sudo apt-get install ack-grep
-
-Install on Fedora with:
-
-    su -l -c 'yum install ack'
-
-Install on openSUSE with:
-
-    sudo zypper install ack
-
-Install on Gentoo with:
-
-    sudo emerge ack
-
-Install with Homebrew:
-
-    brew install ack
-
-Install with MacPorts:
-
-    sudo port install p5-app-ack
-
-Install with Gentoo Prefix:
-
-    emerge ack
-
-Install on FreeBSD with:
-
-    cd /usr/ports/textproc/p5-ack/ && make install clean
-
-You can specify a custom ack name and path in your .vimrc like so:
-
-    let g:ackprg="<custom-ack-path-goes-here> -H --nocolor --nogroup --column"
-
-Otherwise, you are on your own.
+You will need the ack(>= 2.0), of course, to install it follow the
+[manual](http://beyondgrep.com/install/)
 
 ### The Plugin
 
-If you have [Rake](http://rake.rubyforge.org/) installed, you can just run: `rake install`.
+To install it is recommended to use one of the popular package managers for Vim,
+rather than installing by drag and drop all required files into your `.vim` folder.
 
-Otherwise, the file ack.vim goes in ~/.vim/plugin, and the ack.txt file belongs in ~/.vim/doc.  Be sure to run
+#### Manual (not recommended)
 
-    :helptags ~/.vim/doc
+Just
+[download](https://github.com/mileszs/ack.vim/archive/kb-improve-readme.zip) the
+plugin and put it in your `~/.vim/`(or `%PROGRAMFILES%/Vim/vimfiles` on windows)
 
-afterwards.
+#### Vundle
 
+    Bundle 'mileszs/ack.vim'
 
-## Usage ##
+#### NeoBundle
 
-    :Ack [options] {pattern} [{directory}]
+    NeoBundle 'mileszs/ack.vim'
 
-Search recursively in {directory} (which defaults to the current directory) for the {pattern}.
+## Usage
+
+    :Ack [options] {pattern} [{directories}]
+
+Search recursively in {directory} (which defaults to the current directory) for
+the {pattern}.
 
 Files containing the search term will be listed in the split window, along with
 the line number of the occurrence, once for each occurrence.  [Enter] on a line
 in this window will open the file, and place the cursor on the matching line.
 
-Just like where you use :grep, :grepadd, :lgrep, and :lgrepadd, you can use `:Ack`, `:AckAdd`, `:LAck`, and `:LAckAdd` respectively. (See `doc/ack.txt`, or install and `:h Ack` for more information.)
+Just like where you use :grep, :grepadd, :lgrep, and :lgrepadd, you can use
+`:Ack`, `:AckAdd`, `:LAck`, and `:LAckAdd` respectively.
+(See `doc/ack.txt`, or install and `:h Ack` for more information.)
 
-**From the [ack docs](http://betterthangrep.com/)** (my favorite feature):
+For more ack options see
+[ack documentation](http://beyondgrep.com/documentation/)
 
-    --type=TYPE, --type=noTYPE
-
-        Specify the types of files to include or exclude from a search. TYPE is a filetype, like perl or xml. --type=perl can also be specified as --perl, and --type=noperl can be done as --noperl.
-
-        If a file is of both type "foo" and "bar", specifying --foo and --nobar will exclude the file, because an exclusion takes precedence over an inclusion.
-
-        Type specifications can be repeated and are ORed together.
-
-        See ack --help=types for a list of valid types.
-
-### Gotchas ###
-
-Some characters have special meaning, and need to be escaped your search pattern. For instance, '#'. You have to escape it like this `:Ack '\\\#define foo'` to search for `#define foo`. (From [blueyed in issue #5](https://github.com/mileszs/ack.vim/issues/5).)
-
-### Keyboard Shortcuts ###
+### Keyboard Shortcuts
 
 In the quickfix window, you can use:
 
     o    to open (same as enter)
+    O    to open and close quickfix window
     go   to preview file (open but maintain focus on ack.vim results)
     t    to open in new tab
     T    to open in new tab silently
@@ -106,9 +65,67 @@ In the quickfix window, you can use:
     q    to close the quickfix window
 
 This Vim plugin is derived (and by derived, I mean copied, essentially) from
-Antoine Imbert's blog post [Ack and Vim
-Integration](http://blog.ant0ine.com/typepad/2007/03/ack-and-vim-integration.html) (in
-particular, the function at the bottom of the post).  I added a help file that
+Antoine Imbert's blog post
+[Ack and Vim Integration](http://blog.ant0ine.com/typepad/2007/03/ack-and-vim-integration.html)
+(in particular, the function at the bottom of the post).  I added a help file that
 provides just enough reference to get you going.  I also highly recommend you
-check out the docs for the Perl script 'ack', for obvious reasons: [ack -
-grep-like text finder](http://betterthangrep.com/).
+check out the docs for the Perl script 'ack', for obvious reasons:
+[ack - grep-like text finder](http://beyondgrep.com/).
+
+### Gotchas
+
+Some characters have special meaning, and need to be escaped your search
+pattern. For instance, '#'. You have to escape it like this `:Ack '\\\#define
+foo'` to search for '#define foo'. (From blueyed in issue #5.)
+
+## Changelog
+
+### 1.0
+
+* Remove support to ack 1.x
+* Start to use a Changelog
+* Use `autoload` directory to define functions, instead of `plugin`.
+* Add option to auto fold the results(`g:ack_autofold_results`)
+* Improve documentation, list all options and shortcuts
+* Improve highlight option to work when passes directories or use quotes.
+* Add g:ack_mapping
+* Add g:ack_default_options
+* Add a help toggle `?`(like NERDTree)
+
+### 1.0.1
+
+* Fixes #124. Bug with `g:ack_autofold_results`
+
+### 1.0.2
+
+* Add compatibility with [vim-dispatch](https://github.com/tpope/vim-dispatch)
+
+### 1.0.3
+
+* Fixes #127. Use `&l:hlsearch` instead of `v:hlsearch` to keep compatibility
+with versions that does not have this variable.
+
+### 1.0.4
+
+* Fixes #128. Always apply mappings, even when using vim-dispatch.
+
+### 1.0.5
+
+* Fixes #128. Fixes the `errorformat` for ack when using vim-dispatch.
+* Do not use vim-dispatch by default. To use vim-dispath must set
+`g:ack_use_dispatch`
+
+### 1.0.6
+
+* Fixes highlight function to work when user passes options. Ex.: Ack -i test
+  Thank's @mannih. (#131, #134)
+
+### 1.0.7
+
+* Fixes highlight function to work when passes more than one option, or options
+with double dashes(--option) Thank's to @MiguelLatorre and @mannih
+
+### 1.0.8
+
+* Fixes (again) highlight, now using negative look behind.
+* Change mappings `o` and `O` to behave as documented

sources_non_forked/ack.vim/Rakefile

@@ -1,23 +0,0 @@
-# Added by Josh Nichols, a.k.a. technicalpickles
-require 'rake'
-
-files = ['doc/ack.txt', 'plugin/ack.vim']
-
-desc 'Install plugin and documentation'
-task :install do
-  vimfiles = if ENV['VIMFILES']
-               ENV['VIMFILES']
-             elsif RUBY_PLATFORM =~ /(win|w)32$/
-               File.expand_path("~/vimfiles")
-             else
-               File.expand_path("~/.vim")
-             end
-  files.each do |file|
-    target_file = File.join(vimfiles, file)
-    FileUtils.mkdir_p File.dirname(target_file)
-    FileUtils.cp file, target_file
-
-    puts "  Copied #{file} to #{target_file}"
-  end
-
-end

sources_non_forked/ack.vim/autoload/ack.vim

@@ -0,0 +1,154 @@
+function! ack#Ack(cmd, args)
+  redraw
+  echo "Searching ..."
+
+  " If no pattern is provided, search for the word under the cursor
+  if empty(a:args)
+    let l:grepargs = expand("<cword>")
+  else
+    let l:grepargs = a:args . join(a:000, ' ')
+  end
+  echom l:grepargs
+  let l:ackprg_run = g:ackprg
+
+  " Format, used to manage column jump
+  if a:cmd =~# '-g$'
+    let g:ackformat="%f"
+    let l:ackprg_run = substitute(l:ackprg_run, '-H\|--column', '', 'g')
+  else
+    let g:ackformat="%f:%l:%c:%m,%f:%l:%m"
+  endif
+
+  let grepprg_bak = &grepprg
+  let grepformat_bak = &grepformat
+  let &grepprg=l:ackprg_run
+  let &grepformat=g:ackformat
+
+  try
+    " NOTE: we escape special chars, but not everything using shellescape to
+    "       allow for passing arguments etc
+    if g:ack_use_dispatch
+      let &l:errorformat = g:ackformat
+      let &l:makeprg=g:ackprg." " . escape(l:grepargs, '|#%')
+      Make
+    else
+      silent execute a:cmd . " " . escape(l:grepargs, '|#%')
+    endif
+
+  finally
+    let &grepprg=grepprg_bak
+    let &grepformat=grepformat_bak
+  endtry
+
+  if a:cmd =~# '^l'
+    let s:handler = g:ack_lhandler
+    let s:apply_mappings = g:ack_apply_lmappings
+    let s:close_cmd = ':lclose<CR>'
+  else
+    let s:handler = g:ack_qhandler
+    let s:apply_mappings = g:ack_apply_qmappings
+    let s:close_cmd = ':cclose<CR>'
+  endif
+
+  if !g:ack_use_dispatch
+    call ack#show_results()
+  else
+    copen
+  endif
+  call <SID>apply_maps()
+  call <SID>highlight(l:grepargs)
+
+  redraw!
+endfunction
+
+function! ack#show_results()
+  execute s:handler
+endfunction
+
+function! s:apply_maps()
+  let g:ack_mappings.q = s:close_cmd
+
+  execute "nnoremap <buffer> <silent> ? :call ack#quick_help()<CR>"
+
+  if s:apply_mappings && &ft == "qf"
+    if g:ack_autoclose
+      for key_map in items(g:ack_mappings)
+        execute printf("nnoremap <buffer> <silent> %s %s", get(key_map, 0), get(key_map, 1) . s:close_cmd)
+      endfor
+      execute "nnoremap <buffer> <silent> <CR> <CR>" . s:close_cmd
+    else
+      for key_map in items(g:ack_mappings)
+        execute printf("nnoremap <buffer> <silent> %s %s", get(key_map, 0), get(key_map, 1))
+      endfor
+    endif
+
+    if exists("g:ackpreview") " if auto preview in on, remap j and k keys
+      execute "nnoremap <buffer> <silent> j j<CR><C-W><C-W>"
+      execute "nnoremap <buffer> <silent> k k<CR><C-W><C-W>"
+    endif
+  endif
+endfunction
+
+function! ack#quick_help()
+  execute "edit " . globpath(&rtp, "doc/ack_quick_help.txt")
+
+  silent normal gg
+  setlocal buftype=nofile
+  setlocal bufhidden=hide
+  setlocal noswapfile
+  setlocal nobuflisted
+  setlocal nomodifiable
+  setlocal filetype=help
+  setlocal nonumber
+  setlocal norelativenumber
+  setlocal nowrap
+  setlocal foldlevel=20
+  setlocal foldmethod=diff
+  nnoremap <buffer> <silent> ? :q!<CR>:call ack#show_results()<CR>
+endfunction
+
+function! s:highlight(args)
+  if !g:ackhighlight
+    return
+  endif
+
+  let @/ = matchstr(a:args, "\\v(-)\@<!(\<)\@<=\\w+|['\"]\\zs.{-}\\ze['\"]")
+  call feedkeys(":let &l:hlsearch=1 \| echo \<CR>", "n")
+endfunction
+
+function! ack#AckFromSearch(cmd, args)
+  let search = getreg('/')
+  " translate vim regular expression to perl regular expression.
+  let search = substitute(search, '\(\\<\|\\>\)', '\\b', 'g')
+  call ack#Ack(a:cmd, '"' . search . '" ' . a:args)
+endfunction
+
+function! s:GetDocLocations()
+  let dp = ''
+  for p in split(&rtp, ',')
+    let p = p . '/doc/'
+    if isdirectory(p)
+      let dp = p . '*.txt ' . dp
+    endif
+  endfor
+
+  return dp
+endfunction
+
+function! ack#AckHelp(cmd, args)
+  let args = a:args . ' ' . s:GetDocLocations()
+  call ack#Ack(a:cmd, args)
+endfunction
+
+function! ack#AckWindow(cmd, args)
+  let files = tabpagebuflist()
+  " remove duplicated filenames (files appearing in more than one window)
+  let files = filter(copy(sort(files)), 'index(files,v:val,v:key+1)==-1')
+  call map(files, "bufname(v:val)")
+  " remove unnamed buffers as quickfix (empty strings before shellescape)
+  call filter(files, 'v:val != ""')
+  " expand to full path (avoid problems with cd/lcd in au QuickFixCmdPre)
+  let files = map(files, "shellescape(fnamemodify(v:val, ':p'))")
+  let args = a:args . ' ' . join(files)
+  call ack#Ack(a:cmd, args)
+endfunction

sources_non_forked/ack.vim/doc/ack.txt

@@ -16,7 +16,7 @@ shows the results in a split window.
     Search recursively in {directory} (which defaults to the current
     directory) for the {pattern}.  Behaves just like the |:grep| command, but
     will open the |Quickfix| window for you. If [!] is not given the first
-    error is jumped to.
+    occurence is jumped to.
 
 :AckAdd [options] {pattern} [{directory}]                            *:AckAdd*
 
@@ -53,6 +53,16 @@ shows the results in a split window.
     Just like |:AckHelp| but instead of the |quickfix| list, matches are placed
     in the current |location-list|.
 
+:AckWindow[!] [options] {pattern}                                 *:AckWindow*
+
+    Search all buffers visible in the screen (current tab page only) files for
+    the {pattern}.
+
+:LAckWindow [options] {pattern}                                   *:LAckWindow*
+
+    Just like |:AckWindow| but instead of the |quickfix| list, matches are
+    placed in the current |location-list|.
+
 Files containing the search term will be listed in the split window, along
 with the line number of the occurrence, once for each occurrence.  <Enter> on
 a line in this window will open the file, and place the cursor on the matching
@@ -60,6 +70,151 @@ line.
 
 See http://betterthangrep.com/ for more information.
 
+
+==============================================================================
+CONFIGURATION                                              *ack-configuration*
+
+                                                                    *g:ackprg*
+g:ackprg
+Default for ubuntu: "ack-grep"
+Default for other systems: "ack"
+
+Use this option to specify the ack command and its options
+
+Example:
+>
+        let g:ackprg = "other-bin-ack"
+<
+
+                                                       *g:ack_default_options*
+g:ack_default_options
+Default: " -s -H --nocolor --nogroup --column"
+
+Use this option to specify the options used by ack
+
+Example:
+>
+        let g:ack_default_options =
+              \ " -s -H --nocolor --nogroup --column --smart-case --follow"
+<
+
+                                                       *g:ack_apply_qmappings*
+g:ack_apply_qmappings
+Default: 1
+
+This option enable mappings on quickview window.
+
+                                                       *g:ack_apply_lmappings*
+g:ack_apply_lmappings
+Default: 1
+
+This option enable mappings on Location list window.
+
+                                                              *g:ack_mappings*
+g:ack_mappings
+Default: {
+      \ "t": "<C-W><CR><C-W>T",
+      \ "T": "<C-W><CR><C-W>TgT<C-W>j",
+      \ "o": "<CR>",
+      \ "O": "<CR><C-W><C-W>:ccl<CR>",
+      \ "go": "<CR><C-W>j",
+      \ "h": "<C-W><CR><C-W>K",
+      \ "H": "<C-W><CR><C-W>K<C-W>b",
+      \ "v": "<C-W><CR><C-W>H<C-W>b<C-W>J<C-W>t",
+      \ "gv": "<C-W><CR><C-W>H<C-W>b<C-W>J" }
+
+This option list all maps create on quickfix/Location list window.
+
+Example, if you want to open the result in the middle of the screen:
+>
+        let g:ack_mappings = { "o": "<CR>zz" }
+<
+
+                                                              *g:ack_qhandler*
+g:ack_qhandler
+Default: "botright copen"
+
+Command to open the quickview window.
+
+If you want to open a quickview window with 30 lines you can do:
+>
+        let g:ack_qhandler = "botright copen 30"
+<
+
+                                                              *g:ack_lhandler*
+g:ack_lhandler
+Default: "botright lopen"
+
+Command to open the Location list window.
+
+If you want to open a Location list window with 30 lines you can do:
+>
+        let g:ack_lhandler = "botright lopen 30"
+<
+
+                                                              *g:ackhighlight*
+
+g:ackhighlight
+Default: 0
+
+Use this option to highlight the searched term.
+
+Example:
+>
+        let g:ackhighlight = 1
+<
+
+                                                             *g:ack_autoclose*
+g:ack_autoclose
+Default: 0
+
+Use this option to specify whether to close the quickfix window after
+using any of the shortcuts.
+
+Example:
+>
+        let g:ack_autoclose = 1
+<
+
+                                                      *g:ack_autofold_results*
+
+g:ack_autofold_results
+Default: 0
+
+Use this option to fold the results in quickfix by file name. Only the current
+fold will be open by default and while you press 'j' and 'k' to move between the
+results if you hit other fold the last one will be closed and the current will
+be open.
+
+Example:
+>
+        let g:ack_autofold_results = 1
+<
+
+                                                                *g:ackpreview*
+
+g:ackpreview
+Default: 0
+
+Use this option to automagically open the file with 'j' or 'k'.
+
+Example:
+>
+        let g:ackpreview = 1
+<
+
+                                                          *g:ack_use_dispatch*
+
+g:ack_use_dispatch
+Default: 0
+
+Use this option to use vim-dispatch to search the results in background
+
+Example:
+>
+        let g:ack_use_dispatch = 1
+<
+
 ==============================================================================
 MAPPINGS                                                        *ack-mappings*
 
@@ -67,6 +222,8 @@ The following keyboard shortcuts are available in the quickfix window:
 
 o                   open file (same as enter).
 
+O                   open file and close quickfix window.
+
 go                  preview file (open but maintain focus on ack.vim results).
 
 t                   open in a new tab.

sources_non_forked/ack.vim/doc/ack_quick_help.txt

@@ -0,0 +1,14 @@
+====  ack.vim quick help ===============
+
+  *?:*  Show this help
+  *t:*  Open in a new tab
+  *T:*  Open in a new tab silently
+  *o:*  Open
+  *O:*  Open and close result window
+ *go:*  Preview
+  *h:*  Horizontal open
+  *H:*  Horizontal open silently
+  *v:*  Vertical open
+ *gv:*  Vertical open silently
+
+========================================

sources_non_forked/ack.vim/ftplugin/qf.vim

@@ -0,0 +1,9 @@
+if exists("g:ack_autofold_results") && g:ack_autofold_results
+  setlocal foldlevel=0
+  setlocal foldmethod=expr
+  setlocal foldexpr=matchstr(getline(v:lnum),'^[^\|]\\+')==#matchstr(getline(v:lnum+1),'^[^\|]\\+')?1:'<1'
+  setlocal foldenable
+  setlocal foldclose=all
+  setlocal foldopen=all
+  nnoremap <buffer> j jzz
+endif

sources_non_forked/ack.vim/plugin/ack.vim

@@ -1,16 +1,17 @@
-" NOTE: You must, of course, install the ack script
-"       in your path.
-" On Debian / Ubuntu:
-"   sudo apt-get install ack-grep
-" With MacPorts:
-"   sudo port install p5-app-ack
-" With Homebrew:
-"   brew install ack
+if !exists("g:ack_default_options")
+  let g:ack_default_options = " -s -H --nocolor --nogroup --column"
+endif
 
 " Location of the ack utility
 if !exists("g:ackprg")
-  let s:ackcommand = executable('ack-grep') ? 'ack-grep' : 'ack'
-  let g:ackprg=s:ackcommand." -H --nocolor --nogroup --column"
+  if executable('ack')
+    let g:ackprg = "ack"
+  elseif executable('ack-grep')
+    let g:ackprg = "ack-grep"
+  else
+    finish
+  endif
+  let g:ackprg .= g:ack_default_options
 endif
 
 if !exists("g:ack_apply_qmappings")
@@ -21,102 +22,54 @@ if !exists("g:ack_apply_lmappings")
   let g:ack_apply_lmappings = !exists("g:ack_lhandler")
 endif
 
+if !exists("g:ack_use_dispatch")
+  let g:ack_use_dispatch = 0
+end
+
+let s:ack_mappings = {
+      \ "t": "<C-W><CR><C-W>T",
+      \ "T": "<C-W><CR><C-W>TgT<C-W>j",
+      \ "o": "<CR>",
+      \ "O": "<CR><C-W>p<C-W>c",
+      \ "go": "<CR><C-W>p",
+      \ "h": "<C-W><CR><C-W>K",
+      \ "H": "<C-W><CR><C-W>K<C-W>b",
+      \ "v": "<C-W><CR><C-W>H<C-W>b<C-W>J<C-W>t",
+      \ "gv": "<C-W><CR><C-W>H<C-W>b<C-W>J" }
+
+if exists("g:ack_mappings")
+  let g:ack_mappings = extend(s:ack_mappings, g:ack_mappings)
+else
+  let g:ack_mappings = s:ack_mappings
+endif
+
 if !exists("g:ack_qhandler")
-  let g:ack_qhandler="botright copen"
+  let g:ack_qhandler = "botright copen"
 endif
 
 if !exists("g:ack_lhandler")
-  let g:ack_lhandler="botright lopen"
+  let g:ack_lhandler = "botright lopen"
 endif
 
-function! s:Ack(cmd, args)
-  redraw
-  echo "Searching ..."
+if !exists("g:ackhighlight")
+  let g:ackhighlight = 0
+endif
 
-  " If no pattern is provided, search for the word under the cursor
-  if empty(a:args)
-    let l:grepargs = expand("<cword>")
-  else
-    let l:grepargs = a:args . join(a:000, ' ')
-  end
+if !exists("g:ack_autoclose")
+  let g:ack_autoclose = 0
+endif
 
-  " Format, used to manage column jump
-  if a:cmd =~# '-g$'
-    let g:ackformat="%f"
-  else
-    let g:ackformat="%f:%l:%c:%m,%f:%l:%m"
-  end
+if !exists("g:ack_autofold_results")
+  let g:ack_autofold_results = 0
+endif
 
-  let grepprg_bak=&grepprg
-  let grepformat_bak=&grepformat
-  try
-    let &grepprg=g:ackprg
-    let &grepformat=g:ackformat
-    silent execute a:cmd . " " . escape(l:grepargs, '|')
-  finally
-    let &grepprg=grepprg_bak
-    let &grepformat=grepformat_bak
-  endtry
-
-  if a:cmd =~# '^l'
-    exe g:ack_lhandler
-    let l:apply_mappings = g:ack_apply_lmappings
-    let l:close_cmd = ':lclose<CR>'
-  else
-    exe g:ack_qhandler
-    let l:apply_mappings = g:ack_apply_qmappings
-    let l:close_cmd = ':cclose<CR>'
-  endif
-
-  if l:apply_mappings
-    exec "nnoremap <silent> <buffer> q " . l:close_cmd
-    exec "nnoremap <silent> <buffer> t <C-W><CR><C-W>T"
-    exec "nnoremap <silent> <buffer> T <C-W><CR><C-W>TgT<C-W><C-W>"
-    exec "nnoremap <silent> <buffer> o <CR>"
-    exec "nnoremap <silent> <buffer> go <CR><C-W><C-W>"
-    exec "nnoremap <silent> <buffer> h <C-W><CR><C-W>K"
-    exec "nnoremap <silent> <buffer> H <C-W><CR><C-W>K<C-W>b"
-    exec "nnoremap <silent> <buffer> v <C-W><CR><C-W>H<C-W>b<C-W>J<C-W>t"
-    exec "nnoremap <silent> <buffer> gv <C-W><CR><C-W>H<C-W>b<C-W>J"
-  endif
-
-  " If highlighting is on, highlight the search keyword.
-  if exists("g:ackhighlight")
-    let @/ = substitute(l:grepargs,'["'']','','g')
-    set hlsearch
-  end
-
-  redraw!
-endfunction
-
-function! s:AckFromSearch(cmd, args)
-  let search =  getreg('/')
-  " translate vim regular expression to perl regular expression.
-  let search = substitute(search,'\(\\<\|\\>\)','\\b','g')
-  call s:Ack(a:cmd, '"' .  search .'" '. a:args)
-endfunction
-
-function! s:GetDocLocations()
-    let dp = ''
-    for p in split(&rtp,',')
-        let p = p.'/doc/'
-        if isdirectory(p)
-            let dp = p.'*.txt '.dp
-        endif
-    endfor
-    return dp
-endfunction
-
-function! s:AckHelp(cmd,args)
-    let args = a:args.' '.s:GetDocLocations()
-    call s:Ack(a:cmd,args)
-endfunction
-
-command! -bang -nargs=* -complete=file Ack call s:Ack('grep<bang>',<q-args>)
-command! -bang -nargs=* -complete=file AckAdd call s:Ack('grepadd<bang>', <q-args>)
-command! -bang -nargs=* -complete=file AckFromSearch call s:AckFromSearch('grep<bang>', <q-args>)
-command! -bang -nargs=* -complete=file LAck call s:Ack('lgrep<bang>', <q-args>)
-command! -bang -nargs=* -complete=file LAckAdd call s:Ack('lgrepadd<bang>', <q-args>)
-command! -bang -nargs=* -complete=file AckFile call s:Ack('grep<bang> -g', <q-args>)
-command! -bang -nargs=* -complete=help AckHelp call s:AckHelp('grep<bang>',<q-args>)
-command! -bang -nargs=* -complete=help LAckHelp call s:AckHelp('lgrep<bang>',<q-args>)
+command! -bang -nargs=* -complete=file Ack           call ack#Ack('grep<bang>', <q-args>)
+command! -bang -nargs=* -complete=file AckAdd        call ack#Ack('grepadd<bang>', <q-args>)
+command! -bang -nargs=* -complete=file AckFromSearch call ack#AckFromSearch('grep<bang>', <q-args>)
+command! -bang -nargs=* -complete=file LAck          call ack#Ack('lgrep<bang>', <q-args>)
+command! -bang -nargs=* -complete=file LAckAdd       call ack#Ack('lgrepadd<bang>', <q-args>)
+command! -bang -nargs=* -complete=file AckFile       call ack#Ack('grep<bang> -g', <q-args>)
+command! -bang -nargs=* -complete=help AckHelp       call ack#AckHelp('grep<bang>', <q-args>)
+command! -bang -nargs=* -complete=help LAckHelp      call ack#AckHelp('lgrep<bang>', <q-args>)
+command! -bang -nargs=* -complete=help AckWindow     call ack#AckWindow('grep<bang>', <q-args>)
+command! -bang -nargs=* -complete=help LAckWindow    call ack#AckWindow('lgrep<bang>', <q-args>)

sources_non_forked/goyo.vim/plugin/goyo.vim

@@ -46,7 +46,7 @@ function! s:init_pad(command)
   execute a:command
 
   setlocal buftype=nofile bufhidden=wipe nomodifiable nobuflisted noswapfile
-        \ nonu nocursorline winfixwidth winfixheight statusline=\ 
+      \ nonu nocursorline nocursorcolumn winfixwidth winfixheight statusline=\ 
   if exists('&rnu')
     setlocal nornu
   endif
@@ -64,7 +64,7 @@ function! s:setup_pad(bufnr, vert, size)
   execute win . 'wincmd w'
   execute (a:vert ? 'vertical ' : '') . 'resize ' . max([0, a:size])
   augroup goyop
-    autocmd WinEnter <buffer> call s:blank()
+    autocmd WinEnter,CursorMoved <buffer> call s:blank()
   augroup END
 
   " To hide scrollbars of pad windows in GVim
@@ -104,17 +104,19 @@ function! s:tranquilize()
             \ 'StatusLine', 'StatusLineNC', 'SignColumn']
     " -1 on Vim / '' on GVim
     if bg == -1 || empty(bg)
-      call s:set_color(grp, '', 'NONE')
       call s:set_color(grp, 'fg', get(g:, 'goyo_bg', 'black'))
       call s:set_color(grp, 'bg', 'NONE')
     else
       call s:set_color(grp, 'fg', bg)
       call s:set_color(grp, 'bg', bg)
     endif
+    call s:set_color(grp, '', 'NONE')
   endfor
 endfunction
 
 function! s:goyo_on(width)
+  let s:orig_tab = tabpagenr()
+
   " New tab
   tab split
 
@@ -125,6 +127,7 @@ function! s:goyo_on(width)
     \ { 'laststatus':     &laststatus,
     \   'showtabline':    &showtabline,
     \   'fillchars':      &fillchars,
+    \   'winminwidth':    &winminwidth,
     \   'winwidth':       &winwidth,
     \   'winminheight':   &winminheight,
     \   'winheight':      &winheight,
@@ -143,6 +146,12 @@ function! s:goyo_on(width)
     silent! GitGutterDisable
   endif
 
+  " vim-signify
+  let t:goyo_disabled_signify = exists('b:sy') && b:sy.active
+  if t:goyo_disabled_signify
+    SignifyToggle
+  endif
+
   " vim-airline
   let t:goyo_disabled_airline = exists("#airline")
   if t:goyo_disabled_airline
@@ -175,10 +184,10 @@ function! s:goyo_on(width)
   endif
 
   " Global options
-  set winwidth=1
   let &winheight = max([&winminheight, 1])
   set winminheight=1
   set winheight=1
+  set winminwidth=1 winwidth=1
   set laststatus=0
   set showtabline=0
   set noruler
@@ -239,9 +248,12 @@ function! s:goyo_off()
 
   let goyo_revert             = t:goyo_revert
   let goyo_disabled_gitgutter = t:goyo_disabled_gitgutter
+  let goyo_disabled_signify   = t:goyo_disabled_signify
   let goyo_disabled_airline   = t:goyo_disabled_airline
   let goyo_disabled_powerline = t:goyo_disabled_powerline
   let goyo_disabled_lightline = t:goyo_disabled_lightline
+  let goyo_orig_buffer        = t:goyo_master
+  let [line, col]             = [line('.'), col('.')]
 
   if tabpagenr() == 1
     tabnew
@@ -249,7 +261,15 @@ function! s:goyo_off()
     bd
   endif
   tabclose
+  execute 'normal! '.s:orig_tab.'gt'
+  if winbufnr(0) == goyo_orig_buffer
+    execute printf('normal! %dG%d|', line, col)
+  endif
 
+  let wmw = remove(goyo_revert, 'winminwidth')
+  let ww  = remove(goyo_revert, 'winwidth')
+  let &winwidth     = ww
+  let &winminwidth  = wmw
   let wmh = remove(goyo_revert, 'winminheight')
   let wh  = remove(goyo_revert, 'winheight')
   let &winheight    = max([wmh, 1])
@@ -265,6 +285,12 @@ function! s:goyo_off()
     silent! GitGutterEnable
   endif
 
+  if goyo_disabled_signify
+    silent! if !b:sy.active
+      SignifyToggle
+    endif
+  endif
+
   if goyo_disabled_airline && !exists("#airline")
     AirlineToggle
     silent! AirlineRefresh
@@ -288,9 +314,14 @@ function! s:goyo_off()
   endif
 endfunction
 
-function! s:goyo(...)
+function! s:goyo(bang, ...)
   let width = a:0 > 0 ? a:1 : get(g:, 'goyo_width', 80)
 
+  if a:bang
+    if exists('#goyo')
+      call s:goyo_off()
+    endif
+  else
     if exists('#goyo') == 0
       call s:goyo_on(width)
     elseif a:0 > 0
@@ -299,9 +330,10 @@ function! s:goyo(...)
     else
       call s:goyo_off()
     end
+  end
 endfunction
 
-command! -nargs=? Goyo call s:goyo(<args>)
+command! -nargs=? -bar -bang Goyo call s:goyo('<bang>' == '!', <args>)
 
 let &cpo = s:cpo_save
 unlet s:cpo_save

sources_non_forked/nerdtree/README.markdown

@@ -60,7 +60,7 @@ Installation
     cd ~/.vim/bundle
     git clone https://github.com/scrooloose/nerdtree.git
 
-Then reload vim, run `:helptags`, and check out `:help NERD_tree.txt`.
+Then reload vim, run `:Helptags`, and check out `:help NERD_tree.txt`.
 
 
 Faq
@@ -80,7 +80,10 @@ A. Stick this in your vimrc: `autocmd vimenter * NERDTree`
 
 __Q. How can I open a NERDTree automatically when vim starts up if no files were specified?__
 
-A. Stick this in your vimrc `autocmd vimenter * if !argc() | NERDTree | endif`
+A. Stick this in your vimrc
+
+    autocmd StdinReadPre * let s:std_in=1
+    autocmd VimEnter * if argc() == 0 && !exists("s:std_in") | NERDTree | endif
 
 __Q. How can I map a specific key or shortcut to open NERDTree?__
 

sources_non_forked/nerdtree/autoload/nerdtree/ui_glue.vim

@@ -0,0 +1,644 @@
+if exists("g:loaded_nerdtree_ui_glue_autoload")
+    finish
+endif
+let g:loaded_nerdtree_ui_glue_autoload = 1
+
+" FUNCTION: nerdtree#ui_glue#createDefaultBindings() {{{1
+function! nerdtree#ui_glue#createDefaultBindings()
+    let s = '<SNR>' . s:SID() . '_'
+
+    call NERDTreeAddKeyMap({ 'key': '<MiddleRelease>', 'scope': "all", 'callback': s."handleMiddleMouse" })
+    call NERDTreeAddKeyMap({ 'key': '<LeftRelease>', 'scope': "all", 'callback': s."handleLeftClick" })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "DirNode", 'callback': s."activateDirNode" })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "FileNode", 'callback': s."activateFileNode" })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "Bookmark", 'callback': s."activateBookmark" })
+    call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "all", 'callback': s."activateAll" })
+
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "DirNode", 'callback': s."activateDirNode" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "FileNode", 'callback': s."activateFileNode" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "Bookmark", 'callback': s."activateBookmark" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "all", 'callback': s."activateAll" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenSplit, 'scope': "Node", 'callback': s."openHSplit" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenVSplit, 'scope': "Node", 'callback': s."openVSplit" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenSplit, 'scope': "Bookmark", 'callback': s."openHSplit" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenVSplit, 'scope': "Bookmark", 'callback': s."openVSplit" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': "Node", 'callback': s."previewNodeCurrent" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewVSplit, 'scope': "Node", 'callback': s."previewNodeVSplit" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewSplit, 'scope': "Node", 'callback': s."previewNodeHSplit" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': "Bookmark", 'callback': s."previewNodeCurrent" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewVSplit, 'scope': "Bookmark", 'callback': s."previewNodeVSplit" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewSplit, 'scope': "Bookmark", 'callback': s."previewNodeHSplit" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenRecursively, 'scope': "DirNode", 'callback': s."openNodeRecursively" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdir, 'scope': "all", 'callback': s."upDirCurrentRootClosed" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdirKeepOpen, 'scope': "all", 'callback': s."upDirCurrentRootOpen" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChangeRoot, 'scope': "Node", 'callback': s."chRoot" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChdir, 'scope': "Node", 'callback': s."chCwd" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapQuit, 'scope': "all", 'callback': s."closeTreeWindow" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCWD, 'scope': "all", 'callback': "nerdtree#ui_glue#chRootCwd" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefreshRoot, 'scope': "all", 'callback': s."refreshRoot" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefresh, 'scope': "Node", 'callback': s."refreshCurrent" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapHelp, 'scope': "all", 'callback': s."displayHelp" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleZoom, 'scope': "all", 'callback': s."toggleZoom" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleHidden, 'scope': "all", 'callback': s."toggleShowHidden" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFilters, 'scope': "all", 'callback': s."toggleIgnoreFilter" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFiles, 'scope': "all", 'callback': s."toggleShowFiles" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleBookmarks, 'scope': "all", 'callback': s."toggleShowBookmarks" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseDir, 'scope': "Node", 'callback': s."closeCurrentDir" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseChildren, 'scope': "DirNode", 'callback': s."closeChildren" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapMenu, 'scope': "Node", 'callback': s."showMenu" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpParent, 'scope': "Node", 'callback': s."jumpToParent" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpFirstChild, 'scope': "Node", 'callback': s."jumpToFirstChild" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpLastChild, 'scope': "Node", 'callback': s."jumpToLastChild" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpRoot, 'scope': "all", 'callback': s."jumpToRoot" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpNextSibling, 'scope': "Node", 'callback': s."jumpToNextSibling" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpPrevSibling, 'scope': "Node", 'callback': s."jumpToPrevSibling" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': "Node", 'callback': s."openInNewTab" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': "Node", 'callback': s."openInNewTabSilent" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': "Bookmark", 'callback': s."openInNewTab" })
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': "Bookmark", 'callback': s."openInNewTabSilent" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenExpl, 'scope': "DirNode", 'callback': s."openExplorer" })
+
+    call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapDeleteBookmark, 'scope': "Bookmark", 'callback': s."deleteBookmark" })
+endfunction
+
+
+"SECTION: Interface bindings {{{1
+"============================================================
+
+"FUNCTION: s:activateAll() {{{1
+"handle the user activating the updir line
+function! s:activateAll()
+    if getline(".") ==# nerdtree#treeUpDirLine()
+        return nerdtree#ui_glue#upDir(0)
+    endif
+endfunction
+
+"FUNCTION: s:activateDirNode() {{{1
+"handle the user activating a tree node
+function! s:activateDirNode(node)
+    call a:node.activate({'reuse': 1})
+endfunction
+
+"FUNCTION: s:activateFileNode() {{{1
+"handle the user activating a tree node
+function! s:activateFileNode(node)
+    call a:node.activate({'reuse': 1, 'where': 'p'})
+endfunction
+
+"FUNCTION: s:activateBookmark() {{{1
+"handle the user activating a bookmark
+function! s:activateBookmark(bm)
+    call a:bm.activate(!a:bm.path.isDirectory ? {'where': 'p'} : {})
+endfunction
+
+" FUNCTION: nerdtree#ui_glue#bookmarkNode(name) {{{1
+" Associate the current node with the given name
+function! nerdtree#ui_glue#bookmarkNode(...)
+    let currentNode = g:NERDTreeFileNode.GetSelected()
+    if currentNode != {}
+        let name = a:1
+        if empty(name)
+            let name = currentNode.path.getLastPathComponent(0)
+        endif
+        try
+            call currentNode.bookmark(name)
+            call b:NERDTree.render()
+        catch /^NERDTree.IllegalBookmarkNameError/
+            call nerdtree#echo("bookmark names must not contain spaces")
+        endtry
+    else
+        call nerdtree#echo("select a node first")
+    endif
+endfunction
+
+" FUNCTION: s:chCwd(node) {{{1
+function! s:chCwd(node)
+    try
+        call a:node.path.changeToDir()
+    catch /^NERDTree.PathChangeError/
+        call nerdtree#echoWarning("could not change cwd")
+    endtry
+endfunction
+
+" FUNCTION: s:chRoot(node) {{{1
+" changes the current root to the selected one
+function! s:chRoot(node)
+    call a:node.makeRoot()
+    call b:NERDTree.render()
+    call b:NERDTreeRoot.putCursorHere(0, 0)
+endfunction
+
+" FUNCTION: s:nerdtree#ui_glue#chRootCwd() {{{1
+" changes the current root to CWD
+function! nerdtree#ui_glue#chRootCwd()
+    try
+        let cwd = g:NERDTreePath.New(getcwd())
+    catch /^NERDTree.InvalidArgumentsError/
+        call nerdtree#echo("current directory does not exist.")
+        return
+    endtry
+    if cwd.str() == g:NERDTreeFileNode.GetRootForTab().path.str()
+       return
+    endif
+    call s:chRoot(g:NERDTreeDirNode.New(cwd))
+endfunction
+
+" FUNCTION: nnerdtree#ui_glue#clearBookmarks(bookmarks) {{{1
+function! nerdtree#ui_glue#clearBookmarks(bookmarks)
+    if a:bookmarks ==# ''
+        let currentNode = g:NERDTreeFileNode.GetSelected()
+        if currentNode != {}
+            call currentNode.clearBookmarks()
+        endif
+    else
+        for name in split(a:bookmarks, ' ')
+            let bookmark = g:NERDTreeBookmark.BookmarkFor(name)
+            call bookmark.delete()
+        endfor
+    endif
+    call b:NERDTree.render()
+endfunction
+
+" FUNCTION: s:closeChildren(node) {{{1
+" closes all childnodes of the current node
+function! s:closeChildren(node)
+    call a:node.closeChildren()
+    call b:NERDTree.render()
+    call a:node.putCursorHere(0, 0)
+endfunction
+
+" FUNCTION: s:closeCurrentDir(node) {{{1
+" closes the parent dir of the current node
+function! s:closeCurrentDir(node)
+    let parent = a:node.parent
+    if parent ==# {} || parent.isRoot()
+        call nerdtree#echo("cannot close tree root")
+    else
+        while g:NERDTreeCascadeOpenSingleChildDir && !parent.parent.isRoot()
+            if parent.parent.getVisibleChildCount() == 1
+                call parent.close()
+                let parent = parent.parent
+            else
+                break
+            endif
+        endwhile
+        call parent.close()
+        call b:NERDTree.render()
+        call parent.putCursorHere(0, 0)
+    endif
+endfunction
+
+" FUNCTION: s:closeTreeWindow() {{{1
+" close the tree window
+function! s:closeTreeWindow()
+    if b:NERDTreeType ==# "secondary" && b:NERDTreePreviousBuf != -1
+        exec "buffer " . b:NERDTreePreviousBuf
+    else
+        if winnr("$") > 1
+            call nerdtree#closeTree()
+        else
+            call nerdtree#echo("Cannot close last window")
+        endif
+    endif
+endfunction
+
+" FUNCTION: s:deleteBookmark(bm) {{{1
+" if the cursor is on a bookmark, prompt to delete
+function! s:deleteBookmark(bm)
+    echo  "Are you sure you wish to delete the bookmark:\n\"" . a:bm.name . "\" (yN):"
+
+    if  nr2char(getchar()) ==# 'y'
+        try
+            call a:bm.delete()
+            call b:NERDTree.render()
+            redraw
+        catch /^NERDTree/
+            call nerdtree#echoWarning("Could not remove bookmark")
+        endtry
+    else
+        call nerdtree#echo("delete aborted" )
+    endif
+
+endfunction
+
+" FUNCTION: s:displayHelp() {{{1
+" toggles the help display
+function! s:displayHelp()
+    let b:treeShowHelp = b:treeShowHelp ? 0 : 1
+    call b:NERDTree.render()
+    call b:NERDTree.ui.centerView()
+endfunction
+
+" FUNCTION: s:findAndRevealPath() {{{1
+function! s:findAndRevealPath()
+    try
+        let p = g:NERDTreePath.New(expand("%:p"))
+    catch /^NERDTree.InvalidArgumentsError/
+        call nerdtree#echo("no file for the current buffer")
+        return
+    endtry
+
+    if p.isUnixHiddenPath()
+        let showhidden=g:NERDTreeShowHidden
+        let g:NERDTreeShowHidden = 1
+    endif
+
+    if !g:NERDTree.ExistsForTab()
+        try
+            let cwd = g:NERDTreePath.New(getcwd())
+        catch /^NERDTree.InvalidArgumentsError/
+            call nerdtree#echo("current directory does not exist.")
+            let cwd = p.getParent()
+        endtry
+
+        if p.isUnder(cwd)
+            call g:NERDTreeCreator.CreatePrimary(cwd.str())
+        else
+            call g:NERDTreeCreator.CreatePrimary(p.getParent().str())
+        endif
+    else
+        if !p.isUnder(g:NERDTreeFileNode.GetRootForTab().path)
+            if !nerdtree#isTreeOpen()
+                call g:NERDTreeCreator.TogglePrimary('')
+            else
+                call nerdtree#putCursorInTreeWin()
+            endif
+            let b:NERDTreeShowHidden = g:NERDTreeShowHidden
+            call s:chRoot(g:NERDTreeDirNode.New(p.getParent()))
+        else
+            if !nerdtree#isTreeOpen()
+                call g:NERDTreeCreator.TogglePrimary("")
+            endif
+        endif
+    endif
+    call nerdtree#putCursorInTreeWin()
+    call b:NERDTreeRoot.reveal(p)
+
+    if p.isUnixHiddenFile()
+        let g:NERDTreeShowHidden = showhidden
+    endif
+endfunction
+
+"FUNCTION: s:handleLeftClick() {{{1
+"Checks if the click should open the current node
+function! s:handleLeftClick()
+    let currentNode = g:NERDTreeFileNode.GetSelected()
+    if currentNode != {}
+
+        "the dir arrows are multibyte chars, and vim's string functions only
+        "deal with single bytes - so split the line up with the hack below and
+        "take the line substring manually
+        let line = split(getline(line(".")), '\zs')
+        let startToCur = ""
+        for i in range(0,len(line)-1)
+            let startToCur .= line[i]
+        endfor
+
+        if currentNode.path.isDirectory
+            if startToCur =~# nerdtree#treeMarkupReg() && startToCur =~# '[+~▾▸] \?$'
+                call currentNode.activate()
+                return
+            endif
+        endif
+
+        if (g:NERDTreeMouseMode ==# 2 && currentNode.path.isDirectory) || g:NERDTreeMouseMode ==# 3
+            let char = strpart(startToCur, strlen(startToCur)-1, 1)
+            if char !~# nerdtree#treeMarkupReg()
+                if currentNode.path.isDirectory
+                    call currentNode.activate()
+                else
+                    call currentNode.activate({'reuse': 1, 'where': 'p'})
+                endif
+                return
+            endif
+        endif
+    endif
+endfunction
+
+" FUNCTION: s:handleMiddleMouse() {{{1
+function! s:handleMiddleMouse()
+    let curNode = g:NERDTreeFileNode.GetSelected()
+    if curNode ==# {}
+        call nerdtree#echo("Put the cursor on a node first" )
+        return
+    endif
+
+    if curNode.path.isDirectory
+        call nerdtree#openExplorer(curNode)
+    else
+        call curNode.open({'where': 'h'})
+    endif
+endfunction
+
+" FUNCTION: s:jumpToChild(direction) {{{2
+" Args:
+" direction: 0 if going to first child, 1 if going to last
+function! s:jumpToChild(currentNode, direction)
+    if a:currentNode.isRoot()
+        return nerdtree#echo("cannot jump to " . (a:direction ? "last" : "first") .  " child")
+    end
+    let dirNode = a:currentNode.parent
+    let childNodes = dirNode.getVisibleChildren()
+
+    let targetNode = childNodes[0]
+    if a:direction
+        let targetNode = childNodes[len(childNodes) - 1]
+    endif
+
+    if targetNode.equals(a:currentNode)
+        let siblingDir = a:currentNode.parent.findOpenDirSiblingWithVisibleChildren(a:direction)
+        if siblingDir != {}
+            let indx = a:direction ? siblingDir.getVisibleChildCount()-1 : 0
+            let targetNode = siblingDir.getChildByIndex(indx, 1)
+        endif
+    endif
+
+    call targetNode.putCursorHere(1, 0)
+
+    call b:NERDTree.ui.centerView()
+endfunction
+
+
+" FUNCTION: nerdtree#ui_glue#invokeKeyMap(key) {{{1
+"this is needed since I cant figure out how to invoke dict functions from a
+"key map
+function! nerdtree#ui_glue#invokeKeyMap(key)
+    call g:NERDTreeKeyMap.Invoke(a:key)
+endfunction
+
+" FUNCTION: s:jumpToFirstChild() {{{1
+" wrapper for the jump to child method
+function! s:jumpToFirstChild(node)
+    call s:jumpToChild(a:node, 0)
+endfunction
+
+" FUNCTION: s:jumpToLastChild() {{{1
+" wrapper for the jump to child method
+function! s:jumpToLastChild(node)
+    call s:jumpToChild(a:node, 1)
+endfunction
+
+" FUNCTION: s:jumpToParent(node) {{{1
+" moves the cursor to the parent of the current node
+function! s:jumpToParent(node)
+    if !empty(a:node.parent)
+        call a:node.parent.putCursorHere(1, 0)
+        call b:NERDTree.ui.centerView()
+    else
+        call nerdtree#echo("cannot jump to parent")
+    endif
+endfunction
+
+" FUNCTION: s:jumpToRoot() {{{1
+" moves the cursor to the root node
+function! s:jumpToRoot()
+    call b:NERDTreeRoot.putCursorHere(1, 0)
+    call b:NERDTree.ui.centerView()
+endfunction
+
+" FUNCTION: s:jumpToNextSibling(node) {{{1
+function! s:jumpToNextSibling(node)
+    call s:jumpToSibling(a:node, 1)
+endfunction
+
+" FUNCTION: s:jumpToPrevSibling(node) {{{1
+function! s:jumpToPrevSibling(node)
+    call s:jumpToSibling(a:node, 0)
+endfunction
+
+" FUNCTION: s:jumpToSibling(currentNode, forward) {{{2
+" moves the cursor to the sibling of the current node in the given direction
+"
+" Args:
+" forward: 1 if the cursor should move to the next sibling, 0 if it should
+" move back to the previous sibling
+function! s:jumpToSibling(currentNode, forward)
+    let sibling = a:currentNode.findSibling(a:forward)
+
+    if !empty(sibling)
+        call sibling.putCursorHere(1, 0)
+        call b:NERDTree.ui.centerView()
+    endif
+endfunction
+
+" FUNCTION: nerdtree#ui_glue#openBookmark(name) {{{1
+" put the cursor on the given bookmark and, if its a file, open it
+function! nerdtree#ui_glue#openBookmark(name)
+    try
+        let targetNode = g:NERDTreeBookmark.GetNodeForName(a:name, 0)
+        call targetNode.putCursorHere(0, 1)
+        redraw!
+    catch /^NERDTree.BookmarkedNodeNotFoundError/
+        call nerdtree#echo("note - target node is not cached")
+        let bookmark = g:NERDTreeBookmark.BookmarkFor(a:name)
+        let targetNode = g:NERDTreeFileNode.New(bookmark.path)
+    endtry
+    if targetNode.path.isDirectory
+        call targetNode.openExplorer()
+    else
+        call targetNode.open({'where': 'p'})
+    endif
+endfunction
+
+" FUNCTION: s:openHSplit(target) {{{1
+function! s:openHSplit(target)
+    call a:target.activate({'where': 'h'})
+endfunction
+
+" FUNCTION: s:openVSplit(target) {{{1
+function! s:openVSplit(target)
+    call a:target.activate({'where': 'v'})
+endfunction
+
+" FUNCTION: s:openExplorer(node) {{{1
+function! s:openExplorer(node)
+    call a:node.openExplorer()
+endfunction
+
+" FUNCTION: s:openInNewTab(target) {{{1
+function! s:openInNewTab(target)
+    call a:target.activate({'where': 't'})
+endfunction
+
+" FUNCTION: s:openInNewTabSilent(target) {{{1
+function! s:openInNewTabSilent(target)
+    call a:target.activate({'where': 't', 'stay': 1})
+endfunction
+
+" FUNCTION: s:openNodeRecursively(node) {{{1
+function! s:openNodeRecursively(node)
+    call nerdtree#echo("Recursively opening node. Please wait...")
+    call a:node.openRecursively()
+    call b:NERDTree.render()
+    redraw
+    call nerdtree#echo("Recursively opening node. Please wait... DONE")
+endfunction
+
+"FUNCTION: s:previewNodeCurrent(node) {{{1
+function! s:previewNodeCurrent(node)
+    call a:node.open({'stay': 1, 'where': 'p', 'keepopen': 1})
+endfunction
+
+"FUNCTION: s:previewNodeHSplit(node) {{{1
+function! s:previewNodeHSplit(node)
+    call a:node.open({'stay': 1, 'where': 'h', 'keepopen': 1})
+endfunction
+
+"FUNCTION: s:previewNodeVSplit(node) {{{1
+function! s:previewNodeVSplit(node)
+    call a:node.open({'stay': 1, 'where': 'v', 'keepopen': 1})
+endfunction
+
+" FUNCTION: nerdtree#ui_glue#revealBookmark(name) {{{1
+" put the cursor on the node associate with the given name
+function! nerdtree#ui_glue#revealBookmark(name)
+    try
+        let targetNode = g:NERDTreeBookmark.GetNodeForName(a:name, 0)
+        call targetNode.putCursorHere(0, 1)
+    catch /^NERDTree.BookmarkNotFoundError/
+        call nerdtree#echo("Bookmark isnt cached under the current root")
+    endtry
+endfunction
+
+" FUNCTION: s:refreshRoot() {{{1
+" Reloads the current root. All nodes below this will be lost and the root dir
+" will be reloaded.
+function! s:refreshRoot()
+    call nerdtree#echo("Refreshing the root node. This could take a while...")
+    call b:NERDTreeRoot.refresh()
+    call b:NERDTree.render()
+    redraw
+    call nerdtree#echo("Refreshing the root node. This could take a while... DONE")
+endfunction
+
+" FUNCTION: s:refreshCurrent(node) {{{1
+" refreshes the root for the current node
+function! s:refreshCurrent(node)
+    let node = a:node
+    if !node.path.isDirectory
+        let node = node.parent
+    endif
+
+    call nerdtree#echo("Refreshing node. This could take a while...")
+    call node.refresh()
+    call b:NERDTree.render()
+    redraw
+    call nerdtree#echo("Refreshing node. This could take a while... DONE")
+endfunction
+
+" FUNCTION: nerdtree#ui_glue#setupCommands() {{{1
+function! nerdtree#ui_glue#setupCommands()
+    command! -n=? -complete=dir -bar NERDTree :call g:NERDTreeCreator.CreatePrimary('<args>')
+    command! -n=? -complete=dir -bar NERDTreeToggle :call g:NERDTreeCreator.TogglePrimary('<args>')
+    command! -n=0 -bar NERDTreeClose :call nerdtree#closeTreeIfOpen()
+    command! -n=1 -complete=customlist,nerdtree#completeBookmarks -bar NERDTreeFromBookmark call g:NERDTreeCreator.CreatePrimary('<args>')
+    command! -n=0 -bar NERDTreeMirror call g:NERDTreeCreator.CreateMirror()
+    command! -n=0 -bar NERDTreeFind call s:findAndRevealPath()
+    command! -n=0 -bar NERDTreeFocus call NERDTreeFocus()
+    command! -n=0 -bar NERDTreeCWD call NERDTreeCWD()
+endfunction
+
+" Function: s:SID()   {{{1
+function s:SID()
+    if !exists("s:sid")
+        let s:sid = matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
+    endif
+    return s:sid
+endfun
+
+" FUNCTION: s:showMenu(node) {{{1
+function! s:showMenu(node)
+    let mc = g:NERDTreeMenuController.New(g:NERDTreeMenuItem.AllEnabled())
+    call mc.showMenu()
+endfunction
+
+" FUNCTION: s:toggleIgnoreFilter() {{{1
+function! s:toggleIgnoreFilter()
+    call b:NERDTree.ui.toggleIgnoreFilter()
+endfunction
+
+" FUNCTION: s:toggleShowBookmarks() {{{1
+function! s:toggleShowBookmarks()
+    call b:NERDTree.ui.toggleShowBookmarks()
+endfunction
+
+" FUNCTION: s:toggleShowFiles() {{{1
+function! s:toggleShowFiles()
+    call b:NERDTree.ui.toggleShowFiles()
+endfunction
+
+" FUNCTION: s:toggleShowHidden() {{{1
+" toggles the display of hidden files
+function! s:toggleShowHidden()
+    call b:NERDTree.ui.toggleShowHidden()
+endfunction
+
+" FUNCTION: s:toggleZoom() {{{1
+function! s:toggleZoom()
+    call b:NERDTree.ui.toggleZoom()
+endfunction
+
+"FUNCTION: nerdtree#ui_glue#upDir(keepState) {{{1
+"moves the tree up a level
+"
+"Args:
+"keepState: 1 if the current root should be left open when the tree is
+"re-rendered
+function! nerdtree#ui_glue#upDir(keepState)
+    let cwd = b:NERDTreeRoot.path.str({'format': 'UI'})
+    if cwd ==# "/" || cwd =~# '^[^/]..$'
+        call nerdtree#echo("already at top dir")
+    else
+        if !a:keepState
+            call b:NERDTreeRoot.close()
+        endif
+
+        let oldRoot = b:NERDTreeRoot
+
+        if empty(b:NERDTreeRoot.parent)
+            let path = b:NERDTreeRoot.path.getParent()
+            let newRoot = g:NERDTreeDirNode.New(path)
+            call newRoot.open()
+            call newRoot.transplantChild(b:NERDTreeRoot)
+            let b:NERDTreeRoot = newRoot
+        else
+            let b:NERDTreeRoot = b:NERDTreeRoot.parent
+        endif
+
+        if g:NERDTreeChDirMode ==# 2
+            call b:NERDTreeRoot.path.changeToDir()
+        endif
+
+        call b:NERDTree.render()
+        call oldRoot.putCursorHere(0, 0)
+    endif
+endfunction
+
+" FUNCTION: s:upDirCurrentRootOpen() {{{1
+function! s:upDirCurrentRootOpen()
+    call nerdtree#ui_glue#upDir(1)
+endfunction
+
+" FUNCTION: s:upDirCurrentRootClosed() {{{1
+function! s:upDirCurrentRootClosed()
+    call nerdtree#ui_glue#upDir(0)
+endfunction
+
+" vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/nerdtree/doc/NERD_tree.txt

@@ -109,7 +109,7 @@ The following features and functionality are provided by the NERD tree:
 <
 :NERDTreeFromBookmark <bookmark>                       *:NERDTreeFromBookmark*
     Opens a fresh NERD tree with the root initialized to the dir for
-    <bookmark>.  This only reason to use this command over :NERDTree is for
+    <bookmark>.  The only reason to use this command over :NERDTree is for
     the completion (which is for bookmarks rather than directories).
 
 :NERDTreeToggle [<start-directory> | <bookmark>]             *:NERDTreeToggle*
@@ -160,7 +160,7 @@ click bookmarks or use the |NERDTree-o| mapping to activate them. See also,
 
 Note that the following commands are only available in the NERD tree buffer.
 
-:Bookmark <name>
+:Bookmark [<name>]
     Bookmark the current node as <name>. If there is already a <name>
     bookmark, it is overwritten. <name> must not contain spaces.
     If <name> is not provided, it defaults to the file or directory name.
@@ -358,7 +358,7 @@ Default key: O
 Map option: NERDTreeMapOpenRecursively
 Applies to: directories.
 
-Recursively opens the selelected directory.
+Recursively opens the selected directory.
 
 All files and directories are cached, but if a directory would not be
 displayed due to file filters (see |'NERDTreeIgnore'| |NERDTree-f|) or the
@@ -609,17 +609,19 @@ NERD tree. These options should be set in your vimrc.
 
 |'loaded_nerd_tree'|            Turns off the script.
 
-|'NERDChristmasTree'|           Tells the NERD tree to make itself colourful
-                                and pretty.
-
 |'NERDTreeAutoCenter'|          Controls whether the NERD tree window centers
                                 when the cursor moves within a specified
                                 distance to the top/bottom of the window.
+
 |'NERDTreeAutoCenterThreshold'| Controls the sensitivity of autocentering.
 
 |'NERDTreeCaseSensitiveSort'|   Tells the NERD tree whether to be case
                                 sensitive or not when sorting nodes.
 
+|'NERDTreeSortHiddenFirst'|     Tells the NERD tree whether to take the dot
+                                at the beginning of the hidden file names
+                                into account when sorting nodes.
+
 |'NERDTreeChDirMode'|           Tells the NERD tree if/when it should change
                                 vim's current working directory.
 
@@ -631,8 +633,13 @@ NERD tree. These options should be set in your vimrc.
 
 |'NERDTreeIgnore'|              Tells the NERD tree which files to ignore.
 
+|'NERDTreeRespectWildIgnore'|   Tells the NERD tree to respect |'wildignore'|.
+
 |'NERDTreeBookmarksFile'|       Where the bookmarks are stored.
 
+|'NERDTreeBookmarksSort'|       Whether the bookmarks list is sorted on
+                                display.
+
 |'NERDTreeMouseMode'|           Tells the NERD tree how to handle mouse
                                 clicks.
 
@@ -667,8 +674,8 @@ NERD tree. These options should be set in your vimrc.
 |'NERDTreeDirArrows'|           Tells the NERD tree to use arrows instead of
                                 + ~ chars when displaying directories.
 
-|'NERDTreeCasadeOpenSingleChildDir'|
-                                Casade open while selected directory has only
+|'NERDTreeCascadeOpenSingleChildDir'|
+                                Cascade open while selected directory has only
                                 one child that also is a directory.
 
 |'NERDTreeAutoDeleteBuffer'|    Tells the NERD tree to automatically remove 
@@ -686,15 +693,6 @@ If this plugin is making you feel homicidal, it may be a good idea to turn it
 off with this line in your vimrc: >
     let loaded_nerd_tree=1
 <
-------------------------------------------------------------------------------
-                                                         *'NERDChristmasTree'*
-Values: 0 or 1.
-Default: 1.
-
-If this option is set to 1 then some extra syntax highlighting elements are
-added to the nerd tree to make it more colourful.
-
-Set it to 0 for a more vanilla looking tree.
 
 ------------------------------------------------------------------------------
                                                         *'NERDTreeAutoCenter'*
@@ -817,6 +815,13 @@ line: >
 The file filters can be turned on and off dynamically with the |NERDTree-f|
 mapping.
 
+------------------------------------------------------------------------------
+                                                *'NERDTreeRespectWildIgnore'*
+Values: 0 or 1.
+Default: 0.
+
+If set to 1, the |'wildignore'| setting is respected.
+
 ------------------------------------------------------------------------------
                                                      *'NERDTreeBookmarksFile'*
 Values: a path
@@ -824,6 +829,14 @@ Default: $HOME/.NERDTreeBookmarks
 
 This is where bookmarks are saved. See |NERDTreeBookmarkCommands|.
 
+------------------------------------------------------------------------------
+                                                     *'NERDTreeBookmarksSort'*
+Values: 0 or 1
+Default: 1
+
+If set to 0 then the bookmarks list is not sorted.
+If set to 1 the bookmarks list is sorted.
+
 ------------------------------------------------------------------------------
                                                        *'NERDTreeMouseMode'*
 Values: 1, 2 or 3.
@@ -987,16 +1000,17 @@ option: >
 <
 
 ------------------------------------------------------------------------------
-                                          *'NERDTreeCasadeOpenSingleChildDir'*
+                                          *'NERDTreeCascadeOpenSingleChildDir'*
 Values: 0 or 1
 Default: 1.
 
 When opening dir nodes, this option tells NERDTree to recursively open dirs
 that have only one child which is also a dir. NERDTree will stop when it finds
-a dir that contains anything but another single dir. This option may be useful
-for Java projects.  Use one of the follow lines to set this option: >
-    let NERDTreeCasadeOpenSingleChildDir=0
-    let NERDTreeCasadeOpenSingleChildDir=1
+a dir that contains anything but another single dir. This option also causes
+the |NERDTree-x| mapping to close dirs in the same manner. This option may be
+useful for Java projects. Use one of the follow lines to set this option: >
+    let NERDTreeCascadeOpenSingleChildDir=0
+    let NERDTreeCascadeOpenSingleChildDir=1
 <
 
 ------------------------------------------------------------------------------
@@ -1046,6 +1060,9 @@ NERDTreeAddKeyMap({options})                             *NERDTreeAddKeyMap()*
     "callback" - the function the new mapping will be bound to
     "quickhelpText" - the text that will appear in the quickhelp (see
     |NERDTree-?|)
+    "override" - if 1 then this new mapping will override whatever previous
+    mapping was defined for the key/scope combo. Useful for overriding the
+    default mappings.
 
     Additionally, a "scope" argument may be supplied. This constrains the
     mapping so that it is only activated if the cursor is on a certain object.
@@ -1062,8 +1079,8 @@ NERDTreeAddKeyMap({options})                             *NERDTreeAddKeyMap()*
         call NERDTreeAddKeyMap({
                \ 'key': 'foo',
                \ 'callback': 'NERDTreeCDHandler',
-               \ 'quickhelpText': 'echo full path of current node' })
-               \ 'scope': 'DirNode'
+               \ 'quickhelpText': 'echo full path of current node',
+               \ 'scope': 'DirNode' })
 
         function! NERDTreeCDHandler(dirnode)
             call a:dirnode.changeToDir()

sources_non_forked/nerdtree/lib/nerdtree/bookmark.vim

@@ -19,7 +19,9 @@ function! s:Bookmark.AddBookmark(name, path)
         endif
     endfor
     call add(s:Bookmark.Bookmarks(), s:Bookmark.New(a:name, a:path))
+    if g:NERDTreeBookmarksSort ==# 1
         call s:Bookmark.Sort()
+    endif
 endfunction
 
 " FUNCTION: Bookmark.Bookmarks()   {{{1
@@ -101,8 +103,10 @@ function! s:Bookmark.CacheBookmarks(silent)
                 call nerdtree#echo(invalidBookmarksFound . " invalid bookmarks were read. See :help NERDTreeInvalidBookmarks for info.")
             endif
         endif
+        if g:NERDTreeBookmarksSort ==# 1
             call s:Bookmark.Sort()
         endif
+    endif
 endfunction
 
 " FUNCTION: Bookmark.compareTo(otherbookmark) {{{1
@@ -271,7 +275,7 @@ function! s:Bookmark.toRoot()
             let targetNode = g:NERDTreeFileNode.New(s:Bookmark.BookmarkFor(self.name).path)
         endtry
         call targetNode.makeRoot()
-        call nerdtree#renderView()
+        call b:NERDTree.render()
         call targetNode.putCursorHere(0, 0)
     endif
 endfunction
@@ -289,7 +293,7 @@ function! s:Bookmark.validate()
         return 1
     else
         call s:Bookmark.CacheBookmarks(1)
-        call nerdtree#renderView()
+        call b:NERDTree.render()
         call nerdtree#echo(self.name . "now points to an invalid location. See :help NERDTreeInvalidBookmarks for info.")
         return 0
     endif

sources_non_forked/nerdtree/lib/nerdtree/creator.vim

@@ -7,18 +7,18 @@ let g:NERDTreeCreator = s:Creator
 
 "FUNCTION: s:Creator._bindMappings() {{{1
 function! s:Creator._bindMappings()
-    "make <cr> do the same as the default 'o' mapping
-    exec "nnoremap <silent> <buffer> <cr> :call nerdtree#invokeKeyMap('". g:NERDTreeMapActivateNode ."')<cr>"
+    "make <cr> do the same as the activate node mapping
+    nnoremap <silent> <buffer> <cr> :call nerdtree#ui_glue#invokeKeyMap(g:NERDTreeMapActivateNode)<cr>
 
     call g:NERDTreeKeyMap.BindAll()
 
-    command! -buffer -nargs=? Bookmark :call nerdtree#bookmarkNode('<args>')
-    command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=1 RevealBookmark :call nerdtree#revealBookmark('<args>')
-    command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=1 OpenBookmark :call nerdtree#openBookmark('<args>')
-    command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=* ClearBookmarks call nerdtree#clearBookmarks('<args>')
+    command! -buffer -nargs=? Bookmark :call nerdtree#ui_glue#bookmarkNode('<args>')
+    command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=1 RevealBookmark :call nerdtree#ui_glue#revealBookmark('<args>')
+    command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=1 OpenBookmark :call nerdtree#ui_glue#openBookmark('<args>')
+    command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=* ClearBookmarks call nerdtree#ui_glue#clearBookmarks('<args>')
     command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=+ BookmarkToRoot call g:NERDTreeBookmark.ToRoot('<args>')
-    command! -buffer -nargs=0 ClearAllBookmarks call g:NERDTreeBookmark.ClearAll() <bar> call nerdtree#renderView()
-    command! -buffer -nargs=0 ReadBookmarks call g:NERDTreeBookmark.CacheBookmarks(0) <bar> call nerdtree#renderView()
+    command! -buffer -nargs=0 ClearAllBookmarks call g:NERDTreeBookmark.ClearAll() <bar> call b:NERDTree.render()
+    command! -buffer -nargs=0 ReadBookmarks call g:NERDTreeBookmark.CacheBookmarks(0) <bar> call b:NERDTree.render()
     command! -buffer -nargs=0 WriteBookmarks call g:NERDTreeBookmark.Write()
 endfunction
 
@@ -49,26 +49,23 @@ function! s:Creator.createPrimary(name)
         call path.changeToDir()
     endif
 
-    if nerdtree#treeExistsForTab()
+    if g:NERDTree.ExistsForTab()
         if nerdtree#isTreeOpen()
             call nerdtree#closeTree()
         endif
         unlet t:NERDTreeBufName
     endif
 
-    let newRoot = g:NERDTreeDirNode.New(path)
-    call newRoot.open()
-
     call self._createTreeWin()
+    call self._createNERDTree(path)
+    let b:NERDTreeType = "primary"
     let b:treeShowHelp = 0
     let b:NERDTreeIgnoreEnabled = 1
     let b:NERDTreeShowFiles = g:NERDTreeShowFiles
     let b:NERDTreeShowHidden = g:NERDTreeShowHidden
     let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks
-    let b:NERDTreeRoot = newRoot
-    let b:NERDTreeType = "primary"
 
-    call nerdtree#renderView()
+    call b:NERDTree.render()
     call b:NERDTreeRoot.putCursorHere(0, 0)
 
     call self._broadcastInitEvent()
@@ -99,18 +96,26 @@ function! s:Creator.createSecondary(dir)
     exec "silent edit " . self._nextBufferName()
 
     let b:NERDTreePreviousBuf = bufnr(previousBuf)
-
-    let b:NERDTreeRoot = g:NERDTreeDirNode.New(path)
-    call b:NERDTreeRoot.open()
-
+    call self._createNERDTree(path)
     call self._setCommonBufOptions()
     let b:NERDTreeType = "secondary"
 
-    call nerdtree#renderView()
+    call b:NERDTree.render()
 
     call self._broadcastInitEvent()
 endfunction
 
+" FUNCTION: s:Creator._createNERDTree(path) {{{1
+function! s:Creator._createNERDTree(path)
+    let b:NERDTree = g:NERDTree.New(a:path)
+    "TODO: This is kept for compatability only since many things use
+    "b:NERDTreeRoot instead of the new NERDTree.root
+    "Remove this one day
+    let b:NERDTreeRoot = b:NERDTree.root
+
+    call b:NERDTree.root.open()
+endfunction
+
 " FUNCTION: s:Creator.CreateMirror() {{{1
 function! s:Creator.CreateMirror()
     let creator = s:Creator.New()
@@ -122,12 +127,12 @@ function! s:Creator.createMirror()
     "get the names off all the nerd tree buffers
     let treeBufNames = []
     for i in range(1, tabpagenr("$"))
-        let nextName = nerdtree#tabpagevar(i, 'NERDTreeBufName')
+        let nextName = self._tabpagevar(i, 'NERDTreeBufName')
         if nextName != -1 && (!exists("t:NERDTreeBufName") || nextName != t:NERDTreeBufName)
             call add(treeBufNames, nextName)
         endif
     endfor
-    let treeBufNames = nerdtree#unique(treeBufNames)
+    let treeBufNames = self._uniq(treeBufNames)
 
     "map the option names (that the user will be prompted with) to the nerd
     "tree buffer names
@@ -158,7 +163,7 @@ function! s:Creator.createMirror()
         return
     endif
 
-    if nerdtree#treeExistsForTab() && nerdtree#isTreeOpen()
+    if g:NERDTree.ExistsForTab() && nerdtree#isTreeOpen()
         call nerdtree#closeTree()
     endif
 
@@ -166,7 +171,7 @@ function! s:Creator.createMirror()
     call self._createTreeWin()
     exec 'buffer ' .  bufferName
     if !&hidden
-        call nerdtree#renderView()
+        call b:NERDTree.render()
     endif
 endfunction
 
@@ -279,8 +284,8 @@ function! s:Creator._setCommonBufOptions()
     let b:NERDTreeShowFiles = g:NERDTreeShowFiles
     let b:NERDTreeShowHidden = g:NERDTreeShowHidden
     let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks
-    setfiletype nerdtree
     call self._bindMappings()
+    setlocal filetype=nerdtree
 endfunction
 
 "FUNCTION: s:Creator._setupStatusline() {{{1
@@ -290,6 +295,24 @@ function! s:Creator._setupStatusline()
     endif
 endfunction
 
+" FUNCTION: s:Creator._tabpagevar(tabnr, var) {{{1
+function! s:Creator._tabpagevar(tabnr, var)
+    let currentTab = tabpagenr()
+    let old_ei = &ei
+    set ei=all
+
+    exec "tabnext " . a:tabnr
+    let v = -1
+    if exists('t:' . a:var)
+        exec 'let v = t:' . a:var
+    endif
+    exec "tabnext " . currentTab
+
+    let &ei = old_ei
+
+    return v
+endfunction
+
 "FUNCTION: s:Creator.TogglePrimary(dir) {{{1
 function! s:Creator.TogglePrimary(dir)
     let creator = s:Creator.New()
@@ -304,13 +327,13 @@ endfunction
 "dir: the full path for the root node (is only used if the NERD tree is being
 "initialized.
 function! s:Creator.togglePrimary(dir)
-    if nerdtree#treeExistsForTab()
+    if g:NERDTree.ExistsForTab()
         if !nerdtree#isTreeOpen()
             call self._createTreeWin()
             if !&hidden
-                call nerdtree#renderView()
+                call b:NERDTree.render()
             endif
-            call nerdtree#restoreScreenState()
+            call b:NERDTree.ui.restoreScreenState()
         else
             call nerdtree#closeTree()
         endif
@@ -319,4 +342,16 @@ function! s:Creator.togglePrimary(dir)
     endif
 endfunction
 
+" Function: s:Creator._uniq(list)   {{{1
+" returns a:list without duplicates
+function! s:Creator._uniq(list)
+  let uniqlist = []
+  for elem in a:list
+    if index(uniqlist, elem) ==# -1
+      let uniqlist += [elem]
+    endif
+  endfor
+  return uniqlist
+endfunction
+
 " vim: set sw=4 sts=4 et fdm=marker:

sources_non_forked/nerdtree/lib/nerdtree/event.vim

@@ -0,0 +1,13 @@
+"CLASS: Event
+"============================================================
+let s:Event = {}
+let g:NERDTreeEvent = s:Event
+
+function! s:Event.New(nerdtree, subject, action, params) abort
+    let newObj = copy(self)
+    let newObj.nerdtree = a:nerdtree
+    let newObj.subject = a:subject
+    let newObj.action = a:action
+    let newObj.params = a:params
+    return newObj
+endfunction

sources_non_forked/nerdtree/lib/nerdtree/flag_set.vim

@@ -0,0 +1,56 @@
+"CLASS: FlagSet
+"============================================================
+let s:FlagSet = {}
+let g:NERDTreeFlagSet = s:FlagSet
+
+"FUNCTION: FlagSet.addFlag(scope, flag) {{{1
+function! s:FlagSet.addFlag(scope, flag)
+    let flags = self._flagsForScope(a:scope)
+    if index(flags, a:flag) == -1
+        call add(flags, a:flag)
+    end
+endfunction
+
+"FUNCTION: FlagSet.clearFlags(scope) {{{1
+function! s:FlagSet.clearFlags(scope)
+    let self._flags[a:scope] = []
+endfunction
+
+"FUNCTION: FlagSet._flagsForScope(scope) {{{1
+function! s:FlagSet._flagsForScope(scope)
+    if !has_key(self._flags, a:scope)
+        let self._flags[a:scope] = []
+    endif
+    return self._flags[a:scope]
+endfunction
+
+"FUNCTION: FlagSet.New() {{{1
+function! s:FlagSet.New()
+    let newObj = copy(self)
+    let newObj._flags = {}
+    return newObj
+endfunction
+
+"FUNCTION: FlagSet.removeFlag(scope, flag) {{{1
+function! s:FlagSet.removeFlag(scope, flag)
+    let flags = self._flagsForScope(a:scope)
+
+    let i = index(flags, a:flag)
+    if i >= 0
+        call remove(flags, i)
+    endif
+endfunction
+
+"FUNCTION: FlagSet.renderToString() {{{1
+function! s:FlagSet.renderToString()
+    let flagstring = ""
+    for i in values(self._flags)
+        let flagstring .= join(i)
+    endfor
+
+    if len(flagstring) == 0
+        return ""
+    endif
+
+    return '[' . flagstring . ']'
+endfunction

sources_non_forked/nerdtree/lib/nerdtree/key_map.vim

@@ -44,7 +44,7 @@ function! s:KeyMap.bind()
 
     let premap = self.key == "<LeftRelease>" ? " <LeftRelease>" : " "
 
-    exec 'nnoremap <buffer> <silent> '. self.key . premap . ':call nerdtree#invokeKeyMap("'. keymapInvokeString .'")<cr>'
+    exec 'nnoremap <buffer> <silent> '. self.key . premap . ':call nerdtree#ui_glue#invokeKeyMap("'. keymapInvokeString .'")<cr>'
 endfunction
 
 "FUNCTION: KeyMap.Remove(key, scope) {{{1
@@ -79,6 +79,16 @@ endfunction
 "If a keymap has the scope of "all" then it will be called if no other keymap
 "is found for a:key and the scope.
 function! s:KeyMap.Invoke(key)
+
+    "required because clicking the command window below another window still
+    "invokes the <LeftRelease> mapping - but changes the window cursor
+    "is in first
+    "
+    "TODO: remove this check when the vim bug is fixed
+    if !g:NERDTree.ExistsForBuf()
+        return {}
+    endif
+
     let node = g:NERDTreeFileNode.GetSelected()
     if !empty(node)
 
@@ -124,8 +134,14 @@ endfunction
 
 "FUNCTION: KeyMap.Create(options) {{{1
 function! s:KeyMap.Create(options)
-    let newKeyMap = copy(self)
     let opts = extend({'scope': 'all', 'quickhelpText': ''}, copy(a:options))
+
+    "dont override other mappings unless the 'override' option is given
+    if get(opts, 'override', 0) == 0 && !empty(s:KeyMap.FindFor(opts['key'], opts['scope']))
+        return
+    end
+
+    let newKeyMap = copy(self)
     let newKeyMap.key = opts['key']
     let newKeyMap.quickhelpText = opts['quickhelpText']
     let newKeyMap.callback = opts['callback']

sources_non_forked/nerdtree/lib/nerdtree/menu_item.vim

@@ -90,7 +90,7 @@ endfunction
 "callback
 function! s:MenuItem.execute()
     if len(self.children)
-        let mc = s:MenuController.New(self.children)
+        let mc = g:NERDTreeMenuController.New(self.children)
         call mc.showMenu()
     else
         if self.callback != -1

sources_non_forked/nerdtree/lib/nerdtree/nerdtree.vim

@@ -0,0 +1,39 @@
+"CLASS: NERDTree
+"============================================================
+let s:NERDTree = {}
+let g:NERDTree = s:NERDTree
+
+" Function: s:NERDTree.ExistsForBuffer()   {{{1
+" Returns 1 if a nerd tree root exists in the current buffer
+function! s:NERDTree.ExistsForBuf()
+    return exists("b:NERDTreeRoot")
+endfunction
+
+" Function: s:NERDTree.ExistsForTab()   {{{1
+" Returns 1 if a nerd tree root exists in the current tab
+function! s:NERDTree.ExistsForTab()
+    return exists("t:NERDTreeBufName")
+endfunction
+
+function! s:NERDTree.ForCurrentBuf()
+    if s:NERDTree.ExistsForBuf()
+        return b:NERDTree
+    else
+        return {}
+    endif
+endfunction
+
+function! s:NERDTree.New(path)
+    let newObj = copy(self)
+    let newObj.ui = g:NERDTreeUI.New(newObj)
+    let newObj.root = g:NERDTreeDirNode.New(a:path)
+
+    return newObj
+endfunction
+
+"FUNCTION: s:NERDTree.render() {{{1
+"A convenience function - since this is called often
+function! s:NERDTree.render()
+    call self.ui.render()
+endfunction
+

sources_non_forked/nerdtree/lib/nerdtree/notifier.vim

@@ -0,0 +1,35 @@
+"CLASS: Notifier
+"============================================================
+let s:Notifier = {}
+
+function! s:Notifier.AddListener(event, funcname)
+    let listeners = s:Notifier.GetListenersForEvent(a:event)
+    if listeners == []
+        let listenersMap = s:Notifier.GetListenersMap()
+        let listenersMap[a:event] = listeners
+    endif
+    call add(listeners, a:funcname)
+endfunction
+
+function! s:Notifier.NotifyListeners(event, path, params)
+    let event = g:NERDTreeEvent.New(b:NERDTree, a:path, a:event, a:params)
+
+    for listener in s:Notifier.GetListenersForEvent(a:event)
+        call {listener}(event)
+    endfor
+endfunction
+
+function! s:Notifier.GetListenersMap()
+    if !exists("s:refreshListenersMap")
+        let s:refreshListenersMap = {}
+    endif
+    return s:refreshListenersMap
+endfunction
+
+function! s:Notifier.GetListenersForEvent(name)
+    let listenersMap = s:Notifier.GetListenersMap()
+    return get(listenersMap, a:name, [])
+endfunction
+
+let g:NERDTreePathNotifier = deepcopy(s:Notifier)
+

sources_non_forked/nerdtree/lib/nerdtree/opener.vim

@@ -3,6 +3,29 @@
 let s:Opener = {}
 let g:NERDTreeOpener = s:Opener
 
+"FUNCTION: s:Opener._bufInWindows(bnum){{{1
+"[[STOLEN FROM VTREEEXPLORER.VIM]]
+"Determine the number of windows open to this buffer number.
+"Care of Yegappan Lakshman.  Thanks!
+"
+"Args:
+"bnum: the subject buffers buffer number
+function! s:Opener._bufInWindows(bnum)
+    let cnt = 0
+    let winnum = 1
+    while 1
+        let bufnum = winbufnr(winnum)
+        if bufnum < 0
+            break
+        endif
+        if bufnum ==# a:bnum
+            let cnt = cnt + 1
+        endif
+        let winnum = winnum + 1
+    endwhile
+
+    return cnt
+endfunction
 "FUNCTION: Opener._checkToCloseTree(newtab) {{{1
 "Check the class options and global options (i.e. NERDTreeQuitOnOpen) to see
 "if the tree should be closed now.
@@ -21,6 +44,24 @@ function! s:Opener._checkToCloseTree(newtab)
     endif
 endfunction
 
+
+"FUNCTION: s:Opener._firstUsableWindow(){{{1
+"find the window number of the first normal window
+function! s:Opener._firstUsableWindow()
+    let i = 1
+    while i <= winnr("$")
+        let bnum = winbufnr(i)
+        if bnum != -1 && getbufvar(bnum, '&buftype') ==# ''
+                    \ && !getwinvar(i, '&previewwindow')
+                    \ && (!getbufvar(bnum, '&modified') || &hidden)
+            return i
+        endif
+
+        let i += 1
+    endwhile
+    return -1
+endfunction
+
 "FUNCTION: Opener._gotoTargetWin() {{{1
 function! s:Opener._gotoTargetWin()
     if b:NERDTreeType ==# "secondary"
@@ -48,6 +89,37 @@ function! s:Opener._gotoTargetWin()
     endif
 endfunction
 
+"FUNCTION: s:Opener._isWindowUsable(winnumber) {{{1
+"Returns 0 if opening a file from the tree in the given window requires it to
+"be split, 1 otherwise
+"
+"Args:
+"winnumber: the number of the window in question
+function! s:Opener._isWindowUsable(winnumber)
+    "gotta split if theres only one window (i.e. the NERD tree)
+    if winnr("$") ==# 1
+        return 0
+    endif
+
+    let oldwinnr = winnr()
+    call nerdtree#exec(a:winnumber . "wincmd p")
+    let specialWindow = getbufvar("%", '&buftype') != '' || getwinvar('%', '&previewwindow')
+    let modified = &modified
+    call nerdtree#exec(oldwinnr . "wincmd p")
+
+    "if its a special window e.g. quickfix or another explorer plugin then we
+    "have to split
+    if specialWindow
+        return 0
+    endif
+
+    if &hidden
+        return 1
+    endif
+
+    return !modified || self._bufInWindows(winbufnr(a:winnumber)) >= 2
+endfunction
+
 "FUNCTION: Opener.New(path, opts) {{{1
 "Args:
 "
@@ -190,7 +262,7 @@ function! s:Opener._openDirectory(node)
         call self._gotoTargetWin()
         if empty(self._where)
             call a:node.makeRoot()
-            call nerdtree#renderView()
+            call b:NERDTree.render()
             call a:node.putCursorHere(0, 0)
         elseif self._where == 't'
             call g:NERDTreeCreator.CreatePrimary(a:node.path.str())
@@ -206,12 +278,12 @@ endfunction
 
 "FUNCTION: Opener._previousWindow() {{{1
 function! s:Opener._previousWindow()
-    if !nerdtree#isWindowUsable(winnr("#")) && nerdtree#firstUsableWindow() ==# -1
+    if !self._isWindowUsable(winnr("#")) && self._firstUsableWindow() ==# -1
         call self._newSplit()
     else
         try
-            if !nerdtree#isWindowUsable(winnr("#"))
-                call nerdtree#exec(nerdtree#firstUsableWindow() . "wincmd w")
+            if !self._isWindowUsable(winnr("#"))
+                call nerdtree#exec(self._firstUsableWindow() . "wincmd w")
             else
                 call nerdtree#exec('wincmd p')
             endif

sources_non_forked/nerdtree/lib/nerdtree/path.vim

@@ -33,8 +33,10 @@ function! s:Path.bookmarkNames()
 endfunction
 
 "FUNCTION: Path.cacheDisplayString() {{{1
-function! s:Path.cacheDisplayString()
-    let self.cachedDisplayString = self.getLastPathComponent(1)
+function! s:Path.cacheDisplayString() abort
+    let self.cachedDisplayString = self.flagSet.renderToString()
+
+    let self.cachedDisplayString .= self.getLastPathComponent(1)
 
     if self.isExecutable
         let self.cachedDisplayString = self.cachedDisplayString . '*'
@@ -103,6 +105,10 @@ function! s:Path.compareTo(path)
     elseif thisSS > thatSS
         return 1
     else
+        if !g:NERDTreeSortHiddenFirst
+            let thisPath = substitute(thisPath, '^[._]', '', '')
+            let thatPath = substitute(thatPath, '^[._]', '', '')
+        endif
         "if the sort sequences are the same then compare the paths
         "alphabetically
         let pathCompare = g:NERDTreeCaseSensitiveSort ? thisPath <# thatPath : thisPath <? thatPath
@@ -141,6 +147,7 @@ function! s:Path.Create(fullpath)
 
         "assume its a file and create
         else
+            call s:Path.createParentDirectories(a:fullpath)
             call writefile([], a:fullpath)
         endif
     catch
@@ -161,9 +168,11 @@ function! s:Path.copy(dest)
         throw "NERDTree.CopyingNotSupportedError: Copying is not supported on this OS"
     endif
 
+    call s:Path.createParentDirectories(a:dest)
+
     let dest = s:Path.WinToUnixPath(a:dest)
 
-    let cmd = g:NERDTreeCopyCmd . " " . escape(self.str(), nerdtree#escChars()) . " " . escape(dest, nerdtree#escChars())
+    let cmd = g:NERDTreeCopyCmd . " " . escape(self.str(), self._escChars()) . " " . escape(dest, self._escChars())
     let success = system(cmd)
     if success != 0
         throw "NERDTree.CopyError: Could not copy ''". self.str() ."'' to: '" . a:dest . "'"
@@ -197,6 +206,20 @@ function! s:Path.copyingWillOverwrite(dest)
     endif
 endfunction
 
+"FUNCTION: Path.createParentDirectories(path) {{{1
+"
+"create parent directories for this path if needed
+"without throwing any errors is those directories already exist
+"
+"Args:
+"path: full path of the node whose parent directories may need to be created
+function! s:Path.createParentDirectories(path)
+    let dir_path = fnamemodify(a:path, ':h')
+    if !isdirectory(dir_path)
+        call mkdir(dir_path, 'p')
+    endif
+endfunction
+
 "FUNCTION: Path.delete() {{{1
 "
 "Deletes the file represented by this path.
@@ -268,6 +291,15 @@ function! s:Path.exists()
     return filereadable(p) || isdirectory(p)
 endfunction
 
+"FUNCTION: Path._escChars() {{{1
+function! s:Path._escChars()
+    if nerdtree#runningWindows()
+        return " `\|\"#%&,?()\*^<>"
+    endif
+
+    return " \\`\|\"#%&,?()\*^<>[]"
+endfunction
+
 "FUNCTION: Path.getDir() {{{1
 "
 "Returns this path if it is a directory, else this paths parent.
@@ -439,6 +471,7 @@ function! s:Path.New(path)
     call newPath.readInfoFromDisk(s:Path.AbsolutePathFor(a:path))
 
     let newPath.cachedDisplayString = ""
+    let newPath.flagSet = g:NERDTreeFlagSet.New()
 
     return newPath
 endfunction
@@ -516,6 +549,13 @@ endfunction
 "FUNCTION: Path.refresh() {{{1
 function! s:Path.refresh()
     call self.readInfoFromDisk(self.str())
+    call g:NERDTreePathNotifier.NotifyListeners('refresh', self, {})
+    call self.cacheDisplayString()
+endfunction
+
+"FUNCTION: Path.refreshFlags() {{{1
+function! s:Path.refreshFlags()
+    call g:NERDTreePathNotifier.NotifyListeners('refreshFlags', self, {})
     call self.cacheDisplayString()
 endfunction
 
@@ -604,7 +644,7 @@ endfunction
 "
 " returns a string that can be used with :cd
 function! s:Path._strForCd()
-    return escape(self.str(), nerdtree#escChars())
+    return escape(self.str(), self._escChars())
 endfunction
 
 "FUNCTION: Path._strForEdit() {{{1
@@ -612,7 +652,7 @@ endfunction
 "Return: the string for this path that is suitable to be used with the :edit
 "command
 function! s:Path._strForEdit()
-    let p = escape(self.str({'format': 'UI'}), nerdtree#escChars())
+    let p = escape(self.str({'format': 'UI'}), self._escChars())
     let cwd = getcwd() . s:Path.Slash()
 
     "return a relative path if we can
@@ -652,7 +692,7 @@ function! s:Path._strForGlob()
     let toReturn = lead . join(self.pathSegments, s:Path.Slash())
 
     if !nerdtree#runningWindows()
-        let toReturn = escape(toReturn, nerdtree#escChars())
+        let toReturn = escape(toReturn, self._escChars())
     endif
     return toReturn
 endfunction

sources_non_forked/nerdtree/lib/nerdtree/tree_dir_node.vim

@@ -21,7 +21,7 @@ unlet s:TreeDirNode.activate
 function! s:TreeDirNode.activate(...)
     let opts = a:0 ? a:1 : {}
     call self.toggleOpen(opts)
-    call nerdtree#renderView()
+    call b:NERDTree.render()
     call self.putCursorHere(0, 0)
 endfunction
 
@@ -229,7 +229,7 @@ function! s:TreeDirNode._initChildren(silent)
     let globDir = dir.str({'format': 'Glob'})
 
     if version >= 703
-        let filesStr = globpath(globDir, '*', 1) . "\n" . globpath(globDir, '.*', 1)
+        let filesStr = globpath(globDir, '*', !g:NERDTreeRespectWildIgnore) . "\n" . globpath(globDir, '.*', !g:NERDTreeRespectWildIgnore)
     else
         let filesStr = globpath(globDir, '*') . "\n" . globpath(globDir, '.*')
     endif
@@ -252,6 +252,7 @@ function! s:TreeDirNode._initChildren(silent)
             try
                 let path = g:NERDTreePath.New(i)
                 call self.createChild(path, 0)
+                call g:NERDTreePathNotifier.NotifyListeners('init', path, {})
             catch /^NERDTree.\(InvalidArguments\|InvalidFiletype\)Error/
                 let invalidFilesFound += 1
             endtry
@@ -438,6 +439,20 @@ function! s:TreeDirNode.refresh()
     endif
 endfunction
 
+"FUNCTION: TreeDirNode.refreshFlags() {{{1
+unlet s:TreeDirNode.refreshFlags
+function! s:TreeDirNode.refreshFlags()
+    call self.path.refreshFlags()
+    for i in self.children
+        call i.refreshFlags()
+    endfor
+endfunction
+
+"FUNCTION: TreeDirNode.refreshDirFlags() {{{1
+function! s:TreeDirNode.refreshDirFlags()
+    call self.path.refreshFlags()
+endfunction
+
 "FUNCTION: TreeDirNode.reveal(path) {{{1
 "reveal the given path, i.e. cache and open all treenodes needed to display it
 "in the UI
@@ -450,7 +465,7 @@ function! s:TreeDirNode.reveal(path)
 
     if self.path.equals(a:path.getParent())
         let n = self.findNode(a:path)
-        call nerdtree#renderView()
+        call b:NERDTree.render()
         call n.putCursorHere(1,0)
         return
     endif
@@ -500,7 +515,7 @@ function! s:TreeDirNode.toggleOpen(...)
     if self.isOpen ==# 1
         call self.close()
     else
-        if g:NERDTreeCasadeOpenSingleChildDir == 0
+        if g:NERDTreeCascadeOpenSingleChildDir == 0
             call self.open(opts)
         else
             call self.openAlong(opts)

sources_non_forked/nerdtree/lib/nerdtree/tree_file_node.vim

@@ -178,79 +178,20 @@ function! s:TreeFileNode.findSibling(direction)
     return {}
 endfunction
 
-"FUNCTION: TreeFileNode.getLineNum(){{{1
-"returns the line number this node is rendered on, or -1 if it isnt rendered
-function! s:TreeFileNode.getLineNum()
-    "if the node is the root then return the root line no.
-    if self.isRoot()
-        return s:TreeFileNode.GetRootLineNum()
-    endif
-
-    let totalLines = line("$")
-
-    "the path components we have matched so far
-    let pathcomponents = [substitute(b:NERDTreeRoot.path.str({'format': 'UI'}), '/ *$', '', '')]
-    "the index of the component we are searching for
-    let curPathComponent = 1
-
-    let fullpath = self.path.str({'format': 'UI'})
-
-
-    let lnum = s:TreeFileNode.GetRootLineNum()
-    while lnum > 0
-        let lnum = lnum + 1
-        "have we reached the bottom of the tree?
-        if lnum ==# totalLines+1
-            return -1
-        endif
-
-        let curLine = getline(lnum)
-
-        let indent = nerdtree#indentLevelFor(curLine)
-        if indent ==# curPathComponent
-            let curLine = nerdtree#stripMarkupFromLine(curLine, 1)
-
-            let curPath =  join(pathcomponents, '/') . '/' . curLine
-            if stridx(fullpath, curPath, 0) ==# 0
-                if fullpath ==# curPath || strpart(fullpath, len(curPath)-1,1) ==# '/'
-                    let curLine = substitute(curLine, '/ *$', '', '')
-                    call add(pathcomponents, curLine)
-                    let curPathComponent = curPathComponent + 1
-
-                    if fullpath ==# curPath
-                        return lnum
-                    endif
-                endif
-            endif
-        endif
-    endwhile
-    return -1
-endfunction
-
 "FUNCTION: TreeFileNode.GetRootForTab(){{{1
 "get the root node for this tab
 function! s:TreeFileNode.GetRootForTab()
-    if nerdtree#treeExistsForTab()
+    if g:NERDTree.ExistsForTab()
         return getbufvar(t:NERDTreeBufName, 'NERDTreeRoot')
     end
     return {}
 endfunction
 
-"FUNCTION: TreeFileNode.GetRootLineNum(){{{1
-"gets the line number of the root node
-function! s:TreeFileNode.GetRootLineNum()
-    let rootLine = 1
-    while getline(rootLine) !~# '^\(/\|<\)'
-        let rootLine = rootLine + 1
-    endwhile
-    return rootLine
-endfunction
-
 "FUNCTION: TreeFileNode.GetSelected() {{{1
 "gets the treenode that the cursor is currently over
 function! s:TreeFileNode.GetSelected()
     try
-        let path = nerdtree#getPath(line("."))
+        let path = b:NERDTree.ui.getPath(line("."))
         if path ==# {}
             return {}
         endif
@@ -270,7 +211,7 @@ endfunction
 "FUNCTION: TreeFileNode.isRoot() {{{1
 "returns 1 if this node is b:NERDTreeRoot
 function! s:TreeFileNode.isRoot()
-    if !nerdtree#treeExistsForBuf()
+    if !g:NERDTree.ExistsForBuf()
         throw "NERDTree.NoTreeError: No tree exists for the current buffer"
     endif
 
@@ -348,7 +289,7 @@ endfunction
 "recurseUpward: try to put the cursor on the parent if the this node isnt
 "visible
 function! s:TreeFileNode.putCursorHere(isJump, recurseUpward)
-    let ln = self.getLineNum()
+    let ln = b:NERDTree.ui.getLineNum(self)
     if ln != -1
         if a:isJump
             mark '
@@ -357,11 +298,11 @@ function! s:TreeFileNode.putCursorHere(isJump, recurseUpward)
     else
         if a:recurseUpward
             let node = self
-            while node != {} && node.getLineNum() ==# -1
+            while node != {} && b:NERDTree.ui.getLineNum(node) ==# -1
                 let node = node.parent
                 call node.open()
             endwhile
-            call nerdtree#renderView()
+            call b:NERDTree.render()
             call node.putCursorHere(a:isJump, 0)
         endif
     endif
@@ -372,6 +313,11 @@ function! s:TreeFileNode.refresh()
     call self.path.refresh()
 endfunction
 
+"FUNCTION: TreeFileNode.refreshFlags() {{{1
+function! s:TreeFileNode.refreshFlags()
+    call self.path.refreshFlags()
+endfunction
+
 "FUNCTION: TreeFileNode.rename() {{{1
 "Calls the rename method for this nodes path obj
 function! s:TreeFileNode.rename(newName)

sources_non_forked/nerdtree/lib/nerdtree/ui.vim

@@ -0,0 +1,332 @@
+"CLASS: UI
+"============================================================
+let s:UI = {}
+let g:NERDTreeUI = s:UI
+
+
+function! s:UI.lolcats()
+    echomsg "lolcats"
+endfunction
+
+"FUNCTION: s:UI.centerView() {{{2
+"centers the nerd tree window around the cursor (provided the nerd tree
+"options permit)
+function! s:UI.centerView()
+    if g:NERDTreeAutoCenter
+        let current_line = winline()
+        let lines_to_top = current_line
+        let lines_to_bottom = winheight(nerdtree#getTreeWinNum()) - current_line
+        if lines_to_top < g:NERDTreeAutoCenterThreshold || lines_to_bottom < g:NERDTreeAutoCenterThreshold
+            normal! zz
+        endif
+    endif
+endfunction
+
+"FUNCTION: s:UI.new(nerdtree) {{{1
+function! s:UI.New(nerdtree)
+    let newObj = copy(self)
+    let newObj.nerdtree = a:nerdtree
+    return newObj
+endfunction
+
+"FUNCTION: s:UI.getPath(ln) {{{1
+"Gets the full path to the node that is rendered on the given line number
+"
+"Args:
+"ln: the line number to get the path for
+"
+"Return:
+"A path if a node was selected, {} if nothing is selected.
+"If the 'up a dir' line was selected then the path to the parent of the
+"current root is returned
+function! s:UI.getPath(ln)
+    let line = getline(a:ln)
+
+    let rootLine = self.getRootLineNum()
+
+    "check to see if we have the root node
+    if a:ln == rootLine
+        return b:NERDTreeRoot.path
+    endif
+
+    if !g:NERDTreeDirArrows
+        " in case called from outside the tree
+        if line !~# '^ *[|`▸▾ ]' || line =~# '^$'
+            return {}
+        endif
+    endif
+
+    if line ==# nerdtree#treeUpDirLine()
+        return b:NERDTreeRoot.path.getParent()
+    endif
+
+    let indent = self._indentLevelFor(line)
+
+    "remove the tree parts and the leading space
+    let curFile = nerdtree#stripMarkupFromLine(line, 0)
+
+    let wasdir = 0
+    if curFile =~# '/$'
+        let wasdir = 1
+        let curFile = substitute(curFile, '/\?$', '/', "")
+    endif
+
+    let dir = ""
+    let lnum = a:ln
+    while lnum > 0
+        let lnum = lnum - 1
+        let curLine = getline(lnum)
+        let curLineStripped = nerdtree#stripMarkupFromLine(curLine, 1)
+
+        "have we reached the top of the tree?
+        if lnum == rootLine
+            let dir = b:NERDTreeRoot.path.str({'format': 'UI'}) . dir
+            break
+        endif
+        if curLineStripped =~# '/$'
+            let lpindent = self._indentLevelFor(curLine)
+            if lpindent < indent
+                let indent = indent - 1
+
+                let dir = substitute (curLineStripped,'^\\', "", "") . dir
+                continue
+            endif
+        endif
+    endwhile
+    let curFile = b:NERDTreeRoot.path.drive . dir . curFile
+    let toReturn = g:NERDTreePath.New(curFile)
+    return toReturn
+endfunction
+
+"FUNCTION: s:UI.getLineNum(file_node){{{1
+"returns the line number this node is rendered on, or -1 if it isnt rendered
+function! s:UI.getLineNum(file_node)
+    "if the node is the root then return the root line no.
+    if a:file_node.isRoot()
+        return b:NERDTree.ui.getRootLineNum()
+    endif
+
+    let totalLines = line("$")
+
+    "the path components we have matched so far
+    let pathcomponents = [substitute(b:NERDTreeRoot.path.str({'format': 'UI'}), '/ *$', '', '')]
+    "the index of the component we are searching for
+    let curPathComponent = 1
+
+    let fullpath = a:file_node.path.str({'format': 'UI'})
+
+    let lnum = b:NERDTree.ui.getRootLineNum()
+    while lnum > 0
+        let lnum = lnum + 1
+        "have we reached the bottom of the tree?
+        if lnum ==# totalLines+1
+            return -1
+        endif
+
+        let curLine = getline(lnum)
+
+        let indent = self._indentLevelFor(curLine)
+        if indent ==# curPathComponent
+            let curLine = nerdtree#stripMarkupFromLine(curLine, 1)
+
+            let curPath =  join(pathcomponents, '/') . '/' . curLine
+            if stridx(fullpath, curPath, 0) ==# 0
+                if fullpath ==# curPath || strpart(fullpath, len(curPath)-1,1) ==# '/'
+                    let curLine = substitute(curLine, '/ *$', '', '')
+                    call add(pathcomponents, curLine)
+                    let curPathComponent = curPathComponent + 1
+
+                    if fullpath ==# curPath
+                        return lnum
+                    endif
+                endif
+            endif
+        endif
+    endwhile
+    return -1
+endfunction
+
+
+"FUNCTION: s:UI.getRootLineNum(){{{1
+"gets the line number of the root node
+function! s:UI.getRootLineNum()
+    let rootLine = 1
+    while getline(rootLine) !~# '^\(/\|<\)'
+        let rootLine = rootLine + 1
+    endwhile
+    return rootLine
+endfunction
+
+"FUNCTION: s:UI._indentLevelFor(line) {{{2
+function! s:UI._indentLevelFor(line)
+    let level = match(a:line, '[^ \-+~▸▾`|]') / nerdtree#treeWid()
+    " check if line includes arrows
+    if match(a:line, '[▸▾]') > -1
+        " decrement level as arrow uses 3 ascii chars
+        let level = level - 1
+    endif
+    return level
+endfunction
+
+
+"FUNCTION: s:UI.restoreScreenState() {{{2
+"
+"Sets the screen state back to what it was when nerdtree#saveScreenState was last
+"called.
+"
+"Assumes the cursor is in the NERDTree window
+function! s:UI.restoreScreenState()
+    if !has_key(self, '_screenState')
+        return
+    endif
+    exec("silent vertical resize " . self._screenState['oldWindowSize'])
+
+    let old_scrolloff=&scrolloff
+    let &scrolloff=0
+    call cursor(self._screenState['oldTopLine'], 0)
+    normal! zt
+    call setpos(".", self._screenState['oldPos'])
+    let &scrolloff=old_scrolloff
+endfunction
+
+"FUNCTION: s:UI.saveScreenState() {{{2
+"Saves the current cursor position in the current buffer and the window
+"scroll position
+function! s:UI.saveScreenState()
+    let win = winnr()
+    try
+        call nerdtree#putCursorInTreeWin()
+        let self._screenState = {}
+        let self._screenState['oldPos'] = getpos(".")
+        let self._screenState['oldTopLine'] = line("w0")
+        let self._screenState['oldWindowSize']= winwidth("")
+        call nerdtree#exec(win . "wincmd w")
+    catch /^NERDTree.InvalidOperationError/
+    endtry
+endfunction
+
+"FUNCTION: s:UI.render() {{{2
+function! s:UI.render()
+    setlocal modifiable
+
+    "remember the top line of the buffer and the current line so we can
+    "restore the view exactly how it was
+    let curLine = line(".")
+    let curCol = col(".")
+    let topLine = line("w0")
+
+    "delete all lines in the buffer (being careful not to clobber a register)
+    silent 1,$delete _
+
+    call nerdtree#dumpHelp()
+
+    "delete the blank line before the help and add one after it
+    if g:NERDTreeMinimalUI == 0
+        call setline(line(".")+1, "")
+        call cursor(line(".")+1, col("."))
+    endif
+
+    if b:NERDTreeShowBookmarks
+        call nerdtree#renderBookmarks()
+    endif
+
+    "add the 'up a dir' line
+    if !g:NERDTreeMinimalUI
+        call setline(line(".")+1, nerdtree#treeUpDirLine())
+        call cursor(line(".")+1, col("."))
+    endif
+
+    "draw the header line
+    let header = b:NERDTreeRoot.path.str({'format': 'UI', 'truncateTo': winwidth(0)})
+    call setline(line(".")+1, header)
+    call cursor(line(".")+1, col("."))
+
+    "draw the tree
+    let old_o = @o
+    let @o = b:NERDTreeRoot.renderToString()
+    silent put o
+    let @o = old_o
+
+    "delete the blank line at the top of the buffer
+    silent 1,1delete _
+
+    "restore the view
+    let old_scrolloff=&scrolloff
+    let &scrolloff=0
+    call cursor(topLine, 1)
+    normal! zt
+    call cursor(curLine, curCol)
+    let &scrolloff = old_scrolloff
+
+    setlocal nomodifiable
+endfunction
+
+
+"FUNCTION: UI.renderViewSavingPosition {{{1
+"Renders the tree and ensures the cursor stays on the current node or the
+"current nodes parent if it is no longer available upon re-rendering
+function! s:UI.renderViewSavingPosition()
+    let currentNode = g:NERDTreeFileNode.GetSelected()
+
+    "go up the tree till we find a node that will be visible or till we run
+    "out of nodes
+    while currentNode != {} && !currentNode.isVisible() && !currentNode.isRoot()
+        let currentNode = currentNode.parent
+    endwhile
+
+    call b:NERDTree.render()
+
+    if currentNode != {}
+        call currentNode.putCursorHere(0, 0)
+    endif
+endfunction
+
+" FUNCTION: s:UI.toggleIgnoreFilter() {{{1
+" toggles the use of the NERDTreeIgnore option
+function! s:UI.toggleIgnoreFilter()
+    let b:NERDTreeIgnoreEnabled = !b:NERDTreeIgnoreEnabled
+    call b:NERDTree.ui.renderViewSavingPosition()
+    call b:NERDTree.ui.centerView()
+endfunction
+
+" FUNCTION: s:UI.toggleShowBookmarks() {{{1
+" toggles the display of bookmarks
+function! s:UI.toggleShowBookmarks()
+    let b:NERDTreeShowBookmarks = !b:NERDTreeShowBookmarks
+    if b:NERDTreeShowBookmarks
+        call b:NERDTree.render()
+        call nerdtree#putCursorOnBookmarkTable()
+    else
+        call b:NERDTree.ui.renderViewSavingPosition()
+    endif
+    call b:NERDTree.ui.centerView()
+endfunction
+
+" FUNCTION: s:UI.toggleShowFiles() {{{1
+" toggles the display of hidden files
+function! s:UI.toggleShowFiles()
+    let b:NERDTreeShowFiles = !b:NERDTreeShowFiles
+    call b:NERDTree.ui.renderViewSavingPosition()
+    call b:NERDTree.ui.centerView()
+endfunction
+
+" FUNCTION: s:UI.toggleShowHidden() {{{1
+" toggles the display of hidden files
+function! s:UI.toggleShowHidden()
+    let b:NERDTreeShowHidden = !b:NERDTreeShowHidden
+    call b:NERDTree.ui.renderViewSavingPosition()
+    call self.centerView()
+endfunction
+
+" FUNCTION: s:UI.toggleZoom() {{{1
+" zoom (maximize/minimize) the NERDTree window
+function! s:UI.toggleZoom()
+    if exists("b:NERDTreeZoomed") && b:NERDTreeZoomed
+        let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
+        exec "silent vertical resize ". size
+        let b:NERDTreeZoomed = 0
+    else
+        exec "vertical resize"
+        let b:NERDTreeZoomed = 1
+    endif
+endfunction

sources_non_forked/nerdtree/nerdtree_plugin/fs_menu.vim

@@ -82,13 +82,14 @@ endfunction
 function! s:promptToRenameBuffer(bufnum, msg, newFileName)
     echo a:msg
     if g:NERDTreeAutoDeleteBuffer || nr2char(getchar()) ==# 'y'
+        let quotedFileName = "'" . a:newFileName . "'"
         " 1. ensure that a new buffer is loaded
-        exec "badd " . a:newFileName
+        exec "badd " . quotedFileName
         " 2. ensure that all windows which display the just deleted filename
         " display a buffer for a new filename. 
         let s:originalTabNumber = tabpagenr()
         let s:originalWindowNumber = winnr()
-        exec "tabdo windo if winbufnr(0) == " . a:bufnum . " | exec ':e! " . a:newFileName . "' | endif"
+        exec "tabdo windo if winbufnr(0) == " . a:bufnum . " | exec \":e! " . quotedFileName . "\" | endif"
         exec "tabnext " . s:originalTabNumber
         exec s:originalWindowNumber . "wincmd w"
         " 3. We don't need a previous buffer anymore
@@ -114,7 +115,10 @@ function! NERDTreeAddNode()
         let parentNode = b:NERDTreeRoot.findNode(newPath.getParent())
 
         let newTreeNode = g:NERDTreeFileNode.New(newPath)
-        if parentNode.isOpen || !empty(parentNode.children)
+        if empty(parentNode)
+            call b:NERDTreeRoot.refresh()
+            call b:NERDTree.render()
+        elseif parentNode.isOpen || !empty(parentNode.children)
             call parentNode.addChild(newTreeNode, 1)
             call NERDTreeRender()
             call newTreeNode.putCursorHere(1, 0)
@@ -138,7 +142,7 @@ function! NERDTreeMoveNode()
     endif
 
     try
-        let bufnum = bufnr(curNode.path.str())
+        let bufnum = bufnr("^".curNode.path.str()."$")
 
         call curNode.rename(newNodePath)
         call NERDTreeRender()
@@ -186,7 +190,7 @@ function! NERDTreeDeleteNode()
 
             "if the node is open in a buffer, ask the user if they want to
             "close that buffer
-            let bufnum = bufnr(currentNode.path.str())
+            let bufnum = bufnr("^".currentNode.path.str()."$")
             if buflisted(bufnum)
                 let prompt = "\nNode deleted.\n\nThe file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Delete this buffer? (yN)"
                 call s:promptToDelBuffer(bufnum, prompt)
@@ -224,7 +228,10 @@ function! NERDTreeCopyNode()
         if confirmed
             try
                 let newNode = currentNode.copy(newNodePath)
-                if !empty(newNode)
+                if empty(newNode)
+                    call b:NERDTreeRoot.refresh()
+                    call b:NERDTree.render()
+                else
                     call NERDTreeRender()
                     call newNode.putCursorHere(0, 0)
                 endif

sources_non_forked/nerdtree/plugin/NERD_tree.vim

@@ -45,28 +45,30 @@ function! s:initVariable(var, value)
 endfunction
 
 "SECTION: Init variable calls and other random constants {{{2
-call s:initVariable("g:NERDChristmasTree", 1)
 call s:initVariable("g:NERDTreeAutoCenter", 1)
 call s:initVariable("g:NERDTreeAutoCenterThreshold", 3)
 call s:initVariable("g:NERDTreeCaseSensitiveSort", 0)
+call s:initVariable("g:NERDTreeSortHiddenFirst", 1)
 call s:initVariable("g:NERDTreeChDirMode", 0)
 call s:initVariable("g:NERDTreeMinimalUI", 0)
 if !exists("g:NERDTreeIgnore")
     let g:NERDTreeIgnore = ['\~$']
 endif
 call s:initVariable("g:NERDTreeBookmarksFile", expand('$HOME') . '/.NERDTreeBookmarks')
+call s:initVariable("g:NERDTreeBookmarksSort", 1)
 call s:initVariable("g:NERDTreeHighlightCursorline", 1)
 call s:initVariable("g:NERDTreeHijackNetrw", 1)
 call s:initVariable("g:NERDTreeMouseMode", 1)
 call s:initVariable("g:NERDTreeNotificationThreshold", 100)
 call s:initVariable("g:NERDTreeQuitOnOpen", 0)
+call s:initVariable("g:NERDTreeRespectWildIgnore", 0)
 call s:initVariable("g:NERDTreeShowBookmarks", 0)
 call s:initVariable("g:NERDTreeShowFiles", 1)
 call s:initVariable("g:NERDTreeShowHidden", 0)
 call s:initVariable("g:NERDTreeShowLineNumbers", 0)
 call s:initVariable("g:NERDTreeSortDirs", 1)
 call s:initVariable("g:NERDTreeDirArrows", !nerdtree#runningWindows())
-call s:initVariable("g:NERDTreeCasadeOpenSingleChildDir", 1)
+call s:initVariable("g:NERDTreeCascadeOpenSingleChildDir", 1)
 
 if !exists("g:NERDTreeSortOrder")
     let g:NERDTreeSortOrder = ['\/$', '*', '\.swp$',  '\.bak$', '\~$']
@@ -140,20 +142,13 @@ call nerdtree#loadClassFiles()
 
 " SECTION: Commands {{{1
 "============================================================
-"init the command that users start the nerd tree with
-command! -n=? -complete=dir -bar NERDTree :call g:NERDTreeCreator.CreatePrimary('<args>')
-command! -n=? -complete=dir -bar NERDTreeToggle :call g:NERDTreeCreator.TogglePrimary('<args>')
-command! -n=0 -bar NERDTreeClose :call nerdtree#closeTreeIfOpen()
-command! -n=1 -complete=customlist,nerdtree#completeBookmarks -bar NERDTreeFromBookmark call g:NERDTreeCreator.CreatePrimary('<args>')
-command! -n=0 -bar NERDTreeMirror call g:NERDTreeCreator.CreateMirror()
-command! -n=0 -bar NERDTreeFind call nerdtree#findAndRevealPath()
-command! -n=0 -bar NERDTreeFocus call NERDTreeFocus()
-command! -n=0 -bar NERDTreeCWD call NERDTreeCWD()
+call nerdtree#ui_glue#setupCommands()
+
 " SECTION: Auto commands {{{1
 "============================================================
 augroup NERDTree
     "Save the cursor position whenever we close the nerd tree
-    exec "autocmd BufWinLeave ". g:NERDTreeCreator.BufNamePrefix() ."* call nerdtree#saveScreenState()"
+    exec "autocmd BufLeave ". g:NERDTreeCreator.BufNamePrefix() ."* call b:NERDTree.ui.saveScreenState()"
 
     "disallow insert mode in the NERDTree
     exec "autocmd BufEnter ". g:NERDTreeCreator.BufNamePrefix() ."* stopinsert"
@@ -199,7 +194,7 @@ endfunction
 
 function! NERDTreeCWD()
     call NERDTreeFocus()
-    call nerdtree#chRootCwd()
+    call nerdtree#ui_glue#chRootCwd()
 endfunction
 " SECTION: Post Source Actions {{{1
 call nerdtree#postSourceActions()

sources_non_forked/nerdtree/syntax/nerdtree.vim

@@ -1,44 +1,64 @@
 let s:tree_up_dir_line = '.. (up a dir)'
-"NERDTreeFlags are syntax items that should be invisible, but give clues as to
-"how things should be highlighted
-syn match NERDTreeFlag #\~#
-syn match NERDTreeFlag #\[RO\]#
+syn match NERDTreeIgnore #\~#
+syn match NERDTreeIgnore #\[RO\]#
 
 "highlighting for the .. (up dir) line at the top of the tree
 execute "syn match NERDTreeUp #\\V". s:tree_up_dir_line ."#"
 
-"highlighting for the ~/+ symbols for the directory nodes
-syn match NERDTreeClosable #\~\<#
-syn match NERDTreeClosable #\~\.#
-syn match NERDTreeOpenable #+\<#
-syn match NERDTreeOpenable #+\.#he=e-1
-
-"highlighting for the tree structural parts
-syn match NERDTreePart #|#
-syn match NERDTreePart #`#
-syn match NERDTreePartFile #[|`]-#hs=s+1 contains=NERDTreePart
-
 "quickhelp syntax elements
-syn match NERDTreeHelpKey #" \{1,2\}[^ ]*:#hs=s+2,he=e-1
-syn match NERDTreeHelpKey #" \{1,2\}[^ ]*,#hs=s+2,he=e-1
-syn match NERDTreeHelpTitle #" .*\~#hs=s+2,he=e-1 contains=NERDTreeFlag
-syn match NERDTreeToggleOn #".*(on)#hs=e-2,he=e-1 contains=NERDTreeHelpKey
-syn match NERDTreeToggleOff #".*(off)#hs=e-3,he=e-1 contains=NERDTreeHelpKey
+syn match NERDTreeHelpKey #" \{1,2\}[^ ]*:#ms=s+2,me=e-1
+syn match NERDTreeHelpKey #" \{1,2\}[^ ]*,#ms=s+2,me=e-1
+syn match NERDTreeHelpTitle #" .*\~#ms=s+2,me=e-1
+syn match NERDTreeToggleOn #(on)#ms=s+1,he=e-1
+syn match NERDTreeToggleOff #(off)#ms=e-3,me=e-1
 syn match NERDTreeHelpCommand #" :.\{-}\>#hs=s+3
-syn match NERDTreeHelp  #^".*# contains=NERDTreeHelpKey,NERDTreeHelpTitle,NERDTreeFlag,NERDTreeToggleOff,NERDTreeToggleOn,NERDTreeHelpCommand
-
-"highlighting for readonly files
-syn match NERDTreeRO #.*\[RO\]#hs=s+2 contains=NERDTreeFlag,NERDTreeBookmark,NERDTreePart,NERDTreePartFile
+syn match NERDTreeHelp  #^".*# contains=NERDTreeHelpKey,NERDTreeHelpTitle,NERDTreeIgnore,NERDTreeToggleOff,NERDTreeToggleOn,NERDTreeHelpCommand
 
 "highlighting for sym links
-syn match NERDTreeLink #[^-| `].* -> # contains=NERDTreeBookmark,NERDTreeOpenable,NERDTreeClosable,NERDTreeDirSlash
+syn match NERDTreeLinkTarget #->.*# containedin=NERDTreeDir,NERDTreeFile
+syn match NERDTreeLinkFile #.* ->#me=e-3 containedin=NERDTreeFile
+syn match NERDTreeLinkDir #.*/ ->#me=e-3 containedin=NERDTreeDir
 
 "highlighing for directory nodes and file nodes
-syn match NERDTreeDirSlash #/#
-syn match NERDTreeDir #[^-| `].*/# contains=NERDTreeLink,NERDTreeDirSlash,NERDTreeOpenable,NERDTreeClosable
-syn match NERDTreeExecFile  #[|` ].*\*\($\| \)# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark
-syn match NERDTreeFile  #|-.*# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark,NERDTreeExecFile
-syn match NERDTreeFile  #`-.*# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark,NERDTreeExecFile
+syn match NERDTreeDirSlash #/# containedin=NERDTreeDir
+
+if g:NERDTreeDirArrows
+    syn match NERDTreeClosable #▾# containedin=NERDTreeDir,NERDTreeFile
+    syn match NERDTreeOpenable #▸# containedin=NERDTreeDir,NERDTreeFile
+
+    syn match NERDTreeDir #[^▾▸ ].*/#
+    syn match NERDTreeExecFile  #^ .*\*\($\| \)# contains=NERDTreeRO,NERDTreeBookmark
+    syn match NERDTreeFile  #^[^"\.▾▸] *[^▾▸]*# contains=NERDTreeLink,NERDTreeRO,NERDTreeBookmark,NERDTreeExecFile
+
+    "highlighting for readonly files
+    syn match NERDTreeRO # *\zs.*\ze \[RO\]# contains=NERDTreeIgnore,NERDTreeBookmark,NERDTreeFile
+
+    syn match NERDTreeFlags #^ *\zs\[.\]# containedin=NERDTreeFile
+    syn match NERDTreeFlags #\[.\]# containedin=NERDTreeDir
+else
+    "highlighting for the ~/+ symbols for the directory nodes
+    syn match NERDTreeClosable #\~\<#
+    syn match NERDTreeClosable #\~\.#
+    syn match NERDTreeOpenable #+\<#
+    syn match NERDTreeOpenable #+\.#he=e-1
+
+    "highlighting for the tree structural parts
+    syn match NERDTreePart #|#
+    syn match NERDTreePart #`#
+    syn match NERDTreePartFile #[|`]-#hs=s+1 contains=NERDTreePart
+
+    syn match NERDTreeDir #[^-| `].*/# contains=NERDTreeLink,NERDTreeOpenable,NERDTreeClosable
+    syn match NERDTreeExecFile  #[|` ].*\*\($\| \)# contains=NERDTreeLink,NERDTreePart,NERDTreePartFile,NERDTreeBookmark
+    syn match NERDTreeFile  #|-.*# contains=NERDTreeLink,NERDTreePart,NERDTreePartFile,NERDTreeBookmark,NERDTreeExecFile
+    syn match NERDTreeFile  #`-.*# contains=NERDTreeLink,NERDTreePart,NERDTreePartFile,NERDTreeBookmark,NERDTreeExecFile
+
+    "highlighting for readonly files
+    syn match NERDTreeRO #|-.*\[RO\]#he=e-5 contains=NERDTreeIgnore,NERDTreeBookmark,NERDTreePart,NERDTreePartFile
+
+    syn match NERDTreeFlags #-\[.\]# containedin=NERDTreeFile,NERDTreePartFile
+    syn match NERDTreeFlags #[+~]\zs\[.\]# containedin=NERDTreeDir
+endif
+
 syn match NERDTreeCWD #^[</].*$#
 
 "highlighting for bookmarks
@@ -50,19 +70,10 @@ syn match NERDTreeBookmarksHeader #^>-\+Bookmarks-\+$# contains=NERDTreeBookmark
 syn match NERDTreeBookmarkName #^>.\{-} #he=e-1 contains=NERDTreeBookmarksLeader
 syn match NERDTreeBookmark #^>.*$# contains=NERDTreeBookmarksLeader,NERDTreeBookmarkName,NERDTreeBookmarksHeader
 
-if exists("g:NERDChristmasTree") && g:NERDChristmasTree
-    hi def link NERDTreePart Special
-    hi def link NERDTreePartFile Type
-    hi def link NERDTreeFile Normal
-    hi def link NERDTreeExecFile Title
-    hi def link NERDTreeDirSlash Identifier
-    hi def link NERDTreeClosable Type
-else
-    hi def link NERDTreePart Normal
-    hi def link NERDTreePartFile Normal
-    hi def link NERDTreeFile Normal
-    hi def link NERDTreeClosable Title
-endif
+hi def link NERDTreePart Special
+hi def link NERDTreePartFile Type
+hi def link NERDTreeExecFile Title
+hi def link NERDTreeDirSlash Identifier
 
 hi def link NERDTreeBookmarksHeader statement
 hi def link NERDTreeBookmarksLeader ignore
@@ -76,13 +87,19 @@ hi def link NERDTreeHelpTitle Macro
 hi def link NERDTreeToggleOn Question
 hi def link NERDTreeToggleOff WarningMsg
 
+hi def link NERDTreeLinkTarget Type
+hi def link NERDTreeLinkFile Macro
+hi def link NERDTreeLinkDir Macro
+
 hi def link NERDTreeDir Directory
 hi def link NERDTreeUp Directory
+hi def link NERDTreeFile Normal
 hi def link NERDTreeCWD Statement
-hi def link NERDTreeLink Macro
 hi def link NERDTreeOpenable Title
-hi def link NERDTreeFlag ignore
+hi def link NERDTreeClosable Title
+hi def link NERDTreeIgnore ignore
 hi def link NERDTreeRO WarningMsg
 hi def link NERDTreeBookmark Statement
+hi def link NERDTreeFlags Number
 
 hi def link NERDTreeCurrentNode Search

sources_non_forked/syntastic/CONTRIBUTING.md

@@ -1,43 +1,92 @@
-# Bug reports / Github issues
+# CONTRIBUTING
+- - -
+1\. [Bug reports / GitHub issues](#bugreps)  
+2\. [Submitting a patch](#patches)  
+3\. [General style notes](#generalstyle)  
+4\. [Syntax checker notes](#checkerstyle)  
+- - -
 
-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.
+<a name="bugreps"></a>
+
+## 1. Bug reports / GitHub issues
+
+Please note that the preferred channel for posting bug reports is the
+[issue tracker at GitHub][0].  Reports posted elsewhere are less likely
+to be seen by the core team.
+
+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.
+* steps to reproduce the bug;
+* the version of Vim you are using (run `:ver` to find out);
+* the version of syntastic you are using (see `:SyntasticInfo`).
 
-For syntax checker bugs also state the version of the checker executable that you are using.
+For syntax checker bugs also state the version of the checker executable
+that you are using.  Adding debugging information is typically useful
+too:
 
-# Submitting a patch
+* open a file handled by your checker;
+* set `g:syntastic_debug` to 1 or 3;
+* run the checker;
+* copy the output of `:mes`.
 
-* 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
+<a name="patches"></a>
 
-Small focused patches are preferred.
+## 2. Submitting a patch
 
-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.
+Before you consider adding features to syntastic, _please_ spend a few
+minutes (re-)reading the latest version of the [manual][1].  Syntastic
+is changing rapidly at times, and it's quite possible that some of the
+features you want to add exist already.
 
-# General style notes
+To submit a patch:
 
-Following the coding conventions/styles used in the syntastic core:
+* fork the [repo][2] on GitHub;
+* make a [topic branch][3] and start hacking;
+* submit a pull request based off your topic branch.
 
-* 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.
+Small, focused patches are preferred.
 
-# Syntax checker style notes
+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.
 
-The preferred style for error format strings is one "clause" per line. E.g.
-(from the coffeelint checker):
+Also make sure to update the manual whenever applicable.  Nobody can use
+features that aren't documented.
 
-```viml
-let errorformat = '%E%f:%l:%c: %trror: %m,' .
+<a name="generalstyle"></a>
+
+## 3. General style notes
+
+Follow 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][4] to
+aid readability.
+
+<a name="checkerstyle"></a>
+
+## 4. Syntax checker notes
+
+Make sure to read the [guide][5] if you plan to add new syntax checkers.
+
+Use the existing checkers as templates, rather than writing everything
+from scratch.
+
+The preferred style for error format strings is one "clause" per line.
+E.g. (from the `coffee` checker):
+
+```vim
+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,' .
@@ -47,3 +96,10 @@ let errorformat = '%E%f:%l:%c: %trror: %m,' .
     \ '%-Z%p^,' .
     \ '%-G%.%#'
 ```
+
+[0]: https://github.com/scrooloose/syntastic/issues
+[1]: https://github.com/scrooloose/syntastic/blob/master/doc/syntastic.txt
+[2]: https://github.com/scrooloose/syntastic
+[3]: https://github.com/dchelimsky/rspec/wiki/Topic-Branches#using-topic-branches-when-contributing-patches
+[4]: http://www.refactoring.com/catalog/extractVariable.html
+[5]: https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide

sources_non_forked/syntastic/README.markdown

@@ -35,15 +35,16 @@ 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.
+Ada, AppleScript, Arduino, AsciiDoc, ASM, BEMHTML, Bro, Bourne shell, C,
+C++, C#, Cabal, 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, OS X
+and iOS property lists, Puppet, Python, Racket, R, reStructuredText, Ruby,
+SASS/SCSS, Scala, Slim, Tcl, TeX, Texinfo, Twig, TypeScript, Vala, Verilog,
+VHDL, VimL, xHtml, XML, XSLT, YACC, YAML, z80, Zope page templates, and zsh.
+See the [wiki][3] for details about the corresponding supported checkers.
 
 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
@@ -75,9 +76,8 @@ 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
+mkdir -p ~/.vim/autoload ~/.vim/bundle && \
+curl -LSso ~/.vim/autoload/pathogen.vim https://tpo.pe/pathogen.vim
 ```
 Next you *need* to add this to your `~/.vimrc`:
 ```vim
@@ -91,7 +91,7 @@ execute pathogen#infect()
 You now have pathogen installed and can put syntastic into `~/.vim/bundle` like
 this:
 ```sh
-cd ~/.vim/bundle
+cd ~/.vim/bundle && \
 git clone https://github.com/scrooloose/syntastic.git
 ```
 Quit vim and start it back up to reload it, then type:
@@ -111,6 +111,8 @@ If you get an error when you do this, then you probably didn't install
 
 ## 3\. FAQ
 
+<a name="faqinfo"></a>
+
 __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
@@ -125,6 +127,8 @@ 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.
 
+<a name="faqperl"></a>
+
 __Q. The `perl` checker has stopped working...__
 
 A. The `perl` checker runs `perl -c` against your file, which in turn
@@ -133,11 +137,22 @@ 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:
+(re-)enable it, make sure the `g:syntastic_perl_checkers` list includes `perl`,
+and set `g:syntastic_enable_perl_checker` to 1 in your vimrc:
 ```vim
 let g:syntastic_enable_perl_checker = 1
 ```
 
+<a name="faqrust"></a>
+
+__Q. What happened to the `rustc` checker?__
+
+A. It has been included in the [Rust compiler package][12].  If you have
+a recent version of the Rust compiler, the checker should be picked up
+automatically by syntastic.
+
+<a name="faqloclist"></a>
+
 __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`
@@ -148,6 +163,8 @@ your vimrc:
 let g:syntastic_always_populate_loc_list = 1
 ```
 
+<a name="faqargs"></a>
+
 __Q. How can I pass additional arguments to a checker?__
 
 A. Almost all syntax checkers use the `makeprgBuild()` function. Those checkers
@@ -162,6 +179,8 @@ let g:syntastic_ruby_mri_args = "--my --args --here"
 
 See `:help syntastic-checker-options` for more information.
 
+<a name="faqcheckers"></a>
+
 __Q. Syntastic supports several checkers for my filetype - how do I tell it
 which one(s) to use?__
 
@@ -190,6 +209,32 @@ 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`.
 
+You can also run checkers explicitly by calling `:SyntasticCheck <checker>`.
+
+e.g. to run `phpcs` and `phpmd`:
+```vim
+:SyntasticCheck phpcs phpmd
+```
+
+This works for any checkers available for the current filetype, even if they
+aren't listed in `g:syntastic_<filetype>_checkers`.  You can't run checkers for
+"foreign" filetypes though (e.g. you can't run, say, a Python checker if the
+current filetype is `php`).
+
+<a name="faqaggregate"></a>
+
+__Q. How can I display together the errors found by all checkers enabled for
+the current file?__
+
+A. Set `g:syntastic_aggregate_errors` to 1 in your vimrc:
+```vim
+let g:syntastic_aggregate_errors = 1
+```
+
+See `:help syntastic-aggregating-errors` for more details.
+
+<a name="faqlnext"></a>
+
 __Q. How can I jump between the different errors without using the location
 list at the bottom of the window?__
 
@@ -200,6 +245,8 @@ 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).
 
+<a name="faqstyle"></a>
+
 __Q. A syntax checker is giving me unwanted/strange style tips?__
 
 A. Some filetypes (e.g. php) have style checkers as well as syntax
@@ -214,6 +261,8 @@ let g:syntastic_quiet_messages = { "type": "style" }
 ```
 See `:help syntastic_quiet_messages` for details.
 
+<a name="faqbdelete"></a>
+
 __Q. The error window is closed automatically when I :quit the current buffer
 but not when I :bdelete it?__
 
@@ -231,8 +280,10 @@ cabbrev <silent> 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].
+discussions related to syntastic is the [issue tracker at GitHub][4].
+A guide for writing syntax checkers can be found in the [wiki][11].
+There are also a dedicated [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
@@ -248,5 +299,7 @@ a look at [jedi-vim][7], [python-mode][8], or [YouCompleteMe][9].
 [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
+[9]: http://valloric.github.io/YouCompleteMe/
 [10]: http://perldoc.perl.org/perlrun.html#*-c*
+[11]: https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide
+[12]: https://github.com/rust-lang/rust/

sources_non_forked/syntastic/autoload/syntastic/c.vim

@@ -180,7 +180,7 @@ endfunction " }}}2
 function! s:getIncludeDirs(filetype) " {{{2
     let include_dirs = []
 
-    if a:filetype =~# '\v^%(c|cpp|d|objc|objcpp)$' &&
+    if a:filetype =~# '\v^%(c|cpp|objc|objcpp)$' &&
                 \ (!exists('g:syntastic_'.a:filetype.'_no_default_include_dirs') ||
                 \ !g:syntastic_{a:filetype}_no_default_include_dirs)
         let include_dirs = copy(s:default_includes)

sources_non_forked/syntastic/autoload/syntastic/log.vim

@@ -6,7 +6,7 @@ let g:loaded_syntastic_log_autoload = 1
 let s:save_cpo = &cpo
 set cpo&vim
 
-let s:deprecation_notices_issued = []
+let s:one_time_notices_issued = []
 
 " Public functions {{{1
 
@@ -27,15 +27,39 @@ function! syntastic#log#error(msg) " {{{2
     echohl None
 endfunction " }}}2
 
-function! syntastic#log#deprecationWarn(msg) " {{{2
-    if index(s:deprecation_notices_issued, a:msg) >= 0
+function! syntastic#log#oneTimeWarn(msg) " {{{2
+    if index(s:one_time_notices_issued, a:msg) >= 0
         return
     endif
 
-    call add(s:deprecation_notices_issued, a:msg)
+    call add(s:one_time_notices_issued, a:msg)
     call syntastic#log#warn(a:msg)
 endfunction " }}}2
 
+" @vimlint(EVL102, 1, l:OLD_VAR)
+function! syntastic#log#deprecationWarn(old, new, ...) " {{{2
+    if exists('g:syntastic_' . a:old) && !exists('g:syntastic_' . a:new)
+        let msg = 'variable g:syntastic_' . a:old . ' is deprecated, please use '
+
+        if a:0
+            let OLD_VAR = g:syntastic_{a:old}
+            try
+                let NEW_VAR = eval(a:1)
+                let msg .= 'in its stead: let g:syntastic_' . a:new . ' = ' . string(NEW_VAR)
+                let g:syntastic_{a:new} = NEW_VAR
+            catch
+                let msg .= 'g:syntastic_' . a:new . ' instead'
+            endtry
+        else
+            let msg .= 'g:syntastic_' . a:new . ' instead'
+            let g:syntastic_{a:new} = g:syntastic_{a:old}
+        endif
+
+        call syntastic#log#oneTimeWarn(msg)
+    endif
+endfunction " }}}2
+" @vimlint(EVL102, 0, l:OLD_VAR)
+
 function! syntastic#log#debug(level, msg, ...) " {{{2
     if !s:isDebugEnabled(a:level)
         return
@@ -113,6 +137,7 @@ function! s:isDebugEnabled_dumb(level) " {{{2
 endfunction " }}}2
 
 let s:isDebugEnabled = function(exists('*and') ? 's:isDebugEnabled_smart' : 's:isDebugEnabled_dumb')
+lockvar s:isDebugEnabled
 
 function! s:logRedirect(on) " {{{2
     if exists("g:syntastic_debug_file")
@@ -129,16 +154,10 @@ function! s:logRedirect(on) " {{{2
     endif
 endfunction " }}}2
 
-function! s:logTimestamp_smart() " {{{2
+function! s:logTimestamp() " {{{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)

sources_non_forked/syntastic/autoload/syntastic/postprocess.vim

@@ -8,31 +8,14 @@ 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')
+        let e['text'] = substitute(e['text'], '\m^\s\+', '', '')
+        let e['text'] = substitute(e['text'], '\m\s\+$', '', '')
     endfor
 
     return a:errors

sources_non_forked/syntastic/autoload/syntastic/preprocess.vim

@@ -8,6 +8,26 @@ set cpo&vim
 
 " Public functions {{{1
 
+function! syntastic#preprocess#cabal(errors) " {{{2
+    let out = []
+    let star = 0
+    for err in a:errors
+        if star
+            if err == ''
+                let star = 0
+            else
+                let out[-1] .= ' ' . err
+            endif
+        else
+            call add(out, err)
+            if err =~ '\m^*\s'
+                let star = 1
+            endif
+        endif
+    endfor
+    return out
+endfunction " }}}2
+
 function! syntastic#preprocess#checkstyle(errors) " {{{2
     let out = []
     let fname = expand('%')
@@ -56,6 +76,49 @@ function! syntastic#preprocess#perl(errors) " {{{2
     return syntastic#util#unique(out)
 endfunction " }}}2
 
+function! syntastic#preprocess#rparse(errors) " {{{2
+    let errlist = copy(a:errors)
+
+    " remove uninteresting lines and handle continuations
+    let i = 0
+    while i < len(errlist)
+        if i > 0 && errlist[i][:1] == '  ' && errlist[i] !~ '\m\s\+\^$'
+            let errlist[i-1] .= errlist[i][1:]
+            call remove(errlist, i)
+        elseif errlist[i] !~ '\m^\(Lint:\|Lint checking:\|Error in\) '
+            call remove(errlist, i)
+        else
+            let i += 1
+        endif
+    endwhile
+
+    let out = []
+    let fname = ''
+    for e in errlist
+        if match(e, '\m^Lint: ') == 0
+            let parts = matchlist(e, '\m^Lint: \(.*\): found on lines \([0-9, ]\+\)\(+\(\d\+\) more\)\=')
+            if len(parts) >= 3
+                for line in split(parts[2], '\m,\s*')
+                    call add(out, 'E:' . fname . ':' . line . ': ' . parts[1])
+                endfor
+            endif
+            if len(parts) >= 5 && parts[4] != ''
+                call add(out, 'E:' . fname . ':0: ' . parts[1] . ' - ' . parts[4] . ' messages not shown')
+            endif
+        elseif match(e, '\m^Lint checking: ') == 0
+            let fname = matchstr(e, '\m^Lint checking: \zs.*')
+        elseif match(e, '\m^Error in ') == 0
+            call add(out, substitute(e, '\m^Error in .\+ : .\+\ze:\d\+:\d\+: ', 'E:' . fname, ''))
+        endif
+    endfor
+
+    return out
+endfunction " }}}2
+
+function! syntastic#preprocess#tslint(errors) " {{{2
+    return map(copy(a:errors), 'substitute(v:val, ''\m^\(([^)]\+)\)\s\(.\+\)$'', ''\2 \1'', "")')
+endfunction " }}}2
+
 function! syntastic#preprocess#validator(errors) " {{{2
     let out = []
     for e in a:errors

sources_non_forked/syntastic/autoload/syntastic/util.vim

@@ -35,12 +35,12 @@ endfunction " }}}2
 "
 "{'exe': '/usr/bin/perl', 'args': ['-f', '-bar']}
 function! syntastic#util#parseShebang() " {{{2
-    for lnum in range(1,5)
+    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.*'))
+            let line = substitute(line, '\v^#!\s*(\S+/env(\s+-\S+)*\s+)?', '', '')
+            let exe = matchstr(line, '\m^\S*\ze')
+            let args = split(matchstr(line, '\m^\S*\zs.*'))
             return { 'exe': exe, 'args': args }
         endif
     endfor
@@ -58,7 +58,7 @@ 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\.')
+    return map(split(matchstr( a:version, '\v^\D*\zs\d+(\.\d+)+\ze' ), '\m\.'), 'str2nr(v:val)')
 endfunction " }}}2
 
 " Run 'command' in a shell and parse output as a version string.
@@ -74,20 +74,27 @@ endfunction " }}}2
 "
 " 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
+    return syntastic#util#compareLexi(a:installed, a:required) >= 0
+endfunction " }}}2
+
+" Almost lexicographic comparison of two lists of integers. :) If lists
+" have different lengths, the "missing" elements are assumed to be 0.
+function! syntastic#util#compareLexi(a, b) " {{{2
+    for idx in range(max([len(a:a), len(a:b)]))
+        let a_element = str2nr(get(a:a, idx, 0))
+        let b_element = str2nr(get(a:b, idx, 0))
+        if a_element != b_element
+            return a_element > b_element ? 1 : -1
         endif
     endfor
     " Everything matched, so it is at least the required version.
-    return 1
+    return 0
 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')
+lockvar s:width
 
 "print as much of a:msg as possible without "Press Enter" prompt appearing
 function! syntastic#util#wideMsg(msg) " {{{2
@@ -101,7 +108,7 @@ function! syntastic#util#wideMsg(msg) " {{{2
     "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 = join(map(chunks[:-2], 'v:val . repeat(" ", &tabstop - s:width(v:val) % &tabstop)'), '') . chunks[-1]
     let msg = strpart(msg, 0, &columns - 1)
 
     set noruler noshowcmd
@@ -218,6 +225,20 @@ function! syntastic#util#dictFilter(errors, filter) " {{{2
     endtry
 endfunction " }}}2
 
+function! syntastic#util#sortLoclist(errors) " {{{2
+    for e in a:errors
+        call s:setScreenColumn(e)
+    endfor
+    call sort(a:errors, 's:compareErrorItems')
+endfunction " }}}2
+
+" Return a [high, low] list of integers, representing the time
+" (hopefully high resolution) since program start
+" TODO: This assumes reltime() returns a list of integers.
+function! syntastic#util#stamp() " {{{2
+    return reltime(g:syntastic_start)
+endfunction " }}}2
+
 " }}}1
 
 " Private functions {{{1
@@ -254,6 +275,49 @@ function! s:translateElement(key, term) " {{{2
     return ret
 endfunction " }}}2
 
+function! s:screenWidth(str, tabstop) " {{{2
+    let chunks = split(a:str, "\t", 1)
+    let width = s:width(chunks[-1])
+    for c in chunks[:-2]
+        let cwidth = s:width(c)
+        let width += cwidth + a:tabstop - cwidth % a:tabstop
+    endfor
+    return width
+endfunction " }}}2
+
+function! s:setScreenColumn(item) " {{{2
+    if !has_key(a:item, 'scol')
+        let col = get(a:item, 'col', 0)
+        if col != 0 && a:item['vcol'] == 0
+            let buf = str2nr(a:item['bufnr'])
+            try
+                let line = getbufline(buf, a:item['lnum'])[0]
+            catch  /\m^Vim\%((\a\+)\)\=:E684/
+                let line = ''
+            endtry
+            let a:item['scol'] = s:screenWidth(strpart(line, 0, col), getbufvar(buf, '&tabstop'))
+        else
+            let a:item['scol'] = col
+        endif
+    endif
+endfunction " }}}2
+
+function! s:compareErrorItems(a, b) " {{{2
+    if a:a['bufnr'] != a:b['bufnr']
+        " group by file
+        return a:a['bufnr'] - a:b['bufnr']
+    elseif a:a['lnum'] != a:b['lnum']
+        " sort by line
+        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
+        " sort by screen column
+        return a:a['scol'] - a:b['scol']
+    endif
+endfunction " }}}2
+
 " }}}1
 
 let &cpo = s:save_cpo

sources_non_forked/syntastic/doc/syntastic.txt

@@ -36,9 +36,14 @@ CONTENTS                                                  *syntastic-contents*
         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|
+        6.2.Editing files over network.............|syntastic-netrw|
+        6.3.Interaction with python-mode...........|syntastic-pymode|
+        6.4.Interaction with YouCompleteMe.........|syntastic-ycm|
+        6.5.Interaction with the fish shell........|syntastic-fish|
+        6.6.Interaction with PowerShell............|syntastic-powershell|
+        6.7.Using syntastic with the fizsh shell...|syntastic-fizsh|
+        6.8.Interaction with Eclim.................|syntastic-eclim|
+        6.9.Interaction with vim-virtualenv........|syntastic-vim-virtualenv|
     7.About........................................|syntastic-about|
     8.License......................................|syntastic-license|
 
@@ -81,7 +86,7 @@ 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)
+to switch between active (checking on writing the buffer) and passive (manual)
 checking.
 
 ==============================================================================
@@ -91,7 +96,7 @@ 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
+user of errors. See |syntastic-global-options| for how to configure and
 activate/deactivate these features.
 
     * A statusline flag
@@ -167,6 +172,8 @@ 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
+    SyntasticStyleError - Links to SyntasticError by default
+    SyntasticStyleWarning - Links to SyntasticWarning by default
 
 Example: >
     highlight SyntasticError guibg=#2f0000
@@ -186,7 +193,12 @@ 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|'.
+disable generation of these labels by turning off '|syntastic_id_checkers|'.
+
+If |'syntastic_sort_aggregated_errors'| is set (which is the default), messages
+in the aggregated list are grouped by file, then sorted by line number, then
+type, then column number.  Otherwise messages produced by the same checker are
+grouped together.
 
 ------------------------------------------------------------------------------
 2.6 Filtering errors                              *syntastic-filtering-errors*
@@ -278,6 +290,16 @@ 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_sort_aggregated_errors'*
+Default: 1
+By default, 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), errors are grouped by file,
+then sorted by line number, then grouped by type (namely errors take precedence
+over warnings), then they are sorted by column number.  If you want to leave
+messages grouped by checker output, set this variable to 0. >
+    let g:syntastic_sort_aggregated_errors = 0
 <
                                               *'syntastic_echo_current_error'*
 Default: 1
@@ -301,8 +323,8 @@ error symbols can be customized:
     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
@@ -374,12 +396,12 @@ 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' }
+    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' }
+    let g:syntastic_filetype_map = { "handlebars.html": "handlebars" }
 <
                                                         *'syntastic_mode_map'*
 Default: { "mode": "active",
@@ -391,26 +413,26 @@ done).
 
 The option should be set to something like: >
 
-    let g:syntastic_mode_map = { 'mode': 'active',
-                               \ 'active_filetypes': ['ruby', 'php'],
-                               \ 'passive_filetypes': ['puppet'] }
+    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
+"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.
+"passive_filetypes". In passive mode, automatic checks are still done for
+filetypes in the "active_filetypes" array (and "passive_filetypes" is
+ignored). In active mode, automatic checks are not done for any filetypes in
+the "passive_filetypes" array ("active_filetypes" is ignored).
+
+If any of "mode", "active_filetypes", or "passive_filetypes" are left
+unspecified, they default to values above.
 
 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.
+active and passive modes.
 
                                                   *'syntastic_quiet_messages'*
 Default: {}
@@ -451,7 +473,7 @@ 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_<filetype>_<checker>_quiet_messages'| to [] or ''. For
 example, the following setting will silence all warnings, except for the
-ones produced by 'pylint': >
+ones produced by "pylint": >
     let g:syntastic_quiet_messages = { "level": "warnings" }
     let g:syntastic_python_pylint_quiet_messages = { "level" : [] }
 <
@@ -520,7 +542,7 @@ 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' ]
+    let g:syntastic_extra_filetypes = [ "make", "gitcommit" ]
 <
 This will allow |:SyntasticInfo| to do proper tab completion for the new
 filetypes.
@@ -534,14 +556,14 @@ filetypes.
                                            *'g:syntastic_<filetype>_checkers'*
 You can tell syntastic which checkers to run for a given filetype by setting a
 variable 'g:syntastic_<filetype>_checkers' to a list of checkers, e.g. >
-    let g:syntastic_php_checkers = ['php', 'phpcs', 'phpmd']
+    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_<filetype>_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
+    autocmd FileType python if stridx(expand("%:p"), "/some/path/") == 0 |
+        \ let b:syntastic_checkers = ["pylint"] | endif
 <
 If neither |'g:syntastic_<filetype>_checkers'| nor |'b:syntastic_checkers'|
 is set, a default list of checker is used. Beware however that this list
@@ -557,10 +579,10 @@ Use |:SyntasticInfo| to see which checkers are available for a given filetype.
 ------------------------------------------------------------------------------
 5.2 Choosing the executable                            *syntastic-config-exec*
 
-                                    *'syntastic_<filetype>_<subchecker>_exec'*
+                                       *'syntastic_<filetype>_<checker>_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_<filetype>_<subchecker>_exec': >
+'g:syntastic_<filetype>_<checker>_exec': >
     let g:syntastic_ruby_mri_exec = '~/bin/ruby2'
 <
 ------------------------------------------------------------------------------
@@ -569,24 +591,30 @@ checkers is registered. You can however override it by setting the variable
 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_<filetype>_<subchecker>_<option>'*
+                                   *'syntastic_<filetype>_<checker>_<option>'*
 Checkers that use 'makeprgBuild()' construct a 'makeprg' like this: >
     let makeprg = self.makeprgBuild({
-                \ 'exe': self.getExec(),
-                \ 'args': '-a -b -c',
-                \ 'post_args': '--more --args',
-                \ 'tail': '> /tmp/output' })
+                \ "exe": self.getExec(),
+                \ "args": "-a -b -c",
+                \ "post_args": "--more --args",
+                \ "tail": "2>/dev/null" })
 <
 The result is a 'makeprg' of the form: >
-    <exe> <args> <filename> <post_args> <tail>
+    <exe> <args> <fname> <post_args> <tail>
 <
-                                     *'syntastic_<filetype>_<subchecker>_exe'*
 All arguments above are optional, and can be overridden by setting global
 variables 'g:syntastic_<filetype>_<checker-name>_<option-name>' - even
 parameters not specified in the call to makeprgBuild(). These variables also
 have local versions 'b:syntastic_<filetype>_<checker-name>_<option-name>',
 which take precedence over the global ones in the corresponding buffers.
 
+If one of these variables has a non-empty default and you want it to be empty,
+you can set it to a space, e.g.: >
+    let g:syntastic_javascript_jslint_args = " "
+<
+(setting it to an empty string doesn't work, for implementation reasons).
+
+                                        *'syntastic_<filetype>_<checker>_exe'*
 The 'exe' is normally the same as the 'exec' attribute described above, in
 which case it may be omitted. However, you can use it to add environment
 variables or additional parameters, e.g. to tell the mri checker to use KANJI
@@ -598,7 +626,7 @@ To override the args and the tail: >
     let g:syntastic_ruby_mri_tail = "> /tmp/my-output-file-biatch"
 <
 The general form of the override options is: >
-    syntastic_<filetype>_<subchecker>_<option-name>
+    syntastic_<filetype>_<checker>_<option-name>
 <
 For checkers that do not use the 'makeprgBuild()' function you will have to
 look at the source code of the checker in question. If there are specific
@@ -621,37 +649,65 @@ See |syntastic_quiet_messages| for the syntax.
 ------------------------------------------------------------------------------
 6.1. Handling of composite filetypes                     *syntastic-composite*
 
-Some Vim plugins use composite filetypes, such as 'django.python' or
-'handlebars.html'. Normally, syntastic deals with this situation by splitting
+Some Vim plugins use composite filetypes, such as "django.python" or
+"handlebars.html". Normally, syntastic deals with this situation by splitting
 the filetype in its simple components, and calling all checkers that apply.
 If this behaviour is not desirable, you can disable it by mapping the
 composite filetypes to a simple ones using |syntastic_filetype_map|, e.g.: >
-    let g:syntastic_filetype_map = { 'handlebars.html': 'handlebars' }
+    let g:syntastic_filetype_map = { "handlebars.html": "handlebars" }
 <
 ------------------------------------------------------------------------------
-6.2 Interaction with python-mode                            *syntastic-pymode*
+6.2 Editing files over network                               *syntastic-netrw*
+
+The standard plugin |netrw| allows Vim to transparently edit files over
+network and inside archives.  Currently syntastic doesn't support this mode
+of operation.  It can only check files that can be accessed directly by local
+checkers, without any translation or conversion.
+
+------------------------------------------------------------------------------
+6.3 Interaction with python-mode                            *syntastic-pymode*
 
 Syntastic can be used along with the 'python-mode' Vim plugin (see
 https://github.com/klen/python-mode). However, they both run syntax checks by
 default when you save buffers to disk, and this is probably not what you want.
 To avoid both plugins opening error windows, you can either set passive mode
 for python in syntastic (see |syntastic_mode_map|), or disable lint checks in
-python-mode, by setting |pymode_lint_write| to 0. E.g.: >
+'python-mode', by setting |pymode_lint_write| to 0. E.g.: >
     let g:pymode_lint_write = 0
 <
 ------------------------------------------------------------------------------
-6.3 Interaction with the fish shell                           *syntastic-fish*
+6.4 Interaction with YouCompleteMe                             *syntastic-ycm*
+
+Syntastic can be used together with the 'YouCompleteMe' Vim plugin (see
+http://valloric.github.io/YouCompleteMe/).  However, by default 'YouCompleteMe'
+disables syntastic"s checkers for the "c", "cpp", "objc", and "objcpp"
+filetypes, in order to allow its own checkers to run.  If you want to use YCM's
+identifier completer but still run syntastic's checkers for those filetypes you
+have to set |ycm_show_diagnostics_ui| to 0. E.g.: >
+    let g:ycm_show_diagnostics_ui = 0
+<
+------------------------------------------------------------------------------
+6.5 Interaction with the fish shell                           *syntastic-fish*
 
 At the time of this writing the 'fish' shell (see http://fishshell.com/)
 doesn't support the standard UNIX syntax for file redirections, and thus it
 can't be used together with syntastic. You don't need to change your login
 shell to address this problem, but you do have to point Vim's 'shell' to a more
-traditional shell, such as 'zsh', 'bash', 'ksh', or even the original Bourne
-'sh': >
+traditional shell, such as "zsh", "bash", "ksh", or even the original Bourne
+"sh": >
     set shell=bash
 <
 ------------------------------------------------------------------------------
-6.4. Using syntastic with the fizsh shell                    *syntastic-fizsh*
+6.6. Interaction with PowerShell                        *syntastic-powershell*
+
+At the time of this writing, syntastic is not compatible with using 'Windows
+PowerShell' (http://technet.microsoft.com/en-us/library/bb978526.aspx) as Vim's
+'shell'.  You may still run Vim from 'PowerShell', but you do have to point
+Vim's 'shell' to a more traditional program, such as 'cmd.exe': >
+    set shell=cmd.exe
+<
+------------------------------------------------------------------------------
+6.7. Using syntastic with the fizsh shell                    *syntastic-fizsh*
 
 Using syntastic with the 'fizsh' shell (see https://github.com/zsh-users/fizsh)
 is possible, but potentially problematic. In order to do it you'll need to set
@@ -659,10 +715,27 @@ is possible, but potentially problematic. In order to do it you'll need to set
     set shellredir=>%s\ 2>&1
 <
 Please keep in mind however that Vim can't take advantage of any of the
-interactive features of 'fizsh'. Using a more traditional shell such as 'zsh',
-'bash', 'ksh', or the original Bourne 'sh' might be a better choice: >
+interactive features of 'fizsh'. Using a more traditional shell such as "zsh",
+"bash", "ksh", or the original Bourne "sh" might be a better choice: >
     set shell=zsh
 <
+------------------------------------------------------------------------------
+6.8. Interaction with Eclim                                  *syntastic-eclim*
+
+As far as syntastic is concerned there shouldn't be any compatibility problems
+with the 'Eclim' Vim plugin (see http://eclim.org/). However, at the time of
+this writing there are several reports that 'Eclim' triggers a bug in Vim that
+makes syntastic forget some of its configuration parameters. No solutions or
+workarounds are known for now.
+
+------------------------------------------------------------------------------
+6.9. Interaction with vim-virtualenv                *syntastic-vim-virtualenv*
+
+At the time of this writing, syntastic can't run checkers installed
+in Python virtual environments activated by 'vim-virtualenv' (see
+https://github.com/jmcantrell/vim-virtualenv).  This is a limitation of
+'vim-virtualenv'.
+
 ==============================================================================
 7. About                                                     *syntastic-about*
 

sources_non_forked/syntastic/plugin/syntastic.vim

@@ -16,13 +16,15 @@ let g:loaded_syntastic_plugin = 1
 
 if has('reltime')
     let g:syntastic_start = reltime()
+    lockvar! g:syntastic_start
 endif
 
-let g:syntastic_version = '3.4.0'
+let g:syntastic_version = '3.4.0-117'
+lockvar g:syntastic_version
 
 " Sanity checks {{{1
 
-for s:feature in ['autocmd', 'eval', 'modify_fname', 'quickfix', 'user_commands']
+for s:feature in ['autocmd', 'eval', 'modify_fname', 'quickfix', 'reltime', 'user_commands']
     if !has(s:feature)
         call syntastic#log#error("need Vim compiled with feature " . s:feature)
         finish
@@ -30,6 +32,8 @@ for s:feature in ['autocmd', 'eval', 'modify_fname', 'quickfix', 'user_commands'
 endfor
 
 let s:running_windows = syntastic#util#isRunningWindows()
+lockvar s:running_windows
+
 if !s:running_windows && executable('uname')
     try
         let s:uname = system('uname')
@@ -37,6 +41,7 @@ if !s:running_windows && executable('uname')
         call syntastic#log#error("your shell " . &shell . " doesn't use traditional UNIX syntax for redirections")
         finish
     endtry
+    lockvar s:uname
 endif
 
 " }}}1
@@ -60,15 +65,18 @@ let g:syntastic_defaults = {
         \ 'filetype_map':             {},
         \ 'full_redraws':             !(has('gui_running') || has('gui_macvim')),
         \ 'id_checkers':              1,
+        \ 'ignore_extensions':        '\c\v^([gx]?z|lzma|bz2)$',
         \ 'ignore_files':             [],
         \ 'loc_list_height':          10,
         \ 'quiet_messages':           {},
-        \ 'reuse_loc_lists':          (v:version >= 704),
+        \ 'reuse_loc_lists':          0,
+        \ 'sort_aggregated_errors':   1,
         \ 'stl_format':               '[Syntax: line:%F (%t)]',
         \ 'style_error_symbol':       'S>',
         \ 'style_warning_symbol':     'S>',
         \ 'warning_symbol':           '>>'
     \ }
+lockvar! g:syntastic_defaults
 
 for s:key in keys(g:syntastic_defaults)
     if !exists('g:syntastic_' . s:key)
@@ -77,7 +85,7 @@ for s:key in keys(g:syntastic_defaults)
 endfor
 
 if exists("g:syntastic_quiet_warnings")
-    call syntastic#log#deprecationWarn("variable g:syntastic_quiet_warnings is deprecated, please use let g:syntastic_quiet_messages = {'level': 'warnings'} instead")
+    call syntastic#log#oneTimeWarn("variable g:syntastic_quiet_warnings is deprecated, please use let g:syntastic_quiet_messages = {'level': 'warnings'} instead")
     if g:syntastic_quiet_warnings
         let s:quiet_warnings = get(g:syntastic_quiet_messages, 'type', [])
         if type(s:quiet_warnings) != type([])
@@ -105,13 +113,19 @@ let s:debug_dump_options = [
 if v:version > 703 || (v:version == 703 && has('patch446'))
     call add(s:debug_dump_options, 'shellxescape')
 endif
+lockvar! s:debug_dump_options
 
 " debug constants
 let     g:SyntasticDebugTrace         = 1
+lockvar g:SyntasticDebugTrace
 let     g:SyntasticDebugLoclist       = 2
+lockvar g:SyntasticDebugLoclist
 let     g:SyntasticDebugNotifications = 4
+lockvar g:SyntasticDebugNotifications
 let     g:SyntasticDebugAutocommands  = 8
+lockvar g:SyntasticDebugAutocommands
 let     g:SyntasticDebugVariables     = 16
+lockvar g:SyntasticDebugVariables
 
 " }}}1
 
@@ -129,7 +143,7 @@ let s:modemap = g:SyntasticModeMap.Instance()
 function! s:CompleteCheckerName(argLead, cmdLine, cursorPos) " {{{2
     let checker_names = []
     for ft in s:resolveFiletypes()
-        call extend(checker_names, keys(s:registry.getCheckersMap(ft)))
+        call extend(checker_names, s:registry.getNamesOfAvailableCheckers(ft))
     endfor
     return join(checker_names, "\n")
 endfunction " }}}2
@@ -154,7 +168,7 @@ command! -nargs=* -complete=custom,s:CompleteCheckerName SyntasticCheck
             \ call syntastic#util#redraw(g:syntastic_full_redraws)
 command! Errors call s:ShowLocList()
 command! -nargs=? -complete=custom,s:CompleteFiletypes SyntasticInfo
-            \ call s:modemap.echoMode() |
+            \ call s:modemap.modeInfo(<f-args>) |
             \ call s:registry.echoInfoFor(s:resolveFiletypes(<f-args>))
 command! SyntasticReset
             \ call s:ClearCache() |
@@ -168,11 +182,6 @@ command! SyntasticSetLoclist call g:SyntasticLoclist.current().setloclist()
 augroup syntastic
     autocmd BufReadPost * call s:BufReadPostHook()
     autocmd BufWritePost * call s:BufWritePostHook()
-
-    autocmd BufWinEnter * call s:BufWinEnterHook()
-
-    " TODO: the next autocmd should be "autocmd BufWinLeave * if &buftype == '' | lclose | endif"
-    " but in recent versions of Vim lclose can no longer be called from BufWinLeave
     autocmd BufEnter * call s:BufEnterHook()
 augroup END
 
@@ -197,24 +206,22 @@ function! s:BufWritePostHook() " {{{2
     call s:UpdateErrors(1)
 endfunction " }}}2
 
-function! s:BufWinEnterHook() " {{{2
-    call syntastic#log#debug(g:SyntasticDebugAutocommands,
-        \ 'autocmd: BufWinEnter, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))) .
-        \ ', &buftype = ' . string(&buftype))
-    if &buftype == ''
-        call s:notifiers.refresh(g:SyntasticLoclist.current())
-    endif
-endfunction " }}}2
-
 function! s:BufEnterHook() " {{{2
     call syntastic#log#debug(g:SyntasticDebugAutocommands,
         \ 'autocmd: BufEnter, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))) .
         \ ', &buftype = ' . string(&buftype))
+    if &buftype == ''
+        call s:notifiers.refresh(g:SyntasticLoclist.current())
+    elseif &buftype == 'quickfix'
+        " TODO: this is needed because in recent versions of Vim lclose
+        " can no longer be called from BufWinLeave
         " TODO: at this point there is no b:syntastic_loclist
-    let loclist = filter(getloclist(0), 'v:val["valid"] == 1')
-    let buffers = syntastic#util#unique(map( loclist, 'v:val["bufnr"]' ))
-    if &buftype == 'quickfix' && !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' ))
-        call g:SyntasticLoclistHide()
+        let loclist = filter(copy(getloclist(0)), 'v:val["valid"] == 1')
+        let owner = str2nr(getbufvar(bufnr(""), 'syntastic_owner_buffer'))
+        let buffers = syntastic#util#unique(map(loclist, 'v:val["bufnr"]') + (owner ? [owner] : []))
+        if !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' ))
+            call SyntasticLoclistHide()
+        endif
     endif
 endfunction " }}}2
 
@@ -222,7 +229,7 @@ function! s:QuitPreHook() " {{{2
     call syntastic#log#debug(g:SyntasticDebugAutocommands,
         \ 'autocmd: QuitPre, buffer ' . bufnr("") . ' = ' . string(bufname(str2nr(bufnr("")))))
     let b:syntastic_skip_checks = !g:syntastic_check_on_wq
-    call g:SyntasticLoclistHide()
+    call SyntasticLoclistHide()
 endfunction " }}}2
 
 " }}}1
@@ -231,6 +238,11 @@ endfunction " }}}2
 
 "refresh and redraw all the error info for this buf when saving or reading
 function! s:UpdateErrors(auto_invoked, ...) " {{{2
+    call syntastic#log#debugShowVariables(g:SyntasticDebugTrace, 'version')
+    call syntastic#log#debugShowOptions(g:SyntasticDebugTrace, s:debug_dump_options)
+    call syntastic#log#debugDump(g:SyntasticDebugVariables)
+    call syntastic#log#debug(g:SyntasticDebugTrace, 'UpdateErrors' . (a:auto_invoked ? ' (auto)' : '') .
+        \ ': ' . (a:0 ? join(a:000) : 'default checkers'))
     if s:skipFile()
         return
     endif
@@ -277,26 +289,26 @@ endfunction " }}}2
 "clear the loc list for the buffer
 function! s:ClearCache() " {{{2
     call s:notifiers.reset(g:SyntasticLoclist.current())
-    unlet! b:syntastic_loclist
+    call b:syntastic_loclist.destroy()
 endfunction " }}}2
 
 "detect and cache all syntax errors in this buffer
 function! s:CacheErrors(checker_names) " {{{2
+    call syntastic#log#debug(g:SyntasticDebugTrace, 'CacheErrors: ' .
+        \ (len(a:checker_names) ? join(a:checker_names) : 'default checkers'))
     call s:ClearCache()
     let newLoclist = g:SyntasticLoclist.New([])
 
     if !s:skipFile()
         " debug logging {{{3
-        call syntastic#log#debugShowVariables(g:SyntasticDebugTrace, 'version')
-        call syntastic#log#debugShowOptions(g:SyntasticDebugTrace, s:debug_dump_options)
-        call syntastic#log#debugDump(g:SyntasticDebugVariables)
         call syntastic#log#debugShowVariables(g:SyntasticDebugTrace, 'aggregate_errors')
         call syntastic#log#debug(g:SyntasticDebugTrace, 'getcwd() = ' . getcwd())
         " }}}3
 
         let filetypes = s:resolveFiletypes()
-        let aggregate_errors = syntastic#util#var('aggregate_errors')
-        let decorate_errors = (aggregate_errors || len(filetypes) > 1) && syntastic#util#var('id_checkers')
+        let aggregate_errors = syntastic#util#var('aggregate_errors') || len(filetypes) > 1
+        let decorate_errors = aggregate_errors && syntastic#util#var('id_checkers')
+        let sort_aggregated_errors = aggregate_errors && syntastic#util#var('sort_aggregated_errors')
 
         let clist = []
         for type in filetypes
@@ -304,8 +316,15 @@ function! s:CacheErrors(checker_names) " {{{2
         endfor
 
         let names = []
+        let unavailable_checkers = 0
         for checker in clist
             let cname = checker.getFiletype() . '/' . checker.getName()
+            if !checker.isAvailable()
+                call syntastic#log#debug(g:SyntasticDebugTrace, 'CacheErrors: Checker ' . cname . ' is not available')
+                let unavailable_checkers += 1
+                continue
+            endif
+
             call syntastic#log#debug(g:SyntasticDebugTrace, 'CacheErrors: Invoking checker: ' . cname)
 
             let loclist = checker.getLocList()
@@ -315,6 +334,10 @@ function! s:CacheErrors(checker_names) " {{{2
                     call loclist.decorate(cname)
                 endif
                 call add(names, cname)
+                if checker.getWantSort() && !sort_aggregated_errors
+                    call loclist.sort()
+                    call syntastic#log#debug(g:SyntasticDebugLoclist, 'sorted:', loclist)
+                endif
 
                 let newLoclist = newLoclist.extend(loclist)
 
@@ -338,7 +361,7 @@ function! s:CacheErrors(checker_names) " {{{2
         " }}}3
 
         " issue warning about no active checkers {{{3
-        if empty(clist)
+        if len(clist) == unavailable_checkers
             if !empty(a:checker_names)
                 if len(a:checker_names) == 1
                     call syntastic#log#warn('checker ' . a:checker_names[0] . ' is not available')
@@ -352,9 +375,13 @@ function! s:CacheErrors(checker_names) " {{{2
         " }}}3
 
         call syntastic#log#debug(g:SyntasticDebugLoclist, 'aggregated:', newLoclist)
+        if sort_aggregated_errors
+            call newLoclist.sort()
+            call syntastic#log#debug(g:SyntasticDebugLoclist, 'sorted:', newLoclist)
+        endif
     endif
 
-    let b:syntastic_loclist = newLoclist
+    call newLoclist.deploy()
 endfunction " }}}2
 
 function! s:ToggleMode() " {{{2
@@ -385,7 +412,9 @@ endfunction " }}}2
 "   'preprocess' - a function to be applied to the error file before parsing errors
 "   'postprocess' - a list of functions to be applied to the error list
 "   'cwd' - change directory to the given path before running the checker
+"   'env' - environment variables to set before running the checker
 "   'returns' - a list of valid exit codes for the checker
+" @vimlint(EVL102, 1, l:env_save)
 function! SyntasticMake(options) " {{{2
     call syntastic#log#debug(g:SyntasticDebugTrace, 'SyntasticMake: called with options:', a:options)
 
@@ -409,11 +438,31 @@ function! SyntasticMake(options) " {{{2
         execute 'lcd ' . fnameescape(a:options['cwd'])
     endif
 
+    " set environment variables {{{3
+    let env_save = {}
+    if has_key(a:options, 'env') && len(a:options['env'])
+        for key in keys(a:options['env'])
+            if key =~? '\m^[a-z_]\+$'
+                exec 'let env_save[' . string(key) . '] = $' . key
+                exec 'let $' . key . ' = ' . string(a:options['env'][key])
+            endif
+        endfor
+    endif
     let $LC_MESSAGES = 'C'
     let $LC_ALL = ''
+    " }}}3
+
     let err_lines = split(system(a:options['makeprg']), "\n", 1)
+
+    " restore environment variables {{{3
     let $LC_ALL = old_lc_all
     let $LC_MESSAGES = old_lc_messages
+    if len(env_save)
+        for key in keys(env_save)
+            exec 'let $' . key . ' = ' . string(env_save[key])
+        endfor
+    endif
+    " }}}3
 
     call syntastic#log#debug(g:SyntasticDebugLoclist, 'checker output:', err_lines)
 
@@ -474,6 +523,7 @@ function! SyntasticMake(options) " {{{2
 
     return errors
 endfunction " }}}2
+" @vimlint(EVL102, 0, l:env_save)
 
 "return a string representing the state of buffer according to
 "g:syntastic_stl_format
@@ -504,9 +554,14 @@ endfunction " }}}2
 
 " Skip running in special buffers
 function! s:skipFile() " {{{2
-    let force_skip = exists('b:syntastic_skip_checks') ? b:syntastic_skip_checks : 0
     let fname = expand('%')
-    return force_skip || (&buftype != '') || !filereadable(fname) || getwinvar(0, '&diff') || s:ignoreFile(fname)
+    let skip = (exists('b:syntastic_skip_checks') ? b:syntastic_skip_checks : 0) ||
+        \ (&buftype != '') || !filereadable(fname) || getwinvar(0, '&diff') ||
+        \ s:ignoreFile(fname) || fnamemodify(fname, ':e') =~? g:syntastic_ignore_extensions
+    if skip
+        call syntastic#log#debug(g:SyntasticDebugTrace, 'skipFile: skipping')
+    endif
+    return skip
 endfunction " }}}2
 
 " Take a list of errors and add default values to them from a:options
@@ -544,6 +599,7 @@ endfunction " }}}2
 function! s:uname() " {{{2
     if !exists('s:uname')
         let s:uname = system('uname')
+        lockvar s:uname
     endif
     return s:uname
 endfunction " }}}2

sources_non_forked/syntastic/plugin/syntastic/balloons.vim

@@ -43,6 +43,7 @@ endfunction " }}}2
 " Reset the error balloons
 " @vimlint(EVL103, 1, a:loclist)
 function! g:SyntasticBalloonsNotifier.reset(loclist) " {{{2
+    let b:syntastic_balloons = {}
     if has('balloon_eval')
         call syntastic#log#debug(g:SyntasticDebugNotifications, 'balloons: reset')
         set nobeval

sources_non_forked/syntastic/plugin/syntastic/checker.vim

@@ -13,6 +13,7 @@ function! g:SyntasticChecker.New(args) " {{{2
     let newObj._filetype = a:args['filetype']
     let newObj._name = a:args['name']
     let newObj._exec = get(a:args, 'exec', newObj._name)
+    let newObj._sort = 0
 
     if has_key(a:args, 'redirect')
         let [filetype, name] = split(a:args['redirect'], '/')
@@ -75,6 +76,14 @@ function! g:SyntasticChecker.getLocList() " {{{2
     return g:SyntasticLoclist.New(self.getLocListRaw())
 endfunction " }}}2
 
+function! g:SyntasticChecker.getWantSort() " {{{2
+    return self._sort
+endfunction " }}}2
+
+function! g:SyntasticChecker.setWantSort(val) " {{{2
+    let self._sort = a:val
+endfunction " }}}2
+
 function! g:SyntasticChecker.makeprgBuild(opts) " {{{2
     let basename = self._filetype . '_' . self._name . '_'
 
@@ -89,7 +98,10 @@ function! g:SyntasticChecker.makeprgBuild(opts) " {{{2
 endfunction " }}}2
 
 function! g:SyntasticChecker.isAvailable() " {{{2
-    return self._isAvailableFunc()
+    if !has_key(self, '_available')
+        let self._available = self._isAvailableFunc()
+    endif
+    return self._available
 endfunction " }}}2
 
 " }}}1
@@ -126,7 +138,7 @@ function! g:SyntasticChecker._populateHighlightRegexes(errors) " {{{2
         for e in a:errors
             if e['valid']
                 let term = self._highlightRegexFunc(e)
-                if len(term) > 0
+                if term != ''
                     let e['hl'] = term
                 endif
             endif

sources_non_forked/syntastic/plugin/syntastic/cursor.vim

@@ -22,7 +22,7 @@ function! g:SyntasticCursorNotifier.refresh(loclist) " {{{2
         let b:syntastic_messages = copy(a:loclist.messages(bufnr('')))
         let b:oldLine = -1
         autocmd! syntastic CursorMoved
-        autocmd syntastic CursorMoved * call g:SyntasticRefreshCursor()
+        autocmd syntastic CursorMoved * call SyntasticRefreshCursor()
     endif
 endfunction " }}}2
 
@@ -40,7 +40,7 @@ endfunction " }}}2
 " Private methods {{{1
 
 " The following defensive nonsense is needed because of the nature of autocmd
-function! g:SyntasticRefreshCursor() " {{{2
+function! SyntasticRefreshCursor() " {{{2
     if !exists('b:syntastic_messages') || empty(b:syntastic_messages)
         " file not checked
         return

sources_non_forked/syntastic/plugin/syntastic/highlighting.vim

@@ -5,6 +5,7 @@ let g:loaded_syntastic_notifier_highlighting = 1
 
 " Highlighting requires getmatches introduced in 7.1.040
 let s:has_highlighting = v:version > 701 || (v:version == 701 && has('patch040'))
+lockvar s:has_highlighting
 
 let g:SyntasticHighlightingNotifier = {}
 
@@ -18,6 +19,7 @@ function! g:SyntasticHighlightingNotifier.New() " {{{2
     if !s:setup_done
         call self._setup()
         let s:setup_done = 1
+        lockvar s:setup_done
     endif
 
     return newObj
@@ -30,12 +32,12 @@ endfunction " }}}2
 " Sets error highlights in the cuirrent window
 function! g:SyntasticHighlightingNotifier.refresh(loclist) " {{{2
     if self.enabled()
-        call self.reset(a:loclist)
         call syntastic#log#debug(g:SyntasticDebugNotifications, 'highlighting: refresh')
+        call self._reset()
         let buf = bufnr('')
         let issues = filter(a:loclist.copyRaw(), 'v:val["bufnr"] == buf')
         for item in issues
-            let group = item['type'] ==? 'E' ? 'SyntasticError' : 'SyntasticWarning'
+            let group = 'Syntastic' . get(item, 'subtype', '') . ( item['type'] ==? 'E' ? 'Error' : 'Warning' )
 
             " The function `Syntastic_{filetype}_{checker}_GetHighlightRegex` is
             " used to override default highlighting.
@@ -62,11 +64,7 @@ endfunction " }}}2
 function! g:SyntasticHighlightingNotifier.reset(loclist) " {{{2
     if s:has_highlighting
         call syntastic#log#debug(g:SyntasticDebugNotifications, 'highlighting: reset')
-        for match in getmatches()
-            if stridx(match['group'], 'Syntastic') == 0
-                call matchdelete(match['id'])
-            endif
-        endfor
+        call self._reset()
     endif
 endfunction " }}}2
 " @vimlint(EVL103, 0, a:loclist)
@@ -80,12 +78,25 @@ function! g:SyntasticHighlightingNotifier._setup() " {{{2
     if s:has_highlighting
         if !hlexists('SyntasticError')
             highlight link SyntasticError SpellBad
-
         endif
         if !hlexists('SyntasticWarning')
             highlight link SyntasticWarning SpellCap
         endif
+        if !hlexists('SyntasticStyleError')
+            highlight link SyntasticStyleError SyntasticError
         endif
+        if !hlexists('SyntasticStyleWarning')
+            highlight link SyntasticStyleWarning SyntasticWarning
+        endif
+    endif
+endfunction " }}}2
+
+function! g:SyntasticHighlightingNotifier._reset() " {{{2
+    for match in getmatches()
+        if stridx(match['group'], 'Syntastic') == 0
+            call matchdelete(match['id'])
+        endif
+    endfor
 endfunction " }}}2
 
 " }}}1

sources_non_forked/syntastic/plugin/syntastic/loclist.vim

@@ -20,12 +20,13 @@ function! g:SyntasticLoclist.New(rawLoclist) " {{{2
 
     let newObj._rawLoclist = llist
     let newObj._name = ''
+    let newObj._owner = bufnr('')
 
     return newObj
 endfunction " }}}2
 
 function! g:SyntasticLoclist.current() " {{{2
-    if !exists("b:syntastic_loclist")
+    if !exists("b:syntastic_loclist") || empty(b:syntastic_loclist)
         let b:syntastic_loclist = g:SyntasticLoclist.New([])
     endif
     return b:syntastic_loclist
@@ -37,10 +38,22 @@ function! g:SyntasticLoclist.extend(other) " {{{2
     return g:SyntasticLoclist.New(list)
 endfunction " }}}2
 
+function! g:SyntasticLoclist.sort() " {{{2
+    call syntastic#util#sortLoclist(self._rawLoclist)
+endfunction " }}}2
+
 function! g:SyntasticLoclist.isEmpty() " {{{2
     return empty(self._rawLoclist)
 endfunction " }}}2
 
+function! g:SyntasticLoclist.isNewerThan(stamp) " {{{2
+    if !exists("self._stamp")
+        let self._stamp = []
+        return 0
+    endif
+    return syntastic#util#compareLexi(self._stamp, a:stamp) > 0
+endfunction " }}}2
+
 function! g:SyntasticLoclist.copyRaw() " {{{2
     return copy(self._rawLoclist)
 endfunction " }}}2
@@ -49,6 +62,10 @@ function! g:SyntasticLoclist.getRaw() " {{{2
     return self._rawLoclist
 endfunction " }}}2
 
+function! g:SyntasticLoclist.getBuffers() " {{{2
+    return syntastic#util#unique(map(copy(self._rawLoclist), 'str2nr(v:val["bufnr"])') + [self._owner])
+endfunction " }}}2
+
 function! g:SyntasticLoclist.getStatuslineFlag() " {{{2
     if !exists("self._stl_format")
         let self._stl_format = ''
@@ -114,6 +131,28 @@ function! g:SyntasticLoclist.setName(name) " {{{2
     let self._name = a:name
 endfunction " }}}2
 
+function! g:SyntasticLoclist.getOwner() " {{{2
+    return self._owner
+endfunction " }}}2
+
+function! g:SyntasticLoclist.setOwner(buffer) " {{{2
+    let self._owner = type(a:buffer) == type(0) ? a:buffer : str2nr(a:buffer)
+endfunction " }}}2
+
+function! g:SyntasticLoclist.deploy() " {{{2
+    call self.setOwner(bufnr(''))
+    let self._stamp = syntastic#util#stamp()
+    for buf in self.getBuffers()
+        call setbufvar(buf, 'syntastic_loclist', self)
+    endfor
+endfunction " }}}2
+
+function! g:SyntasticLoclist.destroy() " {{{2
+    for buf in self.getBuffers()
+        call setbufvar(buf, 'syntastic_loclist', {})
+    endfor
+endfunction " }}}2
+
 function! g:SyntasticLoclist.decorate(tag) " {{{2
     for e in self._rawLoclist
         let e['text'] .= ' [' . a:tag . ']'
@@ -212,6 +251,7 @@ function! g:SyntasticLoclist.show() " {{{2
                 if strpart(title, 0, 16) ==# ':SyntasticCheck ' ||
                             \ ( (title == '' || title ==# ':setloclist()') && errors == getloclist(0) )
                     call setwinvar(win, 'quickfix_title', ':SyntasticCheck ' . self._name)
+                    call setbufvar(buf, 'syntastic_owner_buffer', self._owner)
                 endif
             endif
         endfor
@@ -222,7 +262,7 @@ endfunction " }}}2
 
 " Non-method functions {{{1
 
-function! g:SyntasticLoclistHide() " {{{2
+function! SyntasticLoclistHide() " {{{2
     call syntastic#log#debug(g:SyntasticDebugNotifications, 'loclist: hide')
     silent! lclose
 endfunction " }}}2

sources_non_forked/syntastic/plugin/syntastic/modemap.vim

@@ -19,8 +19,8 @@ endfunction " }}}2
 function! g:SyntasticModeMap.synch() " {{{2
     if exists('g:syntastic_mode_map')
         let self._mode = get(g:syntastic_mode_map, 'mode', 'active')
-        let self._activeFiletypes = get(g:syntastic_mode_map, 'active_filetypes', [])
-        let self._passiveFiletypes = get(g:syntastic_mode_map, 'passive_filetypes', [])
+        let self._activeFiletypes = copy(get(g:syntastic_mode_map, 'active_filetypes', []))
+        let self._passiveFiletypes = copy(get(g:syntastic_mode_map, 'passive_filetypes', []))
     else
         let self._mode = 'active'
         let self._activeFiletypes = []
@@ -62,6 +62,27 @@ function! g:SyntasticModeMap.echoMode() " {{{2
     echo "Syntastic: " . self._mode . " mode enabled"
 endfunction " }}}2
 
+function! g:SyntasticModeMap.modeInfo(...) " {{{2
+    echomsg 'Syntastic version: ' . g:syntastic_version
+    let type = a:0 ? a:1 : &filetype
+    echomsg 'Info for filetype: ' . type
+
+    call self.synch()
+    echomsg 'Mode: ' . self._mode
+    if self._mode ==# 'active'
+        if len(self._passiveFiletypes)
+            let plural = len(self._passiveFiletypes) != 1 ? 's' : ''
+            echomsg 'Passive filetype' . plural . ': ' . join(sort(copy(self._passiveFiletypes)))
+        endif
+    else
+        if len(self._activeFiletypes)
+            let plural = len(self._activeFiletypes) != 1 ? 's' : ''
+            echomsg 'Active filetype' . plural . ': ' . join(sort(copy(self._activeFiletypes)))
+        endif
+    endif
+    echomsg 'Filetype ' . type . ' is ' . (self.allowsAutoChecking(type) ? 'active' : 'passive')
+endfunction " }}}2
+
 " }}}1
 
 " Private methods {{{1

sources_non_forked/syntastic/plugin/syntastic/notifiers.vim

@@ -6,6 +6,10 @@ let g:loaded_syntastic_notifiers = 1
 let g:SyntasticNotifiers = {}
 
 let s:notifier_types = ['signs', 'balloons', 'highlighting', 'cursor', 'autoloclist']
+lockvar! s:notifier_types
+
+let s:persistent_notifiers = ['signs', 'balloons']
+lockvar! s:persistent_notifiers
 
 " Public methods {{{1
 
@@ -19,11 +23,27 @@ function! g:SyntasticNotifiers.Instance() " {{{2
 endfunction " }}}2
 
 function! g:SyntasticNotifiers.refresh(loclist) " {{{2
+    if !a:loclist.isEmpty() && !a:loclist.isNewerThan([])
+        " loclist not fully constructed yet
+        return
+    endif
+
     call syntastic#log#debug(g:SyntasticDebugNotifications, 'notifiers: refresh')
     for type in self._enabled_types
         let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '')
         if !has_key(g:{class}, 'enabled') || self._notifier[type].enabled()
+            if index(s:persistent_notifiers, type) > -1
+                " refresh only if loclist has changed since last call
+                if !exists('b:syntastic_' . type . '_stamp')
+                    let b:syntastic_{type}_stamp = []
+                endif
+                if a:loclist.isNewerThan(b:syntastic_{type}_stamp) || a:loclist.isEmpty()
                     call self._notifier[type].refresh(a:loclist)
+                    let b:syntastic_{type}_stamp = syntastic#util#stamp()
+                endif
+            else
+                call self._notifier[type].refresh(a:loclist)
+            endif
         endif
     endfor
 endfunction " }}}2
@@ -39,6 +59,11 @@ function! g:SyntasticNotifiers.reset(loclist) " {{{2
         if has_key(g:{class}, 'reset')
             call self._notifier[type].reset(a:loclist)
         endif
+
+        " also reset stamps
+        if index(s:persistent_notifiers, type) > -1
+            let b:syntastic_{type}_stamp = []
+        endif
     endfor
 endfunction " }}}2
 

sources_non_forked/syntastic/plugin/syntastic/registry.vim

@@ -9,10 +9,13 @@ let s:defaultCheckers = {
         \ 'actionscript':['mxmlc'],
         \ 'ada':         ['gcc'],
         \ 'applescript': ['osacompile'],
+        \ 'arduino':     ['avrgcc'],
         \ 'asciidoc':    ['asciidoc'],
         \ 'asm':         ['gcc'],
+        \ 'bro':         ['bro'],
         \ 'bemhtml':     ['bemhtmllint'],
         \ 'c':           ['gcc'],
+        \ 'cabal':       ['cabal'],
         \ 'chef':        ['foodcritic'],
         \ 'co':          ['coco'],
         \ 'cobol':       ['cobc'],
@@ -27,7 +30,7 @@ let s:defaultCheckers = {
         \ 'dart':        ['dartanalyzer'],
         \ 'docbk':       ['xmllint'],
         \ 'dustjs':      ['swiffer'],
-        \ 'elixir':      ['elixir'],
+        \ 'elixir':      [],
         \ 'erlang':      ['escript'],
         \ 'eruby':       ['ruby'],
         \ 'fortran':     ['gfortran'],
@@ -60,10 +63,10 @@ let s:defaultCheckers = {
         \ 'pod':         ['podchecker'],
         \ 'puppet':      ['puppet', 'puppetlint'],
         \ 'python':      ['python', 'flake8', 'pylint'],
+        \ 'r':           [],
         \ 'racket':      ['racket'],
         \ 'rst':         ['rst2pseudoxml'],
         \ 'ruby':        ['mri'],
-        \ 'rust':        ['rustc'],
         \ 'sass':        ['sass'],
         \ 'scala':       ['fsc', 'scalac'],
         \ 'scss':        ['sass', 'scss_lint'],
@@ -88,12 +91,14 @@ let s:defaultCheckers = {
         \ 'zpt':         ['zptlint'],
         \ 'zsh':         ['zsh', 'shellcheck']
     \ }
+lockvar! s:defaultCheckers
 
 let s:defaultFiletypeMap = {
         \ 'gentoo-metadata': 'xml',
         \ 'lhaskell': 'haskell',
         \ 'litcoffee': 'coffee'
     \ }
+lockvar! s:defaultFiletypeMap
 
 let g:SyntasticRegistry = {}
 
@@ -101,14 +106,13 @@ let g:SyntasticRegistry = {}
 
 " Public methods {{{1
 
-" TODO: Handling of filetype aliases: all public methods take aliases as
+" Note: Handling of filetype aliases: all public methods take aliases as
 " parameters, all private methods take normalized filetypes.  Public methods
 " are thus supposed to normalize filetypes before calling private methods.
 
 function! g:SyntasticRegistry.Instance() " {{{2
     if !exists('s:SyntasticRegistryInstance')
         let s:SyntasticRegistryInstance = copy(self)
-        let s:SyntasticRegistryInstance._checkerRaw = {}
         let s:SyntasticRegistryInstance._checkerMap = {}
     endif
 
@@ -121,29 +125,23 @@ function! g:SyntasticRegistry.CreateAndRegisterChecker(args) " {{{2
     call registry._registerChecker(checker)
 endfunction " }}}2
 
-function! g:SyntasticRegistry.isCheckable(ftalias) " {{{2
+" Given a list of checker names hints_list, return a map name --> checker.
+" If hints_list is empty, user settings are are used instead. Checkers are
+" not checked for availability (that is, the corresponding IsAvailable() are
+" not run).
+function! g:SyntasticRegistry.getCheckers(ftalias, hints_list) " {{{2
     let ft = s:normaliseFiletype(a:ftalias)
-    call self._loadCheckers(ft)
-    return !empty(self._checkerMap[ft])
-endfunction " }}}2
+    call self._loadCheckersFor(ft)
 
-function! g:SyntasticRegistry.getCheckersMap(ftalias) " {{{2
-    let ft = s:normaliseFiletype(a:ftalias)
-    call self._loadCheckers(ft)
-    return self._checkerMap[ft]
-endfunction " }}}2
-
-function! g:SyntasticRegistry.getCheckers(ftalias, list) " {{{2
-    let checkers_map = self.getCheckersMap(a:ftalias)
+    let checkers_map = self._checkerMap[ft]
     if empty(checkers_map)
         return []
     endif
 
-    let ft = s:normaliseFiletype(a:ftalias)
     call self._checkDeprecation(ft)
 
     let names =
-        \ !empty(a:list) ? a:list :
+        \ !empty(a:hints_list) ? syntastic#util#unique(a:hints_list) :
         \ exists('b:syntastic_checkers') ? b:syntastic_checkers :
         \ exists('g:syntastic_' . ft . '_checkers') ? g:syntastic_{ft}_checkers :
         \ get(s:defaultCheckers, ft, 0)
@@ -152,6 +150,12 @@ function! g:SyntasticRegistry.getCheckers(ftalias, list) " {{{2
         \ self._filterCheckersByName(checkers_map, names) : [checkers_map[keys(checkers_map)[0]]]
 endfunction " }}}2
 
+" Same as getCheckers(), but keep only the checkers available.  This runs the
+" corresponding IsAvailable() functions for all checkers.
+function! g:SyntasticRegistry.getCheckersAvailable(ftalias, hints_list) " {{{2
+    return filter(self.getCheckers(a:ftalias, a:hints_list), 'v:val.isAvailable()')
+endfunction " }}}2
+
 function! g:SyntasticRegistry.getKnownFiletypes() " {{{2
     let types = keys(s:defaultCheckers)
 
@@ -168,26 +172,37 @@ function! g:SyntasticRegistry.getKnownFiletypes() " {{{2
     return syntastic#util#unique(types)
 endfunction " }}}2
 
-function! g:SyntasticRegistry.echoInfoFor(ftalias_list) " {{{2
-    echomsg "Syntastic info for filetype: " . join(a:ftalias_list, '.')
+function! g:SyntasticRegistry.getNamesOfAvailableCheckers(ftalias) " {{{2
+    let ft = s:normaliseFiletype(a:ftalias)
+    call self._loadCheckersFor(ft)
+    return keys(filter( copy(self._checkerMap[ft]), 'v:val.isAvailable()' ))
+endfunction " }}}2
 
+function! g:SyntasticRegistry.echoInfoFor(ftalias_list) " {{{2
     let ft_list = syntastic#util#unique(map( copy(a:ftalias_list), 's:normaliseFiletype(v:val)' ))
     if len(ft_list) != 1
         let available = []
         let active = []
 
         for ft in ft_list
-            call extend(available, map( keys(self.getCheckersMap(ft)), 'ft . "/" . v:val' ))
-            call extend(active, map( self.getCheckers(ft, []), 'ft . "/" . v:val.getName()' ))
+            call extend(available, map( self.getNamesOfAvailableCheckers(ft), 'ft . "/" . v:val' ))
+            call extend(active, map( self.getCheckersAvailable(ft, []), 'ft . "/" . v:val.getName()' ))
         endfor
     else
         let ft = ft_list[0]
-        let available = keys(self.getCheckersMap(ft))
-        let active = map(self.getCheckers(ft, []), 'v:val.getName()')
+        let available = self.getNamesOfAvailableCheckers(ft)
+        let active = map(self.getCheckersAvailable(ft, []), 'v:val.getName()')
     endif
 
-    echomsg "Available checker(s): " . join(sort(available))
-    echomsg "Currently enabled checker(s): " . join(active)
+    let cnt = len(available)
+    let plural = cnt != 1 ? 's' : ''
+    let cklist = cnt ? join(sort(available)) : '-'
+    echomsg 'Available checker' . plural . ': ' . cklist
+
+    let cnt = len(active)
+    let plural = cnt != 1 ? 's' : ''
+    let cklist = cnt ? join(active) : '-'
+    echomsg 'Currently enabled checker' . plural . ': ' . cklist
 endfunction " }}}2
 
 " }}}1
@@ -196,52 +211,39 @@ endfunction " }}}2
 
 function! g:SyntasticRegistry._registerChecker(checker) abort " {{{2
     let ft = a:checker.getFiletype()
-
-    if !has_key(self._checkerRaw, ft)
-        let self._checkerRaw[ft] = []
+    if !has_key(self._checkerMap, ft)
         let self._checkerMap[ft] = {}
     endif
 
-    call self._validateUniqueName(a:checker)
-
     let name = a:checker.getName()
-    call add(self._checkerRaw[ft], name)
-
-    if a:checker.isAvailable()
-        let self._checkerMap[ft][name] = a:checker
+    if has_key(self._checkerMap[ft], name)
+        throw 'Syntastic: Duplicate syntax checker name: ' . ft . '/' . name
     endif
+
+    let self._checkerMap[ft][name] = a:checker
 endfunction " }}}2
 
 function! g:SyntasticRegistry._filterCheckersByName(checkers_map, list) " {{{2
     return filter( map(copy(a:list), 'get(a:checkers_map, v:val, {})'), '!empty(v:val)' )
 endfunction " }}}2
 
-function! g:SyntasticRegistry._loadCheckers(filetype) " {{{2
-    if has_key(self._checkerRaw, a:filetype)
+function! g:SyntasticRegistry._loadCheckersFor(filetype) " {{{2
+    if has_key(self._checkerMap, a:filetype)
         return
     endif
 
     execute "runtime! syntax_checkers/" . a:filetype . "/*.vim"
 
-    if !has_key(self._checkerRaw, a:filetype)
-        let self._checkerRaw[a:filetype] = []
+    if !has_key(self._checkerMap, a:filetype)
         let self._checkerMap[a:filetype] = {}
     endif
 endfunction " }}}2
 
-function! g:SyntasticRegistry._validateUniqueName(checker) abort " {{{2
-    let ft = a:checker.getFiletype()
-    let name = a:checker.getName()
-    if index(self._checkerRaw[ft], name) > -1
-        throw 'Syntastic: Duplicate syntax checker name: ' . ft . '/' . name
-    endif
-endfunction " }}}2
-
 " Check for obsolete variable g:syntastic_<filetype>_checker
 function! g:SyntasticRegistry._checkDeprecation(filetype) " {{{2
     if exists('g:syntastic_' . a:filetype . '_checker') && !exists('g:syntastic_' . a:filetype . '_checkers')
         let g:syntastic_{a:filetype}_checkers = [g:syntastic_{a:filetype}_checker]
-        call syntastic#log#deprecationWarn('variable g:syntastic_' . a:filetype . '_checker is deprecated')
+        call syntastic#log#oneTimeWarn('variable g:syntastic_' . a:filetype . '_checker is deprecated')
     endif
 endfunction " }}}2
 

sources_non_forked/syntastic/plugin/syntastic/signs.vim

@@ -25,6 +25,7 @@ function! g:SyntasticSignsNotifier.New() " {{{2
     if !s:setup_done
         call self._setup()
         let s:setup_done = 1
+        lockvar s:setup_done
     endif
 
     return newObj
@@ -41,7 +42,6 @@ function! g:SyntasticSignsNotifier.refresh(loclist) " {{{2
         call self._signErrors(a:loclist)
     endif
     call self._removeSigns(old_signs)
-    let s:first_sign_id = s:next_sign_id
 endfunction " }}}2
 
 " }}}1
@@ -87,15 +87,20 @@ function! g:SyntasticSignsNotifier._signErrors(loclist) " {{{2
     let loclist = a:loclist
     if !loclist.isEmpty()
 
-        " errors some first, so that they are not masked by warnings
         let buf = bufnr('')
+        if !bufloaded(buf)
+            " signs can be placed only in loaded buffers
+            return
+        endif
+
+        " errors come first, so that they are not masked by warnings
         let issues = copy(loclist.errors())
         call extend(issues, loclist.warnings())
         call filter(issues, 'v:val["bufnr"] == buf')
         let seen = {}
 
         for i in issues
-            if !has_key(seen, i['lnum'])
+            if i['lnum'] > 0 && !has_key(seen, i['lnum'])
                 let seen[i['lnum']] = 1
 
                 let sign_severity = i['type'] ==? 'W' ? 'Warning' : 'Error'
@@ -113,9 +118,9 @@ endfunction " }}}2
 " Remove the signs with the given ids from this buffer
 function! g:SyntasticSignsNotifier._removeSigns(ids) " {{{2
     if has('signs')
-        for i in a:ids
-            execute "sign unplace " . i
-            call remove(self._bufSignIds(), index(self._bufSignIds(), i))
+        for s in reverse(copy(a:ids))
+            execute "sign unplace " . s
+            call remove(self._bufSignIds(), index(self._bufSignIds(), s))
         endfor
     endif
 endfunction " }}}2

sources_non_forked/syntastic/syntax_checkers/actionscript/mxmlc.vim

@@ -14,10 +14,6 @@ if exists('g:loaded_syntastic_actionscript_mxmlc_checker')
 endif
 let g:loaded_syntastic_actionscript_mxmlc_checker = 1
 
-if !exists('g:syntastic_actionscript_mxmlc_conf')
-    let g:syntastic_actionscript_mxmlc_conf = ''
-endif
-
 let s:save_cpo = &cpo
 set cpo&vim
 
@@ -45,10 +41,10 @@ function! SyntaxCheckers_actionscript_mxmlc_GetHighlightRegex(item)
 endfunction
 
 function! SyntaxCheckers_actionscript_mxmlc_GetLocList() dict
-    let makeprg = self.makeprgBuild({
-        \ 'args_before': (g:syntastic_actionscript_mxmlc_conf != '' ?
-        \   ' -load-config+=' . g:syntastic_actionscript_mxmlc_conf : ''),
-        \ 'args_after': '-output=' . syntastic#util#DevNull() })
+    call syntastic#log#deprecationWarn('actionscript_mxmlc_conf', 'actionscript_mxmlc_args',
+        \ "'-load-config+=' . syntastic#util#shexpand(OLD_VAR)")
+
+    let makeprg = self.makeprgBuild({ 'args_after': '-output=' . syntastic#util#DevNull() })
 
     let errorformat =
         \ '%f(%l): col: %c %trror: %m,' .

sources_non_forked/syntastic/syntax_checkers/arduino/avrgcc.vim

@@ -0,0 +1,26 @@
+"============================================================================
+"File:        avrgcc.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Karel <karelishere at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_arduino_avrgcc_checker')
+    finish
+endif
+let g:loaded_syntastic_arduino_avrgcc_checker = 1
+
+runtime! syntax_checkers/c/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'c',
+    \ 'name': 'avrgcc',
+    \ 'exec': 'avr-gcc',
+    \ 'redirect': 'c/avrgcc'})
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntastic/syntax_checkers/bemhtml/bemhtmllint.vim

@@ -8,7 +8,7 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
-"
+
 if exists("g:loaded_syntastic_bemhtml_bemhtmllint_checker")
     finish
 endif
@@ -29,6 +29,7 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
     \ 'name': 'bemhtmllint',
     \ 'exec': 'bemhtml-lint' })
 
-
 let &cpo = s:save_cpo
 unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntastic/syntax_checkers/bro/bro.vim

@@ -0,0 +1,45 @@
+"============================================================================
+"File:        bro.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  Justin Azoff <justin.azoff@gmail.com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_bro_bro_checker")
+    finish
+endif
+let g:loaded_syntastic_bro_bro_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_bro_bro_IsAvailable() dict
+    return system(self.getExecEscaped() . ' --help') =~# '--parse-only'
+endfunction
+
+function! SyntaxCheckers_bro_bro_GetLocList() dict
+    let makeprg = self.makeprgBuild({ 'args_before': '--parse-only' })
+
+    "example: error in ./foo.bro, line 3: unknown identifier banana, at or "near "banana"
+    let errorformat =
+        \ '%trror in %f\, line %l: %m,' .
+        \ '%tarning in %f\, line %l: %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'bro',
+    \ 'name': 'bro'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntastic/syntax_checkers/c/avrgcc.vim

@@ -53,3 +53,5 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 
 let &cpo = s:save_cpo
 unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntastic/syntax_checkers/c/checkpatch.vim

@@ -14,24 +14,27 @@ if exists("g:loaded_syntastic_c_checkpatch_checker")
 endif
 let g:loaded_syntastic_c_checkpatch_checker = 1
 
-" Bail if the user doesn't have `checkpatch.pl` or ./scripts/checkpatch.pl installed.
-if executable("checkpatch.pl")
-    let g:syntastic_c_checker_checkpatch_location = 'checkpatch.pl'
-elseif executable("./scripts/checkpatch.pl")
-    let g:syntastic_c_checker_checkpatch_location = './scripts/checkpatch.pl'
-endif
-
 let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_c_checkpatch_IsAvailable() dict
-    return exists("g:syntastic_c_checker_checkpatch_location")
+    call syntastic#log#deprecationWarn('c_checker_checkpatch_location', 'c_checkpatch_exe')
+
+    if !exists('g:syntastic_c_checkpatch_exe') && !executable(self.getExec())
+        if executable('checkpatch')
+            let g:syntastic_c_checkpatch_exe = 'checkpatch'
+        elseif executable('./scripts/checkpatch.pl')
+            let g:syntastic_c_checkpatch_exe = fnamemodify('./scripts/checkpatch.pl', ':p')
+        elseif executable('./scripts/checkpatch')
+            let g:syntastic_c_checkpatch_exe = fnamemodify('./scripts/checkpatch', ':p')
+        endif
+    endif
+
+    return executable(self.getExec())
 endfunction
 
 function! SyntaxCheckers_c_checkpatch_GetLocList() dict
-    let makeprg = self.makeprgBuild({
-        \ 'exe': g:syntastic_c_checker_checkpatch_location,
-        \ 'args_after': '--no-summary --no-tree --terse --file' })
+    let makeprg = self.makeprgBuild({ 'args_after': '--no-summary --no-tree --terse --file' })
 
     let errorformat =
         \ '%f:%l: %tARNING: %m,' .

sources_non_forked/syntastic/syntax_checkers/c/make.vim

@@ -19,7 +19,7 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_c_make_GetLocList() dict
-    let makeprg = self.getExecEscaped() . ' -sk'
+    let makeprg = self.makeprgBuild({ 'args': '-sk', 'fname': '' })
 
     let errorformat =
         \ '%-G%f:%s:,' .

sources_non_forked/syntastic/syntax_checkers/c/oclint.vim

@@ -30,7 +30,6 @@ set cpo&vim
 
 function! SyntaxCheckers_c_oclint_GetLocList() dict
     let makeprg = self.makeprgBuild({
-        \ 'args_after': '-text',
         \ 'post_args_before': '-- -c ' . syntastic#c#ReadConfig(g:syntastic_oclint_config_file) })
 
     let errorformat =
@@ -42,12 +41,16 @@ function! SyntaxCheckers_c_oclint_GetLocList() dict
         \ '%W%f:%l:%c: warning: %m,' .
         \ '%-G%.%#'
 
-    return SyntasticMake({
+    let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
         \ 'subtype': 'Style',
-        \ 'postprocess': ['compressWhitespace', 'sort'],
+        \ 'postprocess': ['compressWhitespace'],
         \ 'returns': [0, 3, 5] })
+
+    call self.setWantSort(1)
+
+    return loclist
 endfunction
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({

sources_non_forked/syntastic/syntax_checkers/c/splint.vim

@@ -35,8 +35,11 @@ function! SyntaxCheckers_c_splint_GetLocList() dict
 
     let errorformat =
         \ '%-G%f:%l:%v: %[%#]%[%#]%[%#] Internal Bug %.%#,' .
+        \ '%-G%f(%l\,%v): %[%#]%[%#]%[%#] Internal Bug %.%#,' .
         \ '%W%f:%l:%v: %m,' .
+        \ '%W%f(%l\,%v): %m,' .
         \ '%W%f:%l: %m,' .
+        \ '%W%f(%l): %m,' .
         \ '%-C %\+In file included from %.%#,' .
         \ '%-C %\+from %.%#,' .
         \ '%+C %.%#'

sources_non_forked/syntastic/syntax_checkers/cabal/cabal.vim

@@ -0,0 +1,55 @@
+"============================================================================
+"File:        cabal.vim
+"Description: Haskell package description (.cabal file) linting and syntax
+"             validation via 'cabal check'
+"Maintainer: Ian D. Bollinger <ian.bollinger@gmail.com>
+"License:    This program is free software. It comes without any warranty,
+"            to the extent permitted by applicable law. You can redistribute
+"            it and/or modify it under the terms of the Do What The Fuck You
+"            Want To Public License, Version 2, as published by Sam Hocevar.
+"            See http://sam.zoy.org/wtfpl/COPYING for more details.
+"============================================================================
+
+if exists('g:loaded_syntastic_cabal_cabal_checker')
+    finish
+endif
+let g:loaded_syntastic_cabal_cabal_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_cabal_cabal_GetHighlightRegex(item)
+    let field = matchstr(a:item['text'], "\\vParse of field '\\zs[^']+")
+    if field != ''
+        return '\v\c^\s*' . field . '\s*:\s*\zs.*$'
+    endif
+    let field = matchstr(a:item['text'], "\\v(^|\\s)'\\zs[^']+\\ze'")
+    if field != ''
+        return '\V\c\<' . escape(field, '\') . '\>'
+    endif
+    return ''
+endfunction
+
+function! SyntaxCheckers_cabal_cabal_GetLocList() dict
+    let makeprg = self.getExecEscaped() . ' check'
+
+    let errorformat =
+        \ '%Ecabal: %f:%l: %m,' .
+        \ '%W* %m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'cwd': expand('%:p:h'),
+        \ 'preprocess': 'cabal',
+        \ 'defaults': {'bufnr': bufnr('')} })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'cabal',
+    \ 'name': 'cabal'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntastic/syntax_checkers/co/coco.vim

@@ -19,7 +19,8 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_co_coco_GetLocList() dict
-    let makeprg = self.makeprgBuild({ 'args_after': '-c -o /tmp' })
+    let tmpdir = $TMPDIR != '' ? $TMPDIR : $TMP != '' ? $TMP : '/tmp'
+    let makeprg = self.makeprgBuild({ 'args_after': '-c -o ' . tmpdir })
 
     let errorformat =
         \ '%EFailed at: %f,' .

sources_non_forked/syntastic/syntax_checkers/coffee/coffeelint.vim

@@ -19,7 +19,11 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_coffee_coffeelint_GetLocList() dict
-    let makeprg = self.makeprgBuild({ 'args_after': '--csv' })
+    if !exists('s:coffeelint_new')
+        let s:coffeelint_new = syntastic#util#versionIsAtLeast(syntastic#util#getVersion(
+            \ self.getExecEscaped() . ' --version'), [1, 4])
+    endif
+    let makeprg = self.makeprgBuild({ 'args_after': (s:coffeelint_new ? '--reporter csv' : '--csv') })
 
     let errorformat =
         \ '%f\,%l\,%\d%#\,%trror\,%m,' .

sources_non_forked/syntastic/syntax_checkers/css/csslint.vim

@@ -19,17 +19,13 @@ if exists('g:loaded_syntastic_css_csslint_checker')
 endif
 let g:loaded_syntastic_css_csslint_checker = 1
 
-if !exists('g:syntastic_csslint_options')
-    let g:syntastic_csslint_options = ''
-endif
-
 let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_css_csslint_GetLocList() dict
-    let makeprg = self.makeprgBuild({
-        \ 'args': g:syntastic_csslint_options,
-        \ 'args_after': '--format=compact' })
+    call syntastic#log#deprecationWarn('csslint_options', 'css_csslint_args')
+
+    let makeprg = self.makeprgBuild({ 'args_after': '--format=compact' })
 
     " Print CSS Lint's error/warning messages from compact format. Ignores blank lines.
     let errorformat =

sources_non_forked/syntastic/syntax_checkers/css/prettycss.vim

@@ -43,13 +43,14 @@ function! SyntaxCheckers_css_prettycss_GetLocList() dict
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
-        \ 'defaults': {'bufnr': bufnr("")},
-        \ 'postprocess': ['sort'] })
+        \ 'defaults': {'bufnr': bufnr("")} })
 
     for e in loclist
         let e["text"] .= ')'
     endfor
 
+    call self.setWantSort(1)
+
     return loclist
 endfunction
 

sources_non_forked/syntastic/syntax_checkers/css/recess.vim

@@ -0,0 +1,26 @@
+"============================================================================
+"File:        recess.vim
+"Description: Syntax checking plugin for syntastic.vim using `recess`
+"             (http://twitter.github.io/recess/).
+"Maintainer:  Tim Carry <tim at pixelastic dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_css_recess_checker")
+    finish
+endif
+let g:loaded_syntastic_css_recess_checker = 1
+
+runtime! syntax_checkers/less/*.vim
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'css',
+    \ 'name': 'recess',
+    \ 'redirect': 'less/recess'})
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntastic/syntax_checkers/d/dmd.vim

@@ -35,6 +35,12 @@ function! SyntaxCheckers_d_dmd_IsAvailable() dict
 endfunction
 
 function! SyntaxCheckers_d_dmd_GetLocList() dict
+    if !exists('g:syntastic_d_include_dirs')
+        let g:syntastic_d_include_dirs = filter(glob($HOME . '/.dub/packages/*', 1, 1), 'isdirectory(v:val)')
+        call map(g:syntastic_d_include_dirs, 'isdirectory(v:val . "/source") ? v:val . "/source" : v:val')
+        call add(g:syntastic_d_include_dirs, './source')
+    endif
+
     return syntastic#c#GetLocList('d', 'dmd', {
         \ 'errorformat':
         \     '%-G%f:%s:,%f(%l): %m,' .

sources_non_forked/syntastic/syntax_checkers/elixir/elixir.vim

@@ -24,6 +24,11 @@ function! SyntaxCheckers_elixir_elixir_IsAvailable() dict
 endfunction
 
 function! SyntaxCheckers_elixir_elixir_GetLocList() dict
+    if !exists('g:syntastic_enable_elixir_checker') || !g:syntastic_enable_elixir_checker
+        call syntastic#log#error('checker elixir/elixir: checks disabled for security reasons; ' .
+            \ 'set g:syntastic_enable_elixir_checker to 1 to override')
+        return []
+    endif
 
     let make_options = {}
     let compile_command = 'elixir'

sources_non_forked/syntastic/syntax_checkers/erlang/escript.vim

@@ -30,7 +30,7 @@ function! SyntaxCheckers_erlang_escript_GetLocList() dict
     endif
 
     let shebang = syntastic#util#parseShebang()
-    if shebang['exe'] =~# '\m\<escript$' || (shebang['exe'] ==# '/usr/bin/env' && shebang['args'][0] ==# 'escript')
+    if shebang['exe'] ==# 'escript'
         let args = '-s'
         let post_args = ''
     else

sources_non_forked/syntastic/syntax_checkers/erlang/syntaxerl.vim

@@ -38,3 +38,5 @@ call g:SyntasticRegistry.CreateAndRegisterChecker({
 
 let &cpo = s:save_cpo
 unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntastic/syntax_checkers/eruby/ruby.vim

@@ -19,22 +19,17 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_eruby_ruby_IsAvailable() dict
-    if !exists("g:syntastic_ruby_exec")
-        let g:syntastic_ruby_exec = self.getExec()
+    if !exists('g:syntastic_eruby_ruby_exec') && exists('g:syntastic_ruby_exec')
+        let g:syntastic_eruby_ruby_exec = g:syntastic_ruby_exec
     endif
-    return executable(expand(g:syntastic_ruby_exec))
+    return executable(self.getExec())
 endfunction
 
 function! SyntaxCheckers_eruby_ruby_GetLocList() dict
-    let exe = syntastic#util#shexpand(g:syntastic_ruby_exec)
-    if !syntastic#util#isRunningWindows()
-        let exe = 'RUBYOPT= ' . exe
-    endif
-
     let fname = "'" . escape(expand('%'), "\\'") . "'"
 
     " TODO: encodings became useful in ruby 1.9 :)
-    if syntastic#util#versionIsAtLeast(syntastic#util#getVersion(exe . ' --version'), [1, 9])
+    if syntastic#util#versionIsAtLeast(syntastic#util#getVersion(self.getExecEscaped(). ' --version'), [1, 9])
         let enc = &fileencoding != '' ? &fileencoding : &encoding
         let encoding_spec = ', :encoding => "' . (enc ==? 'utf-8' ? 'UTF-8' : 'BINARY') . '"'
     else
@@ -43,11 +38,11 @@ function! SyntaxCheckers_eruby_ruby_GetLocList() dict
 
     "gsub fixes issue #7, rails has it's own eruby syntax
     let makeprg =
-        \ exe . ' -rerb -e ' .
+        \ self.getExecEscaped() . ' -rerb -e ' .
         \ syntastic#util#shescape('puts ERB.new(File.read(' .
         \     fname . encoding_spec .
         \     ').gsub(''<%='',''<%''), nil, ''-'').src') .
-        \ ' | ' . exe . ' -c'
+        \ ' | ' . self.getExecEscaped() . ' -c'
 
     let errorformat =
         \ '%-GSyntax OK,'.
@@ -56,9 +51,12 @@ function! SyntaxCheckers_eruby_ruby_GetLocList() dict
         \ '%Z%p^,'.
         \ '%-C%.%#'
 
+    let env = syntastic#util#isRunningWindows() ? {} : { 'RUBYOPT': '' }
+
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
+        \ 'env': env,
         \ 'defaults': { 'bufnr': bufnr(""), 'vcol': 1 } })
 endfunction
 

sources_non_forked/syntastic/syntax_checkers/haml/haml.vim

@@ -19,16 +19,12 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_haml_haml_IsAvailable() dict
-    if !exists('g:syntastic_haml_interpreter')
-        let g:syntastic_haml_interpreter = self.getExec()
-    endif
-    return executable(expand(g:syntastic_haml_interpreter))
+    call syntastic#log#deprecationWarn('haml_interpreter', 'haml_haml_exec')
+    return executable(self.getExec())
 endfunction
 
 function! SyntaxCheckers_haml_haml_GetLocList() dict
-    let makeprg = self.makeprgBuild({
-        \ 'exe': syntastic#util#shexpand(g:syntastic_haml_interpreter),
-        \ 'args_after': '-c' })
+    let makeprg = self.makeprgBuild({ 'args_after': '-c' })
 
     let errorformat =
         \ 'Haml error on line %l: %m,' .

sources_non_forked/syntastic/syntax_checkers/haskell/hdevtools.vim

@@ -19,22 +19,30 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_haskell_hdevtools_GetLocList() dict
-    let makeprg = self.makeprgBuild({
-        \ 'exe': self.getExecEscaped() . ' check',
-        \ 'args': get(g:, 'hdevtools_options', '') })
+    if !exists('g:syntastic_haskell_hdevtools_args') && exists('g:hdevtools_options')
+        call syntastic#log#oneTimeWarn('variable g:hdevtools_options is deprecated, ' .
+            \ 'please use g:syntastic_haskell_hdevtools_args instead')
+        let g:syntastic_haskell_hdevtools_args = g:hdevtools_options
+    endif
 
-    let errorformat= '\%-Z\ %#,'.
-        \ '%W%f:%l:%c:\ Warning:\ %m,'.
-        \ '%W%f:%l:%c:\ Warning:,'.
-        \ '%E%f:%l:%c:\ %m,'.
-        \ '%E%>%f:%l:%c:,'.
-        \ '%+C\ \ %#%m,'.
-        \ '%W%>%f:%l:%c:,'.
-        \ '%+C\ \ %#%tarning:\ %m,'
+    let makeprg = self.makeprgBuild({
+        \ 'exe_after': 'check',
+        \ 'fname': syntastic#util#shexpand('%:p') })
+
+    let errorformat =
+        \ '%-Z %#,'.
+        \ '%W%f:%l:%v: Warning: %m,'.
+        \ '%W%f:%l:%v: Warning:,'.
+        \ '%E%f:%l:%v: %m,'.
+        \ '%E%>%f:%l:%v:,'.
+        \ '%+C  %#%m,'.
+        \ '%W%>%f:%l:%v:,'.
+        \ '%+C  %#%tarning: %m,'
 
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
+        \ 'defaults': {'vcol': 1},
         \ 'postprocess': ['compressWhitespace'] })
 endfunction
 

sources_non_forked/syntastic/syntax_checkers/haskell/hlint.vim

@@ -14,16 +14,18 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_haskell_hlint_GetLocList() dict
-    let makeprg = self.makeprgBuild({})
+    let makeprg = self.makeprgBuild({
+        \ 'fname': syntastic#util#shexpand('%:p')})
 
     let errorformat =
-        \ '%E%f:%l:%c: Error: %m,' .
-        \ '%W%f:%l:%c: Warning: %m,' .
+        \ '%E%f:%l:%v: Error: %m,' .
+        \ '%W%f:%l:%v: Warning: %m,' .
         \ '%C%m'
 
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
+        \ 'defaults': {'vcol': 1},
         \ 'postprocess': ['compressWhitespace'] })
 endfunction
 

sources_non_forked/syntastic/syntax_checkers/haskell/scan.vim

@@ -0,0 +1,43 @@
+"============================================================================
+"File:        scan.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_haskell_scan_checker')
+    finish
+endif
+let g:loaded_syntastic_haskell_scan_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_haskell_scan_GetLocList() dict
+    let makeprg = self.makeprgBuild({})
+
+    let errorformat = '%f:%l:%v: %m'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style' })
+
+    call self.setWantSort(1)
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'haskell',
+    \ 'name': 'scan'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntastic/syntax_checkers/html/jshint.vim

@@ -14,31 +14,25 @@ if exists('g:loaded_syntastic_html_jshint_checker')
 endif
 let g:loaded_syntastic_html_jshint_checker = 1
 
-if !exists('g:syntastic_jshint_exec')
-    let g:syntastic_jshint_exec = 'jshint'
-endif
-
-if !exists('g:syntastic_html_jshint_conf')
-    let g:syntastic_html_jshint_conf = ''
-endif
-
 let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_html_jshint_IsAvailable() dict
-    let exe = expand(g:syntastic_jshint_exec)
-    return executable(exe) &&
-        \ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(exe . ' --version'), [2,4])
+    call syntastic#log#deprecationWarn('jshint_exec', 'html_jshint_exec')
+    return executable(self.getExec()) &&
+        \ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(self.getExecEscaped() . ' --version'), [2,4])
 endfunction
 
 function! SyntaxCheckers_html_jshint_GetLocList() dict
-    let makeprg = self.makeprgBuild({
-        \ 'exe': expand(g:syntastic_jshint_exec),
-        \ 'args': (g:syntastic_html_jshint_conf != '' ? '--config ' . g:syntastic_html_jshint_conf : ''),
-        \ 'args_after': '--verbose --extract always' })
+    call syntastic#log#deprecationWarn('html_jshint_conf', 'html_jshint_args',
+        \ "'--config ' . syntastic#util#shexpand(OLD_VAR)")
+
+    let makeprg = self.makeprgBuild({ 'args_after': '--verbose --extract always' })
 
     let errorformat = '%A%f: line %l\, col %v\, %m \(%t%*\d\)'
 
+    call self.setWantSort(1)
+
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,

sources_non_forked/syntastic/syntax_checkers/html/tidy.vim

@@ -10,7 +10,15 @@
 "
 "============================================================================
 "
-" Checker option:
+" Note: if you need to check HTML5 sources, you might consider installing a
+" fork of HTML Tidy, named "HTML Tidy for HTML5":
+"
+"   http://w3c.github.io/tidy-html5/
+"
+" HTML Tidy for HTML5 can be used without changes by this checker, just install
+" it and point g:syntastic_html_tidy_exec to the executable.
+"
+" Checker options:
 "
 " - g:syntastic_html_tidy_ignore_errors (list; default: [])
 "   list of errors to ignore
@@ -48,19 +56,19 @@ set cpo&vim
 " TODO: join this with xhtml.vim for DRY's sake?
 function! s:TidyEncOptByFenc()
     let tidy_opts = {
-                \'utf-8':        '-utf8',
-                \'ascii':        '-ascii',
-                \'latin1':       '-latin1',
-                \'iso-2022-jp':  '-iso-2022',
-                \'cp1252':       '-win1252',
-                \'macroman':     '-mac',
-                \'utf-16le':     '-utf16le',
-                \'utf-16':       '-utf16',
-                \'big5':         '-big5',
-                \'cp932':        '-shiftjis',
-                \'sjis':         '-shiftjis',
-                \'cp850':        '-ibm858',
-                \}
+            \ 'utf-8':        '-utf8',
+            \ 'ascii':        '-ascii',
+            \ 'latin1':       '-latin1',
+            \ 'iso-2022-jp':  '-iso-2022',
+            \ 'cp1252':       '-win1252',
+            \ 'macroman':     '-mac',
+            \ 'utf-16le':     '-utf16le',
+            \ 'utf-16':       '-utf16',
+            \ 'big5':         '-big5',
+            \ 'cp932':        '-shiftjis',
+            \ 'sjis':         '-shiftjis',
+            \ 'cp850':        '-ibm858',
+        \ }
     return get(tidy_opts, &fileencoding, '-utf8')
 endfunction
 
@@ -115,6 +123,7 @@ let s:ignore_errors = [
         \ "proprietary attribute \"aria-valuenow\"",
         \ "proprietary attribute \"aria-valuetext\""
     \ ]
+lockvar! s:ignore_errors
 
 let s:blocklevel_tags = [
         \ "main",
@@ -127,6 +136,7 @@ let s:blocklevel_tags = [
         \ "figure",
         \ "figcaption"
     \ ]
+lockvar! s:blocklevel_tags
 
 let s:inline_tags = [
         \ "video",
@@ -145,11 +155,13 @@ let s:inline_tags = [
         \ "details",
         \ "datalist"
     \ ]
+lockvar! s:inline_tags
 
 let s:empty_tags = [
         \ "wbr",
         \ "keygen"
     \ ]
+lockvar! s:empty_tags
 
 function! s:IgnoreError(text)
     for i in s:ignore_errors + g:syntastic_html_tidy_ignore_errors
@@ -174,9 +186,7 @@ function! s:Args()
 endfunction
 
 function! SyntaxCheckers_html_tidy_GetLocList() dict
-    let makeprg = self.makeprgBuild({
-        \ 'args_after': s:Args(),
-        \ 'tail': '2>&1' })
+    let makeprg = self.makeprgBuild({ 'args_after': s:Args() })
 
     let errorformat =
         \ '%Wline %l column %v - Warning: %m,' .

sources_non_forked/syntastic/syntax_checkers/java/checkstyle.vim

@@ -37,7 +37,8 @@ function! SyntaxCheckers_java_checkstyle_GetLocList() dict
 
     let makeprg = self.makeprgBuild({
         \ 'args_after': '-cp ' . g:syntastic_java_checkstyle_classpath .
-        \               ' com.puppycrawl.tools.checkstyle.Main -c ' . g:syntastic_java_checkstyle_conf_file .
+        \       ' com.puppycrawl.tools.checkstyle.Main -c ' .
+        \       syntastic#util#shexpand(g:syntastic_java_checkstyle_conf_file) .
         \       ' -f xml',
         \ 'fname': fname })
 

sources_non_forked/syntastic/syntax_checkers/java/javac.vim

@@ -10,32 +10,36 @@
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
 
-if exists("g:loaded_syntastic_java_javac_checker")
+if exists('g:loaded_syntastic_java_javac_checker')
     finish
 endif
 let g:loaded_syntastic_java_javac_checker = 1
-let g:syntastic_java_javac_maven_pom_tags = ["build", "properties"]
+let g:syntastic_java_javac_maven_pom_tags = ['build', 'properties']
 let g:syntastic_java_javac_maven_pom_properties = {}
 let s:has_maven = 0
 
 " Global Options
-if !exists("g:syntastic_java_javac_executable")
+if !exists('g:syntastic_java_javac_executable')
     let g:syntastic_java_javac_executable = 'javac'
 endif
 
-if !exists("g:syntastic_java_maven_executable")
+if !exists('g:syntastic_java_maven_executable')
     let g:syntastic_java_maven_executable = 'mvn'
 endif
 
-if !exists("g:syntastic_java_javac_options")
+if !exists('g:syntastic_java_javac_options')
     let g:syntastic_java_javac_options = '-Xlint'
 endif
 
-if !exists("g:syntastic_java_javac_classpath")
+if !exists('g:syntastic_java_maven_options')
+    let g:syntastic_java_maven_options = ''
+endif
+
+if !exists('g:syntastic_java_javac_classpath')
     let g:syntastic_java_javac_classpath = ''
 endif
 
-if !exists("g:syntastic_java_javac_delete_output")
+if !exists('g:syntastic_java_javac_delete_output')
     let g:syntastic_java_javac_delete_output = 1
 endif
 
@@ -43,20 +47,22 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! s:CygwinPath(path)
-    return substitute(system("cygpath -m " . a:path), '\n', '', 'g')
+    return substitute(system('cygpath -m ' . syntastic#util#shescape(a:path)), "\n", '', 'g')
 endfunction
 
-if !exists("g:syntastic_java_javac_temp_dir")
+if !exists('g:syntastic_java_javac_temp_dir')
     if has('win32') || has('win64')
-        let g:syntastic_java_javac_temp_dir = $TEMP."\\vim-syntastic-javac"
+        let g:syntastic_java_javac_temp_dir = $TEMP . syntastic#util#Slash() . 'vim-syntastic-javac'
     elseif has('win32unix')
         let g:syntastic_java_javac_temp_dir = s:CygwinPath('/tmp/vim-syntastic-javac')
+    elseif $TMPDIR != ''
+        let g:syntastic_java_javac_temp_dir = $TMPDIR . '/vim-syntastic-javac'
     else
         let g:syntastic_java_javac_temp_dir = '/tmp/vim-syntastic-javac'
     endif
 endif
 
-if !exists("g:syntastic_java_javac_autoload_maven_classpath")
+if !exists('g:syntastic_java_javac_autoload_maven_classpath')
     let g:syntastic_java_javac_autoload_maven_classpath = 1
 endif
 
@@ -72,16 +78,16 @@ if !exists('g:syntastic_java_javac_custom_classpath_command')
     let g:syntastic_java_javac_custom_classpath_command = ''
 endif
 
-if !exists("g:syntastic_java_javac_maven_pom_ftime")
+if !exists('g:syntastic_java_javac_maven_pom_ftime')
     let g:syntastic_java_javac_maven_pom_ftime = {}
 endif
 
-if !exists("g:syntastic_java_javac_maven_pom_classpath")
+if !exists('g:syntastic_java_javac_maven_pom_classpath')
     let g:syntastic_java_javac_maven_pom_classpath = {}
 endif
 
 function! s:RemoveCarriageReturn(line)
-    return substitute(a:line, '\r', '', 'g')
+    return substitute(a:line, "\r", '', 'g')
 endfunction
 
 " recursively remove directory and all it's sub-directories
@@ -90,41 +96,30 @@ function! s:RemoveDir(dir)
         for f in split(globpath(a:dir, '*'), "\n")
             call s:RemoveDir(f)
         endfor
-        silent! call system('rmdir ' . a:dir)
+        silent! call system('rmdir ' . syntastic#util#shescape(a:dir))
     else
         silent! call delete(a:dir)
     endif
 endfunction
 
+function! s:ClassSep()
+    return (syntastic#util#isRunningWindows() || has('win32unix')) ? ';' : ':'
+endfunction
+
 function! s:AddToClasspath(classpath, path)
     if a:path == ''
         return a:classpath
     endif
-    if a:classpath != '' && a:path != ''
-        if has('win32') || has('win32unix') || has('win64')
-            return a:classpath . ";" . a:path
-        else
-            return a:classpath . ":" . a:path
-        endif
-    else
-        return a:path
-    endif
+    return (a:classpath != '') ? a:classpath . s:ClassSep() . a:path : a:path
 endfunction
 
 function! s:SplitClasspath(classpath)
-    if a:classpath == ''
-        return []
-    endif
-    if has('win32') || has('win32unix') || has('win64')
-        return split(a:classpath, ";")
-    else
-        return split(a:classpath, ":")
-    endif
+    return split(a:classpath, s:ClassSep())
 endfunction
 
 function! s:LoadConfigFile()
-    if filereadable(g:syntastic_java_javac_config_file)
-        exe 'source '.g:syntastic_java_javac_config_file
+    if filereadable(expand(g:syntastic_java_javac_config_file))
+        exe 'source ' . fnameescape(expand(g:syntastic_java_javac_config_file))
     endif
 endfunction
 
@@ -137,25 +132,25 @@ function! s:SaveClasspath()
     endfor
     " save classpath to config file
     if g:syntastic_java_javac_config_file_enabled
-        if filereadable(g:syntastic_java_javac_config_file)
+        if filereadable(expand(g:syntastic_java_javac_config_file))
             " load lines from config file
-            let lines = readfile(g:syntastic_java_javac_config_file)
+            let lines = readfile(expand(g:syntastic_java_javac_config_file))
             " strip g:syntastic_java_javac_classpath options from config file lines
             let i = 0
             while i < len(lines)
                 if match(lines[i], 'g:syntastic_java_javac_classpath') != -1
                     call remove(lines, i)
-                    let i -= 1
-                endif
+                else
                     let i += 1
+                endif
             endwhile
         else
             let lines = []
         endif
         " add new g:syntastic_java_javac_classpath option to config
-        call add(lines, 'let g:syntastic_java_javac_classpath = "'.path.'"')
+        call add(lines, 'let g:syntastic_java_javac_classpath = ' . string(path))
         " save config file lines
-        call writefile(lines, g:syntastic_java_javac_config_file)
+        call writefile(lines, expand(g:syntastic_java_javac_config_file))
     endif
     " set new classpath
     let g:syntastic_java_javac_classpath = path
@@ -169,7 +164,7 @@ function! s:EditClasspath()
         let path = []
         let pathlines = split(g:syntastic_java_javac_classpath, "\n")
         for p in pathlines
-            let path += s:SplitClasspath(p)
+            call extend(path, s:SplitClasspath(p))
         endfor
         execute (len(path) + 5) . 'sp ' . fnameescape(command)
 
@@ -192,7 +187,7 @@ function! s:SaveConfig()
     let lines = getline(1, line('$'))
     if g:syntastic_java_javac_config_file_enabled
         " save config file lines
-        call writefile(lines, g:syntastic_java_javac_config_file)
+        call writefile(lines, expand(g:syntastic_java_javac_config_file))
     endif
     let &modified = 0
 endfunction
@@ -202,8 +197,8 @@ function! s:EditConfig()
     let winnr = bufwinnr('^' . command . '$')
     if winnr < 0
         let lines = []
-        if filereadable(g:syntastic_java_javac_config_file)
-            let lines = readfile(g:syntastic_java_javac_config_file)
+        if filereadable(expand(g:syntastic_java_javac_config_file))
+            let lines = readfile(expand(g:syntastic_java_javac_config_file))
         endif
         execute (len(lines) + 5) . 'sp ' . fnameescape(command)
 
@@ -223,10 +218,12 @@ endfunction
 
 function! s:GetMavenProperties()
     let mvn_properties = {}
-    let pom = findfile("pom.xml", ".;")
+    let pom = findfile('pom.xml', '.;')
     if s:has_maven && filereadable(pom)
         if !has_key(g:syntastic_java_javac_maven_pom_properties, pom)
-            let mvn_cmd = syntastic#util#shexpand(g:syntastic_java_maven_executable) . ' -f ' . pom
+            let mvn_cmd = syntastic#util#shexpand(g:syntastic_java_maven_executable) .
+                \ ' -f ' . syntastic#util#shescape(pom) .
+                \ ' ' . g:syntastic_java_maven_options
             let mvn_is_managed_tag = 1
             let mvn_settings_output = split(system(mvn_cmd . ' help:effective-pom'), "\n")
             let current_path = 'project'
@@ -239,7 +236,7 @@ function! s:GetMavenProperties()
                     let matches = matchlist(line, '\m^\s*</\([a-zA-Z0-9\-\.]\+\)>\s*$')
                     if !empty(matches)
                         let mvn_is_managed_tag = index(g:syntastic_java_javac_maven_pom_tags, matches[1]) < 0
-                        let current_path  = substitute(current_path, '\m\.' . matches[1] . "$", '', '')
+                        let current_path  = substitute(current_path, '\m\.' . matches[1] . '$', '', '')
                     else
                         let matches = matchlist(line, '\m^\s*<\([a-zA-Z0-9\-\.]\+\)>\(.\+\)</[a-zA-Z0-9\-\.]\+>\s*$')
                         if mvn_is_managed_tag && !empty(matches)
@@ -262,10 +259,12 @@ if g:syntastic_java_javac_config_file_enabled
 endif
 
 function! s:GetMavenClasspath()
-    let pom = findfile("pom.xml", ".;")
+    let pom = findfile('pom.xml', '.;')
     if s:has_maven && filereadable(pom)
         if !has_key(g:syntastic_java_javac_maven_pom_ftime, pom) || g:syntastic_java_javac_maven_pom_ftime[pom] != getftime(pom)
-            let mvn_cmd = syntastic#util#shexpand(g:syntastic_java_maven_executable) . ' -f ' . pom
+            let mvn_cmd = syntastic#util#shexpand(g:syntastic_java_maven_executable) .
+                \ ' -f ' . syntastic#util#shescape(pom) .
+                \ ' ' . g:syntastic_java_maven_options
             let mvn_classpath_output = split(system(mvn_cmd . ' dependency:build-classpath'), "\n")
             let mvn_classpath = ''
             let class_path_next = 0
@@ -308,20 +307,20 @@ function! SyntaxCheckers_java_javac_IsAvailable() dict
 endfunction
 
 function! s:MavenOutputDirectory()
-    let pom = findfile("pom.xml", ".;")
+    let pom = findfile('pom.xml', '.;')
     if s:has_maven && filereadable(pom)
         let mvn_properties = s:GetMavenProperties()
         let output_dir = getcwd()
         if has_key(mvn_properties, 'project.properties.build.dir')
             let output_dir = mvn_properties['project.properties.build.dir']
         endif
-        if stridx(expand( '%:p:h' ), "src.main.java") >= 0
+        if stridx(expand( '%:p:h' ), 'src.main.java') >= 0
             let output_dir .= '/target/classes'
             if has_key(mvn_properties, 'project.build.outputDirectory')
                 let output_dir = mvn_properties['project.build.outputDirectory']
             endif
         endif
-        if stridx(expand( '%:p:h' ), "src.test.java") >= 0
+        if stridx(expand( '%:p:h' ), 'src.test.java') >= 0
             let output_dir .= '/target/test-classes'
             if has_key(mvn_properties, 'project.build.testOutputDirectory')
                 let output_dir = mvn_properties['project.build.testOutputDirectory']
@@ -329,7 +328,7 @@ function! s:MavenOutputDirectory()
         endif
 
         if has('win32unix')
-            let output_dir=s:CygwinPath(output_dir)
+            let output_dir = s:CygwinPath(output_dir)
         endif
         return output_dir
     endif
@@ -337,13 +336,12 @@ function! s:MavenOutputDirectory()
 endfunction
 
 function! SyntaxCheckers_java_javac_GetLocList() dict
-
     let javac_opts = g:syntastic_java_javac_options
 
-    let output_dir = ""
+    let output_dir = ''
     if g:syntastic_java_javac_delete_output
         let output_dir = g:syntastic_java_javac_temp_dir
-        let javac_opts .= ' -d ' . output_dir
+        let javac_opts .= ' -d ' . syntastic#util#shescape(output_dir)
     endif
 
     " load classpath from config file
@@ -354,12 +352,7 @@ function! SyntaxCheckers_java_javac_GetLocList() dict
     let javac_classpath = ''
 
     " add classpathes to javac_classpath
-    if has('win32') || has('win32unix') || has('win64')
-        let javac_classpath_split = ';'
-    else
-        let javac_classpath_split = ':'
-    endif
-    for path in split(g:syntastic_java_javac_classpath, javac_classpath_split)
+    for path in split(g:syntastic_java_javac_classpath, s:ClassSep())
         if path != ''
             try
                 let ps = glob(path, 0, 1)
@@ -378,7 +371,7 @@ function! SyntaxCheckers_java_javac_GetLocList() dict
 
     if s:has_maven && g:syntastic_java_javac_autoload_maven_classpath
         if !g:syntastic_java_javac_delete_output
-            let javac_opts .= ' -d ' . s:MavenOutputDirectory()
+            let javac_opts .= ' -d ' . syntastic#util#shescape(s:MavenOutputDirectory())
         endif
         let javac_classpath = s:AddToClasspath(javac_classpath, s:GetMavenClasspath())
     endif
@@ -386,7 +379,7 @@ function! SyntaxCheckers_java_javac_GetLocList() dict
     " load custom classpath
     if g:syntastic_java_javac_custom_classpath_command != ''
         let lines = system(g:syntastic_java_javac_custom_classpath_command)
-        if has('win32') || has('win32unix') || has('win64')
+        if syntastic#util#isRunningWindows() || has('win32unix')
             let lines = substitute(lines, "\r\n", "\n", 'g')
         endif
         for l in split(lines, "\n")
@@ -395,17 +388,10 @@ function! SyntaxCheckers_java_javac_GetLocList() dict
     endif
 
     if javac_classpath != ''
-        let javac_opts .= ' -cp "' . fnameescape(javac_classpath) . '"'
+        let javac_opts .= ' -cp ' . syntastic#util#shexpand(javac_classpath)
     endif
 
-    " path seperator
-    if has('win32') || has('win32unix') || has('win64')
-        let sep = "\\"
-    else
-        let sep = '/'
-    endif
-
-    let fname = fnameescape(expand ( '%:p:h' ) . sep . expand ( '%:t' ))
+    let fname = expand('%:p:h') . syntastic#util#Slash() . expand ('%:t')
 
     if has('win32unix')
         let fname = s:CygwinPath(fname)
@@ -413,8 +399,7 @@ function! SyntaxCheckers_java_javac_GetLocList() dict
 
     let makeprg = self.makeprgBuild({
         \ 'args': javac_opts,
-        \ 'fname': fname,
-        \ 'tail': '2>&1' })
+        \ 'fname': syntastic#util#shescape(fname) })
 
     " unashamedly stolen from *errorformat-javac* (quickfix.txt) and modified to include error types
     let errorformat =

sources_non_forked/syntastic/syntax_checkers/javascript/closurecompiler.vim

@@ -8,48 +8,36 @@
 "             Want To Public License, Version 2, as published by Sam Hocevar.
 "             See http://sam.zoy.org/wtfpl/COPYING for more details.
 "============================================================================
-"
-" To enable this plugin, edit the .vimrc like this:
-"
-"   let g:syntastic_javascript_checker = "closurecompiler"
-"
-" and set the path to the Google Closure Compiler:
-"
-"   let g:syntastic_javascript_closure_compiler_path = '/path/to/google-closure-compiler.jar'
-"
-" It takes additional options for Google Closure Compiler with the variable
-" g:syntastic_javascript_closure_compiler_options.
-"
 
 if exists("g:loaded_syntastic_javascript_closurecompiler_checker")
     finish
 endif
 let g:loaded_syntastic_javascript_closurecompiler_checker = 1
 
-if !exists("g:syntastic_javascript_closure_compiler_options")
-    let g:syntastic_javascript_closure_compiler_options = ""
-endif
-
 let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_javascript_closurecompiler_IsAvailable() dict
+    call syntastic#log#deprecationWarn('javascript_closure_compiler_path', 'javascript_closurecompiler_path')
+
     return
         \ executable("java") &&
-        \ exists("g:syntastic_javascript_closure_compiler_path") &&
-        \ filereadable(g:syntastic_javascript_closure_compiler_path)
+        \ exists("g:syntastic_javascript_closurecompiler_path") &&
+        \ filereadable(g:syntastic_javascript_closurecompiler_path)
 endfunction
 
 function! SyntaxCheckers_javascript_closurecompiler_GetLocList() dict
-    if exists("g:syntastic_javascript_closure_compiler_file_list")
-        let file_list = join(readfile(g:syntastic_javascript_closure_compiler_file_list))
+    call syntastic#log#deprecationWarn('javascript_closure_compiler_options', 'javascript_closurecompiler_args')
+    call syntastic#log#deprecationWarn('javascript_closure_compiler_file_list', 'javascript_closurecompiler_file_list')
+
+    if exists("g:syntastic_javascript_closurecompiler_file_list")
+        let file_list = join(readfile(g:syntastic_javascript_closurecompiler_file_list))
     else
         let file_list = syntastic#util#shexpand('%')
     endif
 
     let makeprg = self.makeprgBuild({
-        \ 'exe': 'java -jar ' . g:syntastic_javascript_closure_compiler_path,
-        \ 'args': g:syntastic_javascript_closure_compiler_options,
+        \ 'exe_after': '-jar ' . g:syntastic_javascript_closurecompiler_path,
         \ 'args_after': '--js' ,
         \ 'fname': file_list })
 

sources_non_forked/syntastic/syntax_checkers/javascript/eslint.vim

@@ -14,29 +14,35 @@ if exists('g:loaded_syntastic_javascript_eslint_checker')
 endif
 let g:loaded_syntastic_javascript_eslint_checker = 1
 
-if !exists('g:syntastic_javascript_eslint_conf')
-    let g:syntastic_javascript_eslint_conf = ''
-endif
-
 let s:save_cpo = &cpo
 set cpo&vim
 
+function! SyntaxCheckers_javascript_eslint_IsAvailable() dict
+    return
+        \ executable(self.getExec()) &&
+        \ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(self.getExecEscaped() . ' --version'), [0, 1])
+endfunction
+
 function! SyntaxCheckers_javascript_eslint_GetLocList() dict
-    let makeprg = self.makeprgBuild({
-        \ 'args': (g:syntastic_javascript_eslint_conf != '' ? '--config ' . g:syntastic_javascript_eslint_conf : '') })
+    call syntastic#log#deprecationWarn('javascript_eslint_conf', 'javascript_eslint_args',
+        \ "'--config ' . syntastic#util#shexpand(OLD_VAR)")
+
+    let makeprg = self.makeprgBuild({ 'args_before': '-f compact' })
 
     let errorformat =
-        \ '%E%f: line %l\, col %c\, Error - %m'
+        \ '%E%f: line %l\, col %c\, Error - %m,' .
+        \ '%W%f: line %l\, col %c\, Warning - %m'
 
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
-        \ 'errorformat': errorformat,
-        \ 'postprocess': ['sort'] })
+        \ 'errorformat': errorformat })
 
     for e in loclist
         let e['col'] += 1
     endfor
 
+    call self.setWantSort(1)
+
     return loclist
 endfunction
 

sources_non_forked/syntastic/syntax_checkers/javascript/gjslint.vim

@@ -14,16 +14,13 @@ if exists("g:loaded_syntastic_javascript_gjslint_checker")
 endif
 let g:loaded_syntastic_javascript_gjslint_checker = 1
 
-if !exists("g:syntastic_javascript_gjslint_conf")
-    let g:syntastic_javascript_gjslint_conf = ""
-endif
-
 let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_javascript_gjslint_GetLocList() dict
+    call syntastic#log#deprecationWarn('javascript_gjslint_conf', 'javascript_gjslint_args')
+
     let makeprg = self.makeprgBuild({
-        \ 'args': g:syntastic_javascript_gjslint_conf,
         \ 'args_after': '--nosummary --unix_mode --nodebug_indentation --nobeep' })
 
     let errorformat =

sources_non_forked/syntastic/syntax_checkers/javascript/jscs.vim

@@ -19,14 +19,19 @@ set cpo&vim
 
 function! SyntaxCheckers_javascript_jscs_GetLocList() dict
     let makeprg = self.makeprgBuild({ 'args_after': '--no-colors --reporter checkstyle' })
+
     let errorformat = '%f:%t:%l:%c:%m'
-    return SyntasticMake({
+
+    let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
         \ 'subtype': 'Style',
         \ 'preprocess': 'checkstyle',
-        \ 'postprocess': ['sort'],
         \ 'returns': [0, 2] })
+
+    call self.setWantSort(1)
+
+    return loclist
 endfunction
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({

sources_non_forked/syntastic/syntax_checkers/javascript/jshint.vim

@@ -14,36 +14,34 @@ if exists('g:loaded_syntastic_javascript_jshint_checker')
 endif
 let g:loaded_syntastic_javascript_jshint_checker = 1
 
-if !exists('g:syntastic_javascript_jshint_conf')
-    let g:syntastic_javascript_jshint_conf = ''
-endif
-
 let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_javascript_jshint_IsAvailable() dict
-    if !exists('g:syntastic_jshint_exec')
-        let g:syntastic_jshint_exec = self.getExec()
+    call syntastic#log#deprecationWarn('jshint_exec', 'javascript_jshint_exec')
+    if !executable(self.getExec())
+        return 0
     endif
-    return executable(expand(g:syntastic_jshint_exec))
+    let s:jshint_version = syntastic#util#getVersion(self.getExecEscaped() . ' --version')
+    return syntastic#util#versionIsAtLeast(s:jshint_version, [1])
 endfunction
 
 function! SyntaxCheckers_javascript_jshint_GetLocList() dict
-    let exe = syntastic#util#shexpand(g:syntastic_jshint_exec)
+    call syntastic#log#deprecationWarn('javascript_jshint_conf', 'javascript_jshint_args',
+        \ "'--config ' . syntastic#util#shexpand(OLD_VAR)")
+
     if !exists('s:jshint_new')
-        let s:jshint_new =
-            \ syntastic#util#versionIsAtLeast(syntastic#util#getVersion(exe . ' --version'), [1, 1])
+        let s:jshint_new = syntastic#util#versionIsAtLeast(s:jshint_version, [1, 1])
     endif
 
-    let makeprg = self.makeprgBuild({
-        \ 'exe': exe,
-        \ 'args': (g:syntastic_javascript_jshint_conf != '' ? '--config ' . g:syntastic_javascript_jshint_conf : ''),
-        \ 'args_after': (s:jshint_new ? '--verbose ' : '') })
+    let makeprg = self.makeprgBuild({ 'args_after': (s:jshint_new ? '--verbose ' : '') })
 
     let errorformat = s:jshint_new ?
         \ '%A%f: line %l\, col %v\, %m \(%t%*\d\)' :
         \ '%E%f: line %l\, col %v\, %m'
 
+    call self.setWantSort(1)
+
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,

sources_non_forked/syntastic/syntax_checkers/javascript/jsl.vim

@@ -14,16 +14,14 @@ if exists("g:loaded_syntastic_javascript_jsl_checker")
 endif
 let g:loaded_syntastic_javascript_jsl_checker = 1
 
-if !exists("g:syntastic_javascript_jsl_conf")
-    let g:syntastic_javascript_jsl_conf = ""
-endif
-
 let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_javascript_jsl_GetLocList() dict
+    call syntastic#log#deprecationWarn('javascript_jsl_conf', 'javascript_jsl_args',
+        \ "'-conf ' . syntastic#util#shexpand(OLD_VAR)")
+
     let makeprg = self.makeprgBuild({
-        \ 'args': (g:syntastic_javascript_jsl_conf != '' ? '-conf ' . g:syntastic_javascript_jsl_conf : ''),
         \ 'args_after': '-nologo -nofilelisting -nosummary -nocontext -process' })
 
     let errorformat =

sources_non_forked/syntastic/syntax_checkers/javascript/jslint.vim

@@ -22,7 +22,7 @@ set cpo&vim
 function! SyntaxCheckers_javascript_jslint_GetHighlightRegex(item)
     let term = matchstr(a:item['text'], '\mExpected .* and instead saw ''\zs.*\ze''')
     if term != ''
-        let term = '\V' . escape(term, '\')
+        let term = '\V\<' . escape(term, '\') . '\>'
     endif
     return term
 endfunction

sources_non_forked/syntastic/syntax_checkers/javascript/jsxhint.vim

@@ -18,10 +18,6 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_javascript_jsxhint_IsAvailable() dict
-    if !executable('jshint') || !syntastic#util#versionIsAtLeast(syntastic#util#getVersion('jshint --version'), [1, 1])
-        return 0
-    endif
-
     let jsxhint_version = system(self.getExecEscaped() . ' --version')
     return
         \ v:shell_error == 0 &&

sources_non_forked/syntastic/syntax_checkers/less/recess.vim

@@ -0,0 +1,44 @@
+"============================================================================
+"File:        recess.vim
+"Description: Syntax checking plugin for syntastic.vim using `recess`
+"             (http://twitter.github.io/recess/).
+"Maintainer:  Tim Carry <tim at pixelastic dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists('g:loaded_syntastic_less_recess_checker')
+    finish
+endif
+let g:loaded_syntastic_less_recess_checker = 1
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_less_recess_GetLocList() dict
+    let makeprg = self.makeprgBuild({
+        \ 'post_args_after': '--format=compact --stripColors' })
+
+    let errorformat =
+        \ '%E%m in %f,' .
+        \ '%Z %#%l.%.%#,' .
+        \ '%f:%l:%m,' .
+        \ '%-G%.%#'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'less',
+    \ 'name': 'recess'})
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntastic/syntax_checkers/lisp/clisp.vim

@@ -20,13 +20,14 @@ set cpo&vim
 
 function! SyntaxCheckers_lisp_clisp_GetLocList() dict
     let makeprg = self.makeprgBuild({
-        \ 'args_after': '-q -c ' . syntastic#c#NullOutput() })
+        \ 'args_after': '-q',
+        \ 'fname_before': '-c' })
 
     let errorformat  =
         \ '%-G;%.%#,' .
-        \ '%W%>WARNING:%.%#line %l : %m,' .
+        \ '%W%>WARNING:%.%# line %l : %m,' .
         \ '%Z  %#%m,' .
-        \ '%W%>WARNING:%.%#lines %l..%\d\# : %m,' .
+        \ '%W%>WARNING:%.%# lines %l%\%.%\%.%\d%\+ : %m,' .
         \ '%Z  %#%m,' .
         \ '%E%>The following functions were %m,' .
         \ '%Z %m,' .

sources_non_forked/syntastic/syntax_checkers/perl/perl.vim

@@ -50,25 +50,25 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_perl_perl_IsAvailable() dict
-    if !exists('g:syntastic_perl_interpreter')
-        let g:syntastic_perl_interpreter = self.getExec()
+    if !exists('g:syntastic_perl_perl_exec') && exists('g:syntastic_perl_interpreter')
+        let g:syntastic_perl_perl_exec = g:syntastic_perl_interpreter
     endif
 
     " don't call executable() here, to allow things like
     " let g:syntastic_perl_interpreter='/usr/bin/env perl'
-    silent! call system(syntastic#util#shexpand(g:syntastic_perl_interpreter) . ' -e ' . syntastic#util#shescape('exit(0)'))
+    silent! call system(self.getExecEscaped() . ' -e ' . syntastic#util#shescape('exit(0)'))
     return v:shell_error == 0
 endfunction
 
 function! SyntaxCheckers_perl_perl_GetLocList() dict
     if !exists('g:syntastic_enable_perl_checker') || !g:syntastic_enable_perl_checker
-        call syntastic#log#error('checker perl/perl: checks disabled for security reasons; set g:syntastic_enable_perl_checker to 1 to override')
+        call syntastic#log#error('checker perl/perl: checks disabled for security reasons; ' .
+            \ 'set g:syntastic_enable_perl_checker to 1 to override')
         return []
     endif
 
-    let exe = expand(g:syntastic_perl_interpreter)
     if type(g:syntastic_perl_lib_path) == type('')
-        call syntastic#log#deprecationWarn('variable g:syntastic_perl_lib_path should be a list')
+        call syntastic#log#oneTimeWarn('variable g:syntastic_perl_lib_path should be a list')
         let includes = split(g:syntastic_perl_lib_path, ',')
     else
         let includes = copy(syntastic#util#var('perl_lib_path'))
@@ -79,9 +79,7 @@ function! SyntaxCheckers_perl_perl_GetLocList() dict
         \ (index(shebang['args'], '-t') >= 0 ? ' -t' : '')
     let errorformat = '%f:%l:%m'
 
-    let makeprg = self.makeprgBuild({
-        \ 'exe': exe,
-        \ 'args_before': '-c -X ' . extra })
+    let makeprg = self.makeprgBuild({ 'args_before': '-c -X ' . extra })
 
     let errors = SyntasticMake({
         \ 'makeprg': makeprg,
@@ -92,9 +90,7 @@ function! SyntaxCheckers_perl_perl_GetLocList() dict
         return errors
     endif
 
-    let makeprg = self.makeprgBuild({
-        \ 'exe': exe,
-        \ 'args_before': '-c -Mwarnings ' . extra })
+    let makeprg = self.makeprgBuild({ 'args_before': '-c -Mwarnings ' . extra })
 
     return SyntasticMake({
         \ 'makeprg': makeprg,

sources_non_forked/syntastic/syntax_checkers/php/phpcs.vim

@@ -27,8 +27,8 @@ function! SyntaxCheckers_php_phpcs_GetLocList() dict
         \ 'args_after': '--report=csv' })
 
     let errorformat =
-        \ '%-GFile\,Line\,Column\,Type\,Message\,Source\,Severity,'.
-        \ '"%f"\,%l\,%v\,%t%*[a-zA-Z]\,"%m"\,%*[a-zA-Z0-9_.-]\,%*[0-9]'
+        \ '%-GFile\,Line\,Column\,Type\,Message\,Source\,Severity%.%#,'.
+        \ '"%f"\,%l\,%v\,%t%*[a-zA-Z]\,"%m"\,%*[a-zA-Z0-9_.-]\,%*[0-9]%.%#'
 
     return SyntasticMake({
         \ 'makeprg': makeprg,

sources_non_forked/syntastic/syntax_checkers/puppet/puppetlint.vim

@@ -18,11 +18,6 @@ let g:loaded_syntastic_puppet_puppetlint_checker = 1
 let s:save_cpo = &cpo
 set cpo&vim
 
-if exists("g:syntastic_puppet_lint_arguments")
-    let g:syntastic_puppet_puppetlint_args = g:syntastic_puppet_lint_arguments
-    call syntastic#log#deprecationWarn("variable g:syntastic_puppet_lint_arguments is deprecated, please use g:syntastic_puppet_puppetlint_args instead")
-endif
-
 function! SyntaxCheckers_puppet_puppetlint_IsAvailable() dict
     return
         \ executable("puppet") &&
@@ -32,6 +27,8 @@ function! SyntaxCheckers_puppet_puppetlint_IsAvailable() dict
 endfunction
 
 function! SyntaxCheckers_puppet_puppetlint_GetLocList() dict
+    call syntastic#log#deprecationWarn('puppet_lint_arguments', 'puppet_puppetlint_args')
+
     let makeprg = self.makeprgBuild({
         \ 'args_after': '--log-format "%{KIND} [%{check}] %{message} at %{fullpath}:%{linenumber}"' })
 

sources_non_forked/syntastic/syntax_checkers/python/flake8.vim

@@ -27,9 +27,12 @@ function! SyntaxCheckers_python_flake8_GetLocList() dict
         \ '%A%f:%l: %t%n %m,' .
         \ '%-G%.%#'
 
+    let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' }
+
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
-        \ 'errorformat': errorformat })
+        \ 'errorformat': errorformat,
+        \ 'env': env })
 
     for e in loclist
         " E*** and W*** are pep8 errors

sources_non_forked/syntastic/syntax_checkers/python/frosted.vim

@@ -27,9 +27,12 @@ function! SyntaxCheckers_python_frosted_GetLocList() dict
         \ '%-Z%p^,' .
         \ '%-G%.%#'
 
+    let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' }
+
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
+        \ 'env': env,
         \ 'returns': [0, 1] })
 
     for e in loclist

sources_non_forked/syntastic/syntax_checkers/python/pep257.vim

@@ -5,7 +5,7 @@
 "
 " For details about pep257 see: https://github.com/GreenSteam/pep257
 
-if exists("g:loaded_syntastic_python_pep257_checker")
+if exists('g:loaded_syntastic_python_pep257_checker')
     finish
 endif
 let g:loaded_syntastic_python_pep257_checker = 1
@@ -14,24 +14,40 @@ let s:save_cpo = &cpo
 set cpo&vim
 
 function! SyntaxCheckers_python_pep257_GetLocList() dict
+    if !exists('s:pep257_new')
+        let s:pep257_new = syntastic#util#versionIsAtLeast(syntastic#util#getVersion(
+            \ self.getExecEscaped() . ' --version'), [0, 3])
+    endif
+
     let makeprg = self.makeprgBuild({})
 
+    if s:pep257_new
+        let errorformat =
+            \ '%E%f:%l %.%#:,' .
+            \ '%+C        %m'
+    else
         let errorformat =
             \ '%E%f:%l:%c%\%.%\%.%\d%\+:%\d%\+: %m,' .
             \ '%E%f:%l:%c: %m,' .
             \ '%+C    %m'
+    endif
+
+    let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' }
 
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
+        \ 'env': env,
         \ 'subtype': 'Style',
         \ 'preprocess': 'killEmpty',
         \ 'postprocess': ['compressWhitespace'] })
 
-    " pep257 outputs byte offsets rather than column numbers
+    if s:pep257_new == 0
+        " byte offsets rather than column numbers
         for e in loclist
             let e['col'] = get(e, 'col', 0) + 1
         endfor
+    endif
 
     return loclist
 endfunction

sources_non_forked/syntastic/syntax_checkers/python/pep8.vim

@@ -25,9 +25,12 @@ function! SyntaxCheckers_python_pep8_GetLocList() dict
 
     let errorformat = '%f:%l:%c: %m'
 
+    let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' }
+
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
+        \ 'env': env,
         \ 'subtype': 'Style' })
 
     for e in loclist

sources_non_forked/syntastic/syntax_checkers/python/py3kwarn.vim

@@ -18,9 +18,12 @@ function! SyntaxCheckers_python_py3kwarn_GetLocList() dict
 
     let errorformat = '%W%f:%l:%c: %m'
 
+    let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' }
+
     return SyntasticMake({
         \ 'makeprg': makeprg,
-        \ 'errorformat': errorformat })
+        \ 'errorformat': errorformat,
+        \ 'env': env })
 endfunction
 
 call g:SyntasticRegistry.CreateAndRegisterChecker({

sources_non_forked/syntastic/syntax_checkers/python/pyflakes.vim

@@ -26,14 +26,14 @@ function! SyntaxCheckers_python_pyflakes_GetHighlightRegex(i)
         \ || stridx(a:i['text'], 'shadowed by loop variable') >= 0
 
         " fun with Python's %r: try "..." first, then '...'
-        let terms =  split(a:i['text'], '"', 1)
-        if len(terms) > 2
-            return terms[1]
+        let term = matchstr(a:i['text'], '\m^.\{-}"\zs.\{-1,}\ze"')
+        if term != ''
+            return '\V\<' . escape(term, '\') . '\>'
         endif
 
-        let terms =  split(a:i['text'], "'", 1)
-        if len(terms) > 2
-            return terms[1]
+        let term = matchstr(a:i['text'], '\m^.\{-}''\zs.\{-1,}\ze''')
+        if term != ''
+            return '\V\<' . escape(term, '\') . '\>'
         endif
     endif
     return ''
@@ -49,9 +49,12 @@ function! SyntaxCheckers_python_pyflakes_GetLocList() dict
         \ '%E%f:%l: %m,'.
         \ '%-G%.%#'
 
+    let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' }
+
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
+        \ 'env': env,
         \ 'defaults': {'text': "Syntax error"} })
 
     for e in loclist

sources_non_forked/syntastic/syntax_checkers/python/pylama.vim

@@ -30,10 +30,12 @@ function! SyntaxCheckers_python_pylama_GetLocList() dict
         \ '%-GWARNING:pylama:%.%#,' .
         \ '%A%f:%l:%c: %m'
 
+    let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' }
+
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
-        \ 'postprocess': ['sort'] })
+        \ 'env': env })
 
     " adjust for weirdness in each checker
     for e in loclist
@@ -53,6 +55,8 @@ function! SyntaxCheckers_python_pylama_GetLocList() dict
         endif
     endfor
 
+    call self.setWantSort(1)
+
     return loclist
 endfunction
 

sources_non_forked/syntastic/syntax_checkers/python/pylint.vim

@@ -32,10 +32,12 @@ function! SyntaxCheckers_python_pylint_GetLocList() dict
         \ '%-Z%p^%.%#,' .
         \ '%-G%.%#'
 
-    let loclist=SyntasticMake({
+    let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' }
+
+    let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
-        \ 'postprocess': ['sort'],
+        \ 'env': env,
         \ 'returns': range(32) })
 
     for e in loclist
@@ -55,6 +57,8 @@ function! SyntaxCheckers_python_pylint_GetLocList() dict
         let e['vcol'] = 0
     endfor
 
+    call self.setWantSort(1)
+
     return loclist
 endfunction
 
@@ -63,9 +67,10 @@ function! s:PylintNew(exe)
     try
         " On Windows the version is shown as "pylint-script.py 1.0.0".
         " On Gentoo Linux it's "pylint-python2.7 0.28.0".
-        " On NixOS, that would be ".pylint-wrapped 0.26.0", that would be.
+        " On NixOS, that would be ".pylint-wrapped 0.26.0".
+        " On Arch Linux it's "pylint2 1.1.0".
         " Have you guys considered switching to creative writing yet? ;)
-        let pylint_version = filter(split(system(exe . ' --version'), '\m, \=\|\n'), 'v:val =~# ''\m^\.\=pylint\>''')[0]
+        let pylint_version = filter(split(system(exe . ' --version'), '\m, \=\|\n'), 'v:val =~# ''\m^\.\=pylint[-0-9]*\>''')[0]
         let pylint_version = substitute(pylint_version, '\v^\S+\s+', '', '')
         let ret = syntastic#util#versionIsAtLeast(syntastic#util#parseVersion(pylint_version), [1])
     catch /\m^Vim\%((\a\+)\)\=:E684/

sources_non_forked/syntastic/syntax_checkers/python/python.vim

@@ -30,9 +30,12 @@ function! SyntaxCheckers_python_python_GetLocList() dict
 
     let errorformat = '%E%f:%l:%c: %m'
 
+    let env = syntastic#util#isRunningWindows() ? {} : { 'TERM': 'dumb' }
+
     return SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
+        \ 'env': env,
         \ 'returns': [0] })
 endfunction
 

sources_non_forked/syntastic/syntax_checkers/r/lint.vim

@@ -0,0 +1,81 @@
+"============================================================================
+"File:        lint.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+
+if exists("g:loaded_syntastic_r_lint_checker")
+    finish
+endif
+let g:loaded_syntastic_r_lint_checker = 1
+
+if !exists('g:syntastic_r_lint_styles')
+    let g:syntastic_r_lint_styles = 'lint.style'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_r_lint_GetHighlightRegex(item)
+    let term = matchstr(a:item['text'], '\m`\zs[^`]\+\ze`')
+    if term == ''
+        let term = matchstr(a:item['text'], "\\m'\\zs[^']\\+\\ze'")
+    endif
+    return term != '' ? '\V' . escape(term, '\') : ''
+endfunction
+
+function! SyntaxCheckers_r_lint_IsAvailable() dict
+    if !executable(self.getExec())
+        return 0
+    endif
+    call system(self.getExecEscaped() . ' --slave --restore --no-save -e ' . syntastic#util#shescape('library(lint)'))
+    return v:shell_error == 0
+endfunction
+
+function! SyntaxCheckers_r_lint_GetLocList() dict
+    let setwd = syntastic#util#isRunningWindows() ? 'setwd("' . escape(getcwd(), '"\') . '"); ' : ''
+    let setwd = 'setwd("' . escape(getcwd(), '"\') . '"); '
+    let makeprg = self.getExecEscaped() . ' --slave --restore --no-save' .
+        \ ' -e ' . syntastic#util#shescape(setwd . 'library(lint); ' .
+        \       'try(lint(commandArgs(TRUE), ' . g:syntastic_r_lint_styles . '))') .
+        \ ' --args ' . syntastic#util#shexpand('%')
+
+    let errorformat =
+        \ '%t:%f:%l:%v: %m,' .
+        \ '%t:%f:%l: %m'
+
+    let loclist = SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'subtype': 'Style',
+        \ 'preprocess': 'rparse',
+        \ 'returns': [0] })
+
+    for e in loclist
+        if e['type'] == 'F'
+            " parse error
+            let e['type'] = 'E'
+            call remove(e, 'subtype')
+        endif
+    endfor
+
+    call self.setWantSort(1)
+
+    return loclist
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'r',
+    \ 'name': 'lint',
+    \ 'exec': 'R' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntastic/syntax_checkers/r/svtools.vim

@@ -0,0 +1,78 @@
+"============================================================================
+"File:        svtools.vim
+"Description: Syntax checking plugin for syntastic.vim
+"Maintainer:  LCD 47 <lcd047 at gmail dot com>
+"License:     This program is free software. It comes without any warranty,
+"             to the extent permitted by applicable law. You can redistribute
+"             it and/or modify it under the terms of the Do What The Fuck You
+"             Want To Public License, Version 2, as published by Sam Hocevar.
+"             See http://sam.zoy.org/wtfpl/COPYING for more details.
+"
+"============================================================================
+"
+" Security:
+"
+" This checker runs the code in your file.  This is probably fine if you
+" wrote the file yourself, but it can be a problem if you're trying to
+" check third party files.  If you are 100% willing to let Vim run the
+" code in your file, set g:syntastic_enable_r_svtools_checker to 1 in
+" your vimrc to enable this checker:
+"
+"   let g:syntastic_enable_r_svtools_checker = 1
+
+if exists("g:loaded_syntastic_r_svtools_checker")
+    finish
+endif
+let g:loaded_syntastic_r_svtools_checker = 1
+
+if !exists('g:syntastic_r_svtools_styles')
+    let g:syntastic_r_svtools_styles = 'lint.style'
+endif
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! SyntaxCheckers_r_svtools_GetHighlightRegex(item)
+    let term = matchstr(a:item['text'], "\\m'\\zs[^']\\+\\ze'")
+    return term != '' ? '\V' . escape(term, '\') : ''
+endfunction
+
+function! SyntaxCheckers_r_svtools_IsAvailable() dict
+    if !executable(self.getExec())
+        return 0
+    endif
+    call system(self.getExecEscaped() . ' --slave --restore --no-save -e ' . syntastic#util#shescape('library(svTools)'))
+    return v:shell_error == 0
+endfunction
+
+function! SyntaxCheckers_r_svtools_GetLocList() dict
+    if !exists('g:syntastic_enable_r_svtools_checker') || !g:syntastic_enable_r_svtools_checker
+        call syntastic#log#error('checker r/svtools: checks disabled for security reasons; set g:syntastic_enable_r_svtools_checker to 1 to override')
+        return []
+    endif
+
+    let setwd = syntastic#util#isRunningWindows() ? 'setwd("' . escape(getcwd(), '"\') . '"); ' : ''
+    let makeprg = self.getExecEscaped() . ' --slave --restore --no-save' .
+        \ ' -e ' . syntastic#util#shescape(setwd . 'library(svTools); ' .
+        \       'try(lint(commandArgs(TRUE), filename = commandArgs(TRUE), type = "flat", sep = ":"))') .
+        \ ' --args ' . syntastic#util#shexpand('%')
+
+    let errorformat =
+        \ '%trror:%f:%\s%#%l:%\s%#%v:%m,' .
+        \ '%tarning:%f:%\s%#%l:%\s%#%v:%m'
+
+    return SyntasticMake({
+        \ 'makeprg': makeprg,
+        \ 'errorformat': errorformat,
+        \ 'returns': [0] })
+endfunction
+
+call g:SyntasticRegistry.CreateAndRegisterChecker({
+    \ 'filetype': 'r',
+    \ 'name': 'svtools',
+    \ 'exec': 'R' })
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim: set et sts=4 sw=4:

sources_non_forked/syntastic/syntax_checkers/racket/code-ayatollah.vim

@@ -38,13 +38,14 @@ function! SyntaxCheckers_racket_code_ayatollah_GetLocList() dict
     let loclist = SyntasticMake({
         \ 'makeprg': makeprg,
         \ 'errorformat': errorformat,
-        \ 'subtype': 'Style',
-        \ 'postprocess': ['sort'] })
+        \ 'subtype': 'Style' })
 
     for e in loclist
         let e['col'] += 1
     endfor
 
+    call self.setWantSort(1)
+
     return loclist
 endfunction