Update Dockerfile to have user with some configs
• Use demo user inside the container • Add .bashrc and .vimrc/.vim config filesmaster
Buddy Sandidge
10 years ago
parent
932a7e9182
commit
a82ce15c24
@ -0,0 +1,114 @@
|
||||
# ~/.bashrc: executed by bash(1) for non-login shells.
|
||||
# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
|
||||
# for examples
|
||||
|
||||
# If not running interactively, don't do anything
|
||||
case $- in
|
||||
*i*) ;;
|
||||
*) return;;
|
||||
esac
|
||||
|
||||
# don't put duplicate lines or lines starting with space in the history.
|
||||
# See bash(1) for more options
|
||||
HISTCONTROL=ignoreboth
|
||||
|
||||
# append to the history file, don't overwrite it
|
||||
shopt -s histappend
|
||||
|
||||
# for setting history length see HISTSIZE and HISTFILESIZE in bash(1)
|
||||
HISTSIZE=1000
|
||||
HISTFILESIZE=2000
|
||||
|
||||
# check the window size after each command and, if necessary,
|
||||
# update the values of LINES and COLUMNS.
|
||||
shopt -s checkwinsize
|
||||
|
||||
# If set, the pattern "**" used in a pathname expansion context will
|
||||
# match all files and zero or more directories and subdirectories.
|
||||
#shopt -s globstar
|
||||
|
||||
# make less more friendly for non-text input files, see lesspipe(1)
|
||||
[ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"
|
||||
|
||||
# set variable identifying the chroot you work in (used in the prompt below)
|
||||
if [ -z "${debian_chroot:-}" ] && [ -r /etc/debian_chroot ]; then
|
||||
debian_chroot=$(cat /etc/debian_chroot)
|
||||
fi
|
||||
|
||||
# set a fancy prompt (non-color, unless we know we "want" color)
|
||||
case "$TERM" in
|
||||
xterm-color) color_prompt=yes;;
|
||||
esac
|
||||
|
||||
# uncomment for a colored prompt, if the terminal has the capability; turned
|
||||
# off by default to not distract the user: the focus in a terminal window
|
||||
# should be on the output of commands, not on the prompt
|
||||
force_color_prompt=yes
|
||||
|
||||
if [ -n "$force_color_prompt" ]; then
|
||||
if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then
|
||||
# We have color support; assume it's compliant with Ecma-48
|
||||
# (ISO/IEC-6429). (Lack of such support is extremely rare, and such
|
||||
# a case would tend to support setf rather than setaf.)
|
||||
color_prompt=yes
|
||||
else
|
||||
color_prompt=
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ "$color_prompt" = yes ]; then
|
||||
PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\n\$ '
|
||||
else
|
||||
PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\n\$ '
|
||||
fi
|
||||
unset color_prompt force_color_prompt
|
||||
|
||||
# If this is an xterm set the title to user@host:dir
|
||||
case "$TERM" in
|
||||
xterm*|rxvt*)
|
||||
PS1="\[\e]0;${debian_chroot:+($debian_chroot)}\u@\h: \w\a\]$PS1"
|
||||
;;
|
||||
*)
|
||||
;;
|
||||
esac
|
||||
|
||||
# enable color support of ls and also add handy aliases
|
||||
if [ -x /usr/bin/dircolors ]; then
|
||||
test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"
|
||||
alias ls='ls --color=auto'
|
||||
#alias dir='dir --color=auto'
|
||||
#alias vdir='vdir --color=auto'
|
||||
|
||||
alias grep='grep --color=auto'
|
||||
alias fgrep='fgrep --color=auto'
|
||||
alias egrep='egrep --color=auto'
|
||||
fi
|
||||
|
||||
# some more ls aliases
|
||||
alias ll='ls -alF'
|
||||
alias la='ls -A'
|
||||
alias l='ls -CF'
|
||||
|
||||
# Add an "alert" alias for long running commands. Use like so:
|
||||
# sleep 10; alert
|
||||
alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'
|
||||
|
||||
# Alias definitions.
|
||||
# You may want to put all your additions into a separate file like
|
||||
# ~/.bash_aliases, instead of adding them here directly.
|
||||
# See /usr/share/doc/bash-doc/examples in the bash-doc package.
|
||||
|
||||
if [ -f ~/.bash_aliases ]; then
|
||||
. ~/.bash_aliases
|
||||
fi
|
||||
|
||||
# enable programmable completion features (you don't need to enable
|
||||
# this, if it's already enabled in /etc/bash.bashrc and /etc/profile
|
||||
# sources /etc/bash.bashrc).
|
||||
if ! shopt -oq posix; then
|
||||
if [ -f /usr/share/bash-completion/bash_completion ]; then
|
||||
. /usr/share/bash-completion/bash_completion
|
||||
elif [ -f /etc/bash_completion ]; then
|
||||
. /etc/bash_completion
|
||||
fi
|
||||
fi
|
||||
@ -0,0 +1,347 @@
|
||||
" pathogen.vim - path option manipulation
|
||||
" Maintainer: Tim Pope <http://tpo.pe/>
|
||||
" Version: 2.3
|
||||
|
||||
" Install in ~/.vim/autoload (or ~\vimfiles\autoload).
|
||||
"
|
||||
" For management of individually installed plugins in ~/.vim/bundle (or
|
||||
" ~\vimfiles\bundle), adding `execute pathogen#infect()` to the top of your
|
||||
" .vimrc is the only other setup necessary.
|
||||
"
|
||||
" The API is documented inline below.
|
||||
|
||||
if exists("g:loaded_pathogen") || &cp
|
||||
finish
|
||||
endif
|
||||
let g:loaded_pathogen = 1
|
||||
|
||||
" Point of entry for basic default usage. Give a relative path to invoke
|
||||
" pathogen#interpose() (defaults to "bundle/{}"), or an absolute path to invoke
|
||||
" pathogen#surround(). Curly braces are expanded with pathogen#expand():
|
||||
" "bundle/{}" finds all subdirectories inside "bundle" inside all directories
|
||||
" in the runtime path.
|
||||
function! pathogen#infect(...) abort
|
||||
for path in a:0 ? filter(reverse(copy(a:000)), 'type(v:val) == type("")') : ['bundle/{}']
|
||||
if path =~# '^\%({\=[$~\\/]\|{\=\w:[\\/]\).*[{}*]'
|
||||
call pathogen#surround(path)
|
||||
elseif path =~# '^\%([$~\\/]\|\w:[\\/]\)'
|
||||
call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')')
|
||||
call pathogen#surround(path . '/{}')
|
||||
elseif path =~# '[{}*]'
|
||||
call pathogen#interpose(path)
|
||||
else
|
||||
call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')')
|
||||
call pathogen#interpose(path . '/{}')
|
||||
endif
|
||||
endfor
|
||||
call pathogen#cycle_filetype()
|
||||
if pathogen#is_disabled($MYVIMRC)
|
||||
return 'finish'
|
||||
endif
|
||||
return ''
|
||||
endfunction
|
||||
|
||||
" Split a path into a list.
|
||||
function! pathogen#split(path) abort
|
||||
if type(a:path) == type([]) | return a:path | endif
|
||||
if empty(a:path) | return [] | endif
|
||||
let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
|
||||
return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
|
||||
endfunction
|
||||
|
||||
" Convert a list to a path.
|
||||
function! pathogen#join(...) abort
|
||||
if type(a:1) == type(1) && a:1
|
||||
let i = 1
|
||||
let space = ' '
|
||||
else
|
||||
let i = 0
|
||||
let space = ''
|
||||
endif
|
||||
let path = ""
|
||||
while i < a:0
|
||||
if type(a:000[i]) == type([])
|
||||
let list = a:000[i]
|
||||
let j = 0
|
||||
while j < len(list)
|
||||
let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g')
|
||||
let path .= ',' . escaped
|
||||
let j += 1
|
||||
endwhile
|
||||
else
|
||||
let path .= "," . a:000[i]
|
||||
endif
|
||||
let i += 1
|
||||
endwhile
|
||||
return substitute(path,'^,','','')
|
||||
endfunction
|
||||
|
||||
" Convert a list to a path with escaped spaces for 'path', 'tag', etc.
|
||||
function! pathogen#legacyjoin(...) abort
|
||||
return call('pathogen#join',[1] + a:000)
|
||||
endfunction
|
||||
|
||||
" Turn filetype detection off and back on again if it was already enabled.
|
||||
function! pathogen#cycle_filetype() abort
|
||||
if exists('g:did_load_filetypes')
|
||||
filetype off
|
||||
filetype on
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" Check if a bundle is disabled. A bundle is considered disabled if its
|
||||
" basename or full name is included in the list g:pathogen_disabled.
|
||||
function! pathogen#is_disabled(path) abort
|
||||
if a:path =~# '\~$'
|
||||
return 1
|
||||
endif
|
||||
let sep = pathogen#slash()
|
||||
let blacklist = map(
|
||||
\ get(g:, 'pathogen_blacklist', get(g:, 'pathogen_disabled', [])) +
|
||||
\ pathogen#split($VIMBLACKLIST),
|
||||
\ 'substitute(v:val, "[\\/]$", "", "")')
|
||||
return index(blacklist, fnamemodify(a:path, ':t')) != -1 || index(blacklist, a:path) != -1
|
||||
endfunction "}}}1
|
||||
|
||||
" Prepend the given directory to the runtime path and append its corresponding
|
||||
" after directory. Curly braces are expanded with pathogen#expand().
|
||||
function! pathogen#surround(path) abort
|
||||
let sep = pathogen#slash()
|
||||
let rtp = pathogen#split(&rtp)
|
||||
let path = fnamemodify(a:path, ':p:?[\\/]\=$??')
|
||||
let before = filter(pathogen#expand(path), '!pathogen#is_disabled(v:val)')
|
||||
let after = filter(reverse(pathogen#expand(path.sep.'after')), '!pathogen#is_disabled(v:val[0:-7])')
|
||||
call filter(rtp, 'index(before + after, v:val) == -1')
|
||||
let &rtp = pathogen#join(before, rtp, after)
|
||||
return &rtp
|
||||
endfunction
|
||||
|
||||
" For each directory in the runtime path, add a second entry with the given
|
||||
" argument appended. Curly braces are expanded with pathogen#expand().
|
||||
function! pathogen#interpose(name) abort
|
||||
let sep = pathogen#slash()
|
||||
let name = a:name
|
||||
if has_key(s:done_bundles, name)
|
||||
return ""
|
||||
endif
|
||||
let s:done_bundles[name] = 1
|
||||
let list = []
|
||||
for dir in pathogen#split(&rtp)
|
||||
if dir =~# '\<after$'
|
||||
let list += reverse(filter(pathogen#expand(dir[0:-6].name.sep.'after'), '!pathogen#is_disabled(v:val[0:-7])')) + [dir]
|
||||
else
|
||||
let list += [dir] + filter(pathogen#expand(dir.sep.name), '!pathogen#is_disabled(v:val)')
|
||||
endif
|
||||
endfor
|
||||
let &rtp = pathogen#join(pathogen#uniq(list))
|
||||
return 1
|
||||
endfunction
|
||||
|
||||
let s:done_bundles = {}
|
||||
|
||||
" Invoke :helptags on all non-$VIM doc directories in runtimepath.
|
||||
function! pathogen#helptags() abort
|
||||
let sep = pathogen#slash()
|
||||
for glob in pathogen#split(&rtp)
|
||||
for dir in map(split(glob(glob), "\n"), 'v:val.sep."/doc/".sep')
|
||||
if (dir)[0 : strlen($VIMRUNTIME)] !=# $VIMRUNTIME.sep && filewritable(dir) == 2 && !empty(split(glob(dir.'*.txt'))) && (!filereadable(dir.'tags') || filewritable(dir.'tags'))
|
||||
silent! execute 'helptags' pathogen#fnameescape(dir)
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
command! -bar Helptags :call pathogen#helptags()
|
||||
|
||||
" Execute the given command. This is basically a backdoor for --remote-expr.
|
||||
function! pathogen#execute(...) abort
|
||||
for command in a:000
|
||||
execute command
|
||||
endfor
|
||||
return ''
|
||||
endfunction
|
||||
|
||||
" Section: Unofficial
|
||||
|
||||
function! pathogen#is_absolute(path) abort
|
||||
return a:path =~# (has('win32') ? '^\%([\\/]\|\w:\)[\\/]\|^[~$]' : '^[/~$]')
|
||||
endfunction
|
||||
|
||||
" Given a string, returns all possible permutations of comma delimited braced
|
||||
" alternatives of that string. pathogen#expand('/{a,b}/{c,d}') yields
|
||||
" ['/a/c', '/a/d', '/b/c', '/b/d']. Empty braces are treated as a wildcard
|
||||
" and globbed. Actual globs are preserved.
|
||||
function! pathogen#expand(pattern) abort
|
||||
if a:pattern =~# '{[^{}]\+}'
|
||||
let [pre, pat, post] = split(substitute(a:pattern, '\(.\{-\}\){\([^{}]\+\)}\(.*\)', "\\1\001\\2\001\\3", ''), "\001", 1)
|
||||
let found = map(split(pat, ',', 1), 'pre.v:val.post')
|
||||
let results = []
|
||||
for pattern in found
|
||||
call extend(results, pathogen#expand(pattern))
|
||||
endfor
|
||||
return results
|
||||
elseif a:pattern =~# '{}'
|
||||
let pat = matchstr(a:pattern, '^.*{}[^*]*\%($\|[\\/]\)')
|
||||
let post = a:pattern[strlen(pat) : -1]
|
||||
return map(split(glob(substitute(pat, '{}', '*', 'g')), "\n"), 'v:val.post')
|
||||
else
|
||||
return [a:pattern]
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" \ on Windows unless shellslash is set, / everywhere else.
|
||||
function! pathogen#slash() abort
|
||||
return !exists("+shellslash") || &shellslash ? '/' : '\'
|
||||
endfunction
|
||||
|
||||
function! pathogen#separator() abort
|
||||
return pathogen#slash()
|
||||
endfunction
|
||||
|
||||
" Convenience wrapper around glob() which returns a list.
|
||||
function! pathogen#glob(pattern) abort
|
||||
let files = split(glob(a:pattern),"\n")
|
||||
return map(files,'substitute(v:val,"[".pathogen#slash()."/]$","","")')
|
||||
endfunction "}}}1
|
||||
|
||||
" Like pathogen#glob(), only limit the results to directories.
|
||||
function! pathogen#glob_directories(pattern) abort
|
||||
return filter(pathogen#glob(a:pattern),'isdirectory(v:val)')
|
||||
endfunction "}}}1
|
||||
|
||||
" Remove duplicates from a list.
|
||||
function! pathogen#uniq(list) abort
|
||||
let i = 0
|
||||
let seen = {}
|
||||
while i < len(a:list)
|
||||
if (a:list[i] ==# '' && exists('empty')) || has_key(seen,a:list[i])
|
||||
call remove(a:list,i)
|
||||
elseif a:list[i] ==# ''
|
||||
let i += 1
|
||||
let empty = 1
|
||||
else
|
||||
let seen[a:list[i]] = 1
|
||||
let i += 1
|
||||
endif
|
||||
endwhile
|
||||
return a:list
|
||||
endfunction
|
||||
|
||||
" Backport of fnameescape().
|
||||
function! pathogen#fnameescape(string) abort
|
||||
if exists('*fnameescape')
|
||||
return fnameescape(a:string)
|
||||
elseif a:string ==# '-'
|
||||
return '\-'
|
||||
else
|
||||
return substitute(escape(a:string," \t\n*?[{`$\\%#'\"|!<"),'^[+>]','\\&','')
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" Like findfile(), but hardcoded to use the runtimepath.
|
||||
function! pathogen#runtime_findfile(file,count) abort "{{{1
|
||||
let rtp = pathogen#join(1,pathogen#split(&rtp))
|
||||
let file = findfile(a:file,rtp,a:count)
|
||||
if file ==# ''
|
||||
return ''
|
||||
else
|
||||
return fnamemodify(file,':p')
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" Section: Deprecated
|
||||
|
||||
function! s:warn(msg) abort
|
||||
echohl WarningMsg
|
||||
echomsg a:msg
|
||||
echohl NONE
|
||||
endfunction
|
||||
|
||||
" Prepend all subdirectories of path to the rtp, and append all 'after'
|
||||
" directories in those subdirectories. Deprecated.
|
||||
function! pathogen#runtime_prepend_subdirectories(path) abort
|
||||
call s:warn('Change pathogen#runtime_prepend_subdirectories('.string(a:path).') to pathogen#infect('.string(a:path.'/{}').')')
|
||||
return pathogen#surround(a:path . pathogen#slash() . '{}')
|
||||
endfunction
|
||||
|
||||
function! pathogen#incubate(...) abort
|
||||
let name = a:0 ? a:1 : 'bundle/{}'
|
||||
call s:warn('Change pathogen#incubate('.(a:0 ? string(a:1) : '').') to pathogen#infect('.string(name).')')
|
||||
return pathogen#interpose(name)
|
||||
endfunction
|
||||
|
||||
" Deprecated alias for pathogen#interpose().
|
||||
function! pathogen#runtime_append_all_bundles(...) abort
|
||||
if a:0
|
||||
call s:warn('Change pathogen#runtime_append_all_bundles('.string(a:1).') to pathogen#infect('.string(a:1.'/{}').')')
|
||||
else
|
||||
call s:warn('Change pathogen#runtime_append_all_bundles() to pathogen#infect()')
|
||||
endif
|
||||
return pathogen#interpose(a:0 ? a:1 . '/{}' : 'bundle/{}')
|
||||
endfunction
|
||||
|
||||
if exists(':Vedit')
|
||||
finish
|
||||
endif
|
||||
|
||||
let s:vopen_warning = 0
|
||||
|
||||
function! s:find(count,cmd,file,lcd)
|
||||
let rtp = pathogen#join(1,pathogen#split(&runtimepath))
|
||||
let file = pathogen#runtime_findfile(a:file,a:count)
|
||||
if file ==# ''
|
||||
return "echoerr 'E345: Can''t find file \"".a:file."\" in runtimepath'"
|
||||
endif
|
||||
if !s:vopen_warning
|
||||
let s:vopen_warning = 1
|
||||
let warning = '|echohl WarningMsg|echo "Install scriptease.vim to continue using :V'.a:cmd.'"|echohl NONE'
|
||||
else
|
||||
let warning = ''
|
||||
endif
|
||||
if a:lcd
|
||||
let path = file[0:-strlen(a:file)-2]
|
||||
execute 'lcd `=path`'
|
||||
return a:cmd.' '.pathogen#fnameescape(a:file) . warning
|
||||
else
|
||||
return a:cmd.' '.pathogen#fnameescape(file) . warning
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! s:Findcomplete(A,L,P)
|
||||
let sep = pathogen#slash()
|
||||
let cheats = {
|
||||
\'a': 'autoload',
|
||||
\'d': 'doc',
|
||||
\'f': 'ftplugin',
|
||||
\'i': 'indent',
|
||||
\'p': 'plugin',
|
||||
\'s': 'syntax'}
|
||||
if a:A =~# '^\w[\\/]' && has_key(cheats,a:A[0])
|
||||
let request = cheats[a:A[0]].a:A[1:-1]
|
||||
else
|
||||
let request = a:A
|
||||
endif
|
||||
let pattern = substitute(request,'/\|\'.sep,'*'.sep,'g').'*'
|
||||
let found = {}
|
||||
for path in pathogen#split(&runtimepath)
|
||||
let path = expand(path, ':p')
|
||||
let matches = split(glob(path.sep.pattern),"\n")
|
||||
call map(matches,'isdirectory(v:val) ? v:val.sep : v:val')
|
||||
call map(matches,'expand(v:val, ":p")[strlen(path)+1:-1]')
|
||||
for match in matches
|
||||
let found[match] = 1
|
||||
endfor
|
||||
endfor
|
||||
return sort(keys(found))
|
||||
endfunction
|
||||
|
||||
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Ve :execute s:find(<count>,'edit<bang>',<q-args>,0)
|
||||
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vedit :execute s:find(<count>,'edit<bang>',<q-args>,0)
|
||||
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vopen :execute s:find(<count>,'edit<bang>',<q-args>,1)
|
||||
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vsplit :execute s:find(<count>,'split',<q-args>,<bang>1)
|
||||
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vvsplit :execute s:find(<count>,'vsplit',<q-args>,<bang>1)
|
||||
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vtabedit :execute s:find(<count>,'tabedit',<q-args>,<bang>1)
|
||||
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vpedit :execute s:find(<count>,'pedit',<q-args>,<bang>1)
|
||||
command! -bar -bang -range=1 -nargs=1 -complete=customlist,s:Findcomplete Vread :execute s:find(<count>,'read',<q-args>,<bang>1)
|
||||
|
||||
" vim:set et sw=2 foldmethod=expr foldexpr=getline(v\:lnum)=~'^\"\ Section\:'?'>1'\:getline(v\:lnum)=~#'^fu'?'a1'\:getline(v\:lnum)=~#'^endf'?'s1'\:'=':
|
||||
@ -0,0 +1,3 @@
|
||||
*~
|
||||
*.swp
|
||||
tags
|
||||
@ -0,0 +1,103 @@
|
||||
The NERD Tree
|
||||
=============
|
||||
|
||||
Intro
|
||||
-----
|
||||
|
||||
The NERD tree allows you to explore your filesystem and to open files and
|
||||
directories. It presents the filesystem to you in the form of a tree which you
|
||||
manipulate with the keyboard and/or mouse. It also allows you to perform
|
||||
simple filesystem operations.
|
||||
|
||||
The following features and functionality are provided by the NERD tree:
|
||||
|
||||
* Files and directories are displayed in a hierarchical tree structure
|
||||
* Different highlighting is provided for the following types of nodes:
|
||||
* files
|
||||
* directories
|
||||
* sym-links
|
||||
* windows .lnk files
|
||||
* read-only files
|
||||
* executable files
|
||||
* Many (customisable) mappings are provided to manipulate the tree:
|
||||
* Mappings to open/close/explore directory nodes
|
||||
* Mappings to open files in new/existing windows/tabs
|
||||
* Mappings to change the current root of the tree
|
||||
* Mappings to navigate around the tree
|
||||
* ...
|
||||
* Directories and files can be bookmarked.
|
||||
* Most NERD tree navigation can also be done with the mouse
|
||||
* Filtering of tree content (can be toggled at runtime)
|
||||
* custom file filters to prevent e.g. vim backup files being displayed
|
||||
* optional displaying of hidden files (. files)
|
||||
* files can be "turned off" so that only directories are displayed
|
||||
* The position and size of the NERD tree window can be customised
|
||||
* The order in which the nodes in the tree are listed can be customised.
|
||||
* A model of your filesystem is created/maintained as you explore it. This
|
||||
has several advantages:
|
||||
* All filesystem information is cached and is only re-read on demand
|
||||
* If you revisit a part of the tree that you left earlier in your
|
||||
session, the directory nodes will be opened/closed as you left them
|
||||
* The script remembers the cursor position and window position in the NERD
|
||||
tree so you can toggle it off (or just close the tree window) and then
|
||||
reopen it (with NERDTreeToggle) the NERD tree window will appear exactly
|
||||
as you left it
|
||||
* You can have a separate NERD tree for each tab, share trees across tabs,
|
||||
or a mix of both.
|
||||
* By default the script overrides the default file browser (netrw), so if
|
||||
you :edit a directory a (slightly modified) NERD tree will appear in the
|
||||
current window
|
||||
* A programmable menu system is provided (simulates right clicking on a node)
|
||||
* one default menu plugin is provided to perform basic filesystem
|
||||
operations (create/delete/move/copy files/directories)
|
||||
* There's an API for adding your own keymappings
|
||||
|
||||
Installation
|
||||
------------
|
||||
|
||||
[pathogen.vim](https://github.com/tpope/vim-pathogen) is the recommended way to install nerdtree.
|
||||
|
||||
cd ~/.vim/bundle
|
||||
git clone https://github.com/scrooloose/nerdtree.git
|
||||
|
||||
Then reload vim, run `:Helptags`, and check out `:help NERD_tree.txt`.
|
||||
|
||||
|
||||
Faq
|
||||
---
|
||||
|
||||
> Is there any support for `git` flags?
|
||||
|
||||
Yes, install [nerdtree-git-plugin](https://github.com/Xuyuanp/nerdtree-git-plugin).
|
||||
|
||||
|
||||
> Can I have the nerdtree on every tab automatically?
|
||||
|
||||
Nope. If this is something you want then chances are you aren't using tabs and
|
||||
buffers as they were intended to be used. Read this
|
||||
http://stackoverflow.com/questions/102384/using-vims-tabs-like-buffers
|
||||
|
||||
If you are interested in this behaviour then consider [vim-nerdtree-tabs](https://github.com/jistr/vim-nerdtree-tabs)
|
||||
|
||||
> How can I open a NERDTree automatically when vim starts up?
|
||||
|
||||
Stick this in your vimrc: `autocmd vimenter * NERDTree`
|
||||
|
||||
> How can I open a NERDTree automatically when vim starts up if no files were specified?
|
||||
|
||||
Stick this in your vimrc
|
||||
|
||||
autocmd StdinReadPre * let s:std_in=1
|
||||
autocmd VimEnter * if argc() == 0 && !exists("s:std_in") | NERDTree | endif
|
||||
|
||||
> How can I map a specific key or shortcut to open NERDTree?
|
||||
|
||||
Stick this in your vimrc to open NERDTree with `Ctrl+n` (you can set whatever key you want):
|
||||
|
||||
`map <C-n> :NERDTreeToggle<CR>`
|
||||
|
||||
> How can I close vim if the only window left open is a NERDTree?
|
||||
|
||||
Stick this in your vimrc:
|
||||
|
||||
`autocmd bufenter * if (winnr("$") == 1 && exists("b:NERDTreeType") && b:NERDTreeType == "primary") | q | endif`
|
||||
@ -0,0 +1,136 @@
|
||||
if exists("g:loaded_nerdtree_autoload")
|
||||
finish
|
||||
endif
|
||||
let g:loaded_nerdtree_autoload = 1
|
||||
|
||||
function! nerdtree#version()
|
||||
return '4.2.0'
|
||||
endfunction
|
||||
|
||||
" SECTION: General Functions {{{1
|
||||
"============================================================
|
||||
|
||||
"FUNCTION: nerdtree#checkForBrowse(dir) {{{2
|
||||
"inits a secondary nerd tree in the current buffer if appropriate
|
||||
function! nerdtree#checkForBrowse(dir)
|
||||
if a:dir != '' && isdirectory(a:dir)
|
||||
call g:NERDTreeCreator.CreateSecondary(a:dir)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" FUNCTION: nerdtree#completeBookmarks(A,L,P) {{{2
|
||||
" completion function for the bookmark commands
|
||||
function! nerdtree#completeBookmarks(A,L,P)
|
||||
return filter(g:NERDTreeBookmark.BookmarkNames(), 'v:val =~# "^' . a:A . '"')
|
||||
endfunction
|
||||
|
||||
"FUNCTION: nerdtree#compareBookmarks(dir) {{{2
|
||||
function! nerdtree#compareBookmarks(first, second)
|
||||
return a:first.compareTo(a:second)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: nerdtree#compareNodes(dir) {{{2
|
||||
function! nerdtree#compareNodes(n1, n2)
|
||||
return a:n1.path.compareTo(a:n2.path)
|
||||
endfunction
|
||||
|
||||
" FUNCTION: nerdtree#deprecated(func, [msg]) {{{2
|
||||
" Issue a deprecation warning for a:func. If a second arg is given, use this
|
||||
" as the deprecation message
|
||||
function! nerdtree#deprecated(func, ...)
|
||||
let msg = a:0 ? a:func . ' ' . a:1 : a:func . ' is deprecated'
|
||||
|
||||
if !exists('s:deprecationWarnings')
|
||||
let s:deprecationWarnings = {}
|
||||
endif
|
||||
if !has_key(s:deprecationWarnings, a:func)
|
||||
let s:deprecationWarnings[a:func] = 1
|
||||
echomsg msg
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" FUNCTION: nerdtree#exec(cmd) {{{2
|
||||
" same as :exec cmd but eventignore=all is set for the duration
|
||||
function! nerdtree#exec(cmd)
|
||||
let old_ei = &ei
|
||||
set ei=all
|
||||
exec a:cmd
|
||||
let &ei = old_ei
|
||||
endfunction
|
||||
|
||||
" FUNCTION: nerdtree#has_opt(options, name) {{{2
|
||||
function! nerdtree#has_opt(options, name)
|
||||
return has_key(a:options, a:name) && a:options[a:name] == 1
|
||||
endfunction
|
||||
|
||||
" FUNCTION: nerdtree#loadClassFiles() {{{2
|
||||
function! nerdtree#loadClassFiles()
|
||||
runtime lib/nerdtree/path.vim
|
||||
runtime lib/nerdtree/menu_controller.vim
|
||||
runtime lib/nerdtree/menu_item.vim
|
||||
runtime lib/nerdtree/key_map.vim
|
||||
runtime lib/nerdtree/bookmark.vim
|
||||
runtime lib/nerdtree/tree_file_node.vim
|
||||
runtime lib/nerdtree/tree_dir_node.vim
|
||||
runtime lib/nerdtree/opener.vim
|
||||
runtime lib/nerdtree/creator.vim
|
||||
runtime lib/nerdtree/flag_set.vim
|
||||
runtime lib/nerdtree/nerdtree.vim
|
||||
runtime lib/nerdtree/ui.vim
|
||||
runtime lib/nerdtree/event.vim
|
||||
runtime lib/nerdtree/notifier.vim
|
||||
endfunction
|
||||
|
||||
" FUNCTION: nerdtree#postSourceActions() {{{2
|
||||
function! nerdtree#postSourceActions()
|
||||
call g:NERDTreeBookmark.CacheBookmarks(0)
|
||||
call nerdtree#ui_glue#createDefaultBindings()
|
||||
|
||||
"load all nerdtree plugins
|
||||
runtime! nerdtree_plugin/**/*.vim
|
||||
endfunction
|
||||
|
||||
"FUNCTION: nerdtree#runningWindows(dir) {{{2
|
||||
function! nerdtree#runningWindows()
|
||||
return has("win16") || has("win32") || has("win64")
|
||||
endfunction
|
||||
|
||||
" SECTION: View Functions {{{1
|
||||
"============================================================
|
||||
|
||||
"FUNCTION: nerdtree#echo {{{2
|
||||
"A wrapper for :echo. Appends 'NERDTree:' on the front of all messages
|
||||
"
|
||||
"Args:
|
||||
"msg: the message to echo
|
||||
function! nerdtree#echo(msg)
|
||||
redraw
|
||||
echomsg "NERDTree: " . a:msg
|
||||
endfunction
|
||||
|
||||
"FUNCTION: nerdtree#echoError {{{2
|
||||
"Wrapper for nerdtree#echo, sets the message type to errormsg for this message
|
||||
"Args:
|
||||
"msg: the message to echo
|
||||
function! nerdtree#echoError(msg)
|
||||
echohl errormsg
|
||||
call nerdtree#echo(a:msg)
|
||||
echohl normal
|
||||
endfunction
|
||||
|
||||
"FUNCTION: nerdtree#echoWarning {{{2
|
||||
"Wrapper for nerdtree#echo, sets the message type to warningmsg for this message
|
||||
"Args:
|
||||
"msg: the message to echo
|
||||
function! nerdtree#echoWarning(msg)
|
||||
echohl warningmsg
|
||||
call nerdtree#echo(a:msg)
|
||||
echohl normal
|
||||
endfunction
|
||||
|
||||
"FUNCTION: nerdtree#renderView {{{2
|
||||
function! nerdtree#renderView()
|
||||
call b:NERDTree.render()
|
||||
endfunction
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -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(".") ==# g:NERDTreeUI.UpDirLine()
|
||||
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()
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:activateFileNode() {{{1
|
||||
"handle the user activating a tree node
|
||||
function! s:activateFileNode(node)
|
||||
call a:node.activate({'reuse': 'all', '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 g:NERDTree.Close()
|
||||
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 !g:NERDTree.IsOpen()
|
||||
call g:NERDTreeCreator.TogglePrimary('')
|
||||
else
|
||||
call g:NERDTree.CursorToTreeWin()
|
||||
endif
|
||||
let b:NERDTreeShowHidden = g:NERDTreeShowHidden
|
||||
call s:chRoot(g:NERDTreeDirNode.New(p.getParent()))
|
||||
else
|
||||
if !g:NERDTree.IsOpen()
|
||||
call g:NERDTreeCreator.TogglePrimary("")
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
call g:NERDTree.CursorToTreeWin()
|
||||
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 =~# g:NERDTreeUI.MarkupReg() && 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 !~# g:NERDTreeUI.MarkupReg()
|
||||
if currentNode.path.isDirectory
|
||||
call currentNode.activate()
|
||||
else
|
||||
call currentNode.activate({'reuse': 'all', '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 g:NERDTree.Close()
|
||||
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:
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,319 @@
|
||||
"CLASS: Bookmark
|
||||
"============================================================
|
||||
let s:Bookmark = {}
|
||||
let g:NERDTreeBookmark = s:Bookmark
|
||||
|
||||
" FUNCTION: Bookmark.activate() {{{1
|
||||
function! s:Bookmark.activate(...)
|
||||
call self.open(a:0 ? a:1 : {})
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.AddBookmark(name, path) {{{1
|
||||
" Class method to add a new bookmark to the list, if a previous bookmark exists
|
||||
" with the same name, just update the path for that bookmark
|
||||
function! s:Bookmark.AddBookmark(name, path)
|
||||
for i in s:Bookmark.Bookmarks()
|
||||
if i.name ==# a:name
|
||||
let i.path = a:path
|
||||
return
|
||||
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
|
||||
" Class method to get all bookmarks. Lazily initializes the bookmarks global
|
||||
" variable
|
||||
function! s:Bookmark.Bookmarks()
|
||||
if !exists("g:NERDTreeBookmarks")
|
||||
let g:NERDTreeBookmarks = []
|
||||
endif
|
||||
return g:NERDTreeBookmarks
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.BookmarkExistsFor(name) {{{1
|
||||
" class method that returns 1 if a bookmark with the given name is found, 0
|
||||
" otherwise
|
||||
function! s:Bookmark.BookmarkExistsFor(name)
|
||||
try
|
||||
call s:Bookmark.BookmarkFor(a:name)
|
||||
return 1
|
||||
catch /^NERDTree.BookmarkNotFoundError/
|
||||
return 0
|
||||
endtry
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.BookmarkFor(name) {{{1
|
||||
" Class method to get the bookmark that has the given name. {} is return if no
|
||||
" bookmark is found
|
||||
function! s:Bookmark.BookmarkFor(name)
|
||||
for i in s:Bookmark.Bookmarks()
|
||||
if i.name ==# a:name
|
||||
return i
|
||||
endif
|
||||
endfor
|
||||
throw "NERDTree.BookmarkNotFoundError: no bookmark found for name: \"". a:name .'"'
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.BookmarkNames() {{{1
|
||||
" Class method to return an array of all bookmark names
|
||||
function! s:Bookmark.BookmarkNames()
|
||||
let names = []
|
||||
for i in s:Bookmark.Bookmarks()
|
||||
call add(names, i.name)
|
||||
endfor
|
||||
return names
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.CacheBookmarks(silent) {{{1
|
||||
" Class method to read all bookmarks from the bookmarks file initialize
|
||||
" bookmark objects for each one.
|
||||
"
|
||||
" Args:
|
||||
" silent - dont echo an error msg if invalid bookmarks are found
|
||||
function! s:Bookmark.CacheBookmarks(silent)
|
||||
if filereadable(g:NERDTreeBookmarksFile)
|
||||
let g:NERDTreeBookmarks = []
|
||||
let g:NERDTreeInvalidBookmarks = []
|
||||
let bookmarkStrings = readfile(g:NERDTreeBookmarksFile)
|
||||
let invalidBookmarksFound = 0
|
||||
for i in bookmarkStrings
|
||||
|
||||
"ignore blank lines
|
||||
if i != ''
|
||||
|
||||
let name = substitute(i, '^\(.\{-}\) .*$', '\1', '')
|
||||
let path = substitute(i, '^.\{-} \(.*\)$', '\1', '')
|
||||
|
||||
try
|
||||
let bookmark = s:Bookmark.New(name, g:NERDTreePath.New(path))
|
||||
call add(g:NERDTreeBookmarks, bookmark)
|
||||
catch /^NERDTree.InvalidArgumentsError/
|
||||
call add(g:NERDTreeInvalidBookmarks, i)
|
||||
let invalidBookmarksFound += 1
|
||||
endtry
|
||||
endif
|
||||
endfor
|
||||
if invalidBookmarksFound
|
||||
call s:Bookmark.Write()
|
||||
if !a: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
|
||||
" Compare these two bookmarks for sorting purposes
|
||||
function! s:Bookmark.compareTo(otherbookmark)
|
||||
return a:otherbookmark.name < self.name
|
||||
endfunction
|
||||
" FUNCTION: Bookmark.ClearAll() {{{1
|
||||
" Class method to delete all bookmarks.
|
||||
function! s:Bookmark.ClearAll()
|
||||
for i in s:Bookmark.Bookmarks()
|
||||
call i.delete()
|
||||
endfor
|
||||
call s:Bookmark.Write()
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.delete() {{{1
|
||||
" Delete this bookmark. If the node for this bookmark is under the current
|
||||
" root, then recache bookmarks for its Path object
|
||||
function! s:Bookmark.delete()
|
||||
let node = {}
|
||||
try
|
||||
let node = self.getNode(1)
|
||||
catch /^NERDTree.BookmarkedNodeNotFoundError/
|
||||
endtry
|
||||
call remove(s:Bookmark.Bookmarks(), index(s:Bookmark.Bookmarks(), self))
|
||||
if !empty(node)
|
||||
call node.path.cacheDisplayString()
|
||||
endif
|
||||
call s:Bookmark.Write()
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.getNode(searchFromAbsoluteRoot) {{{1
|
||||
" Gets the treenode for this bookmark
|
||||
"
|
||||
" Args:
|
||||
" searchFromAbsoluteRoot: specifies whether we should search from the current
|
||||
" tree root, or the highest cached node
|
||||
function! s:Bookmark.getNode(searchFromAbsoluteRoot)
|
||||
let searchRoot = a:searchFromAbsoluteRoot ? g:NERDTreeDirNode.AbsoluteTreeRoot() : b:NERDTreeRoot
|
||||
let targetNode = searchRoot.findNode(self.path)
|
||||
if empty(targetNode)
|
||||
throw "NERDTree.BookmarkedNodeNotFoundError: no node was found for bookmark: " . self.name
|
||||
endif
|
||||
return targetNode
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.GetNodeForName(name, searchFromAbsoluteRoot) {{{1
|
||||
" Class method that finds the bookmark with the given name and returns the
|
||||
" treenode for it.
|
||||
function! s:Bookmark.GetNodeForName(name, searchFromAbsoluteRoot)
|
||||
let bookmark = s:Bookmark.BookmarkFor(a:name)
|
||||
return bookmark.getNode(a:searchFromAbsoluteRoot)
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.GetSelected() {{{1
|
||||
" returns the Bookmark the cursor is over, or {}
|
||||
function! s:Bookmark.GetSelected()
|
||||
let line = getline(".")
|
||||
let name = substitute(line, '^>\(.\{-}\) .\+$', '\1', '')
|
||||
if name != line
|
||||
try
|
||||
return s:Bookmark.BookmarkFor(name)
|
||||
catch /^NERDTree.BookmarkNotFoundError/
|
||||
return {}
|
||||
endtry
|
||||
endif
|
||||
return {}
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.InvalidBookmarks() {{{1
|
||||
" Class method to get all invalid bookmark strings read from the bookmarks
|
||||
" file
|
||||
function! s:Bookmark.InvalidBookmarks()
|
||||
if !exists("g:NERDTreeInvalidBookmarks")
|
||||
let g:NERDTreeInvalidBookmarks = []
|
||||
endif
|
||||
return g:NERDTreeInvalidBookmarks
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.mustExist() {{{1
|
||||
function! s:Bookmark.mustExist()
|
||||
if !self.path.exists()
|
||||
call s:Bookmark.CacheBookmarks(1)
|
||||
throw "NERDTree.BookmarkPointsToInvalidLocationError: the bookmark \"".
|
||||
\ self.name ."\" points to a non existing location: \"". self.path.str()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.New(name, path) {{{1
|
||||
" Create a new bookmark object with the given name and path object
|
||||
function! s:Bookmark.New(name, path)
|
||||
if a:name =~# ' '
|
||||
throw "NERDTree.IllegalBookmarkNameError: illegal name:" . a:name
|
||||
endif
|
||||
|
||||
let newBookmark = copy(self)
|
||||
let newBookmark.name = a:name
|
||||
let newBookmark.path = a:path
|
||||
return newBookmark
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.open([options]) {{{1
|
||||
"Args:
|
||||
"A dictionary containing the following keys (all optional):
|
||||
" 'where': Specifies whether the node should be opened in new split/tab or in
|
||||
" the previous window. Can be either 'v' (vertical split), 'h'
|
||||
" (horizontal split), 't' (new tab) or 'p' (previous window).
|
||||
" 'reuse': if a window is displaying the file then jump the cursor there
|
||||
" 'keepopen': dont close the tree window
|
||||
" 'stay': open the file, but keep the cursor in the tree win
|
||||
"
|
||||
function! s:Bookmark.open(...)
|
||||
let opts = a:0 ? a:1 : {}
|
||||
|
||||
if self.path.isDirectory && !has_key(opts, 'where')
|
||||
call self.toRoot()
|
||||
else
|
||||
let opener = g:NERDTreeOpener.New(self.path, opts)
|
||||
call opener.open(self)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.openInNewTab(options) {{{1
|
||||
" Create a new bookmark object with the given name and path object
|
||||
function! s:Bookmark.openInNewTab(options)
|
||||
call nerdtree#deprecated('Bookmark.openInNewTab', 'is deprecated, use open() instead')
|
||||
call self.open(a:options)
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.setPath(path) {{{1
|
||||
" makes this bookmark point to the given path
|
||||
function! s:Bookmark.setPath(path)
|
||||
let self.path = a:path
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.Sort() {{{1
|
||||
" Class method that sorts all bookmarks
|
||||
function! s:Bookmark.Sort()
|
||||
let CompareFunc = function("nerdtree#compareBookmarks")
|
||||
call sort(s:Bookmark.Bookmarks(), CompareFunc)
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.str() {{{1
|
||||
" Get the string that should be rendered in the view for this bookmark
|
||||
function! s:Bookmark.str()
|
||||
let pathStrMaxLen = winwidth(g:NERDTree.GetWinNum()) - 4 - len(self.name)
|
||||
if &nu
|
||||
let pathStrMaxLen = pathStrMaxLen - &numberwidth
|
||||
endif
|
||||
|
||||
let pathStr = self.path.str({'format': 'UI'})
|
||||
if len(pathStr) > pathStrMaxLen
|
||||
let pathStr = '<' . strpart(pathStr, len(pathStr) - pathStrMaxLen)
|
||||
endif
|
||||
return '>' . self.name . ' ' . pathStr
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.toRoot() {{{1
|
||||
" Make the node for this bookmark the new tree root
|
||||
function! s:Bookmark.toRoot()
|
||||
if self.validate()
|
||||
try
|
||||
let targetNode = self.getNode(1)
|
||||
catch /^NERDTree.BookmarkedNodeNotFoundError/
|
||||
let targetNode = g:NERDTreeFileNode.New(s:Bookmark.BookmarkFor(self.name).path)
|
||||
endtry
|
||||
call targetNode.makeRoot()
|
||||
call b:NERDTree.render()
|
||||
call targetNode.putCursorHere(0, 0)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.ToRoot(name) {{{1
|
||||
" Make the node for this bookmark the new tree root
|
||||
function! s:Bookmark.ToRoot(name)
|
||||
let bookmark = s:Bookmark.BookmarkFor(a:name)
|
||||
call bookmark.toRoot()
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.validate() {{{1
|
||||
function! s:Bookmark.validate()
|
||||
if self.path.exists()
|
||||
return 1
|
||||
else
|
||||
call s:Bookmark.CacheBookmarks(1)
|
||||
call b:NERDTree.render()
|
||||
call nerdtree#echo(self.name . "now points to an invalid location. See :help NERDTreeInvalidBookmarks for info.")
|
||||
return 0
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Bookmark.Write() {{{1
|
||||
" Class method to write all bookmarks to the bookmarks file
|
||||
function! s:Bookmark.Write()
|
||||
let bookmarkStrings = []
|
||||
for i in s:Bookmark.Bookmarks()
|
||||
call add(bookmarkStrings, i.name . ' ' . i.path.str())
|
||||
endfor
|
||||
|
||||
"add a blank line before the invalid ones
|
||||
call add(bookmarkStrings, "")
|
||||
|
||||
for j in s:Bookmark.InvalidBookmarks()
|
||||
call add(bookmarkStrings, j)
|
||||
endfor
|
||||
call writefile(bookmarkStrings, g:NERDTreeBookmarksFile)
|
||||
endfunction
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,362 @@
|
||||
"CLASS: Creator
|
||||
"Creates primary/secondary/mirror nerdtree windows. Sets up all the window and
|
||||
"buffer options and key mappings etc.
|
||||
"============================================================
|
||||
let s:Creator = {}
|
||||
let g:NERDTreeCreator = s:Creator
|
||||
|
||||
"FUNCTION: s:Creator._bindMappings() {{{1
|
||||
function! s:Creator._bindMappings()
|
||||
"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#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 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
|
||||
|
||||
"FUNCTION: s:Creator._broadcastInitEvent() {{{1
|
||||
function! s:Creator._broadcastInitEvent()
|
||||
silent doautocmd User NERDTreeInit
|
||||
endfunction
|
||||
|
||||
" FUNCTION: s:Creator.BufNamePrefix() {{{2
|
||||
function! s:Creator.BufNamePrefix()
|
||||
return 'NERD_tree_'
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:Creator.CreatePrimary(a:name) {{{1
|
||||
function! s:Creator.CreatePrimary(name)
|
||||
let creator = s:Creator.New()
|
||||
call creator.createPrimary(a:name)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:Creator.createPrimary(a:name) {{{1
|
||||
"name: the name of a bookmark or a directory
|
||||
function! s:Creator.createPrimary(name)
|
||||
let path = self._pathForString(a:name)
|
||||
|
||||
"abort if exception was thrown (bookmark/dir doesn't exist)
|
||||
if empty(path)
|
||||
return
|
||||
endif
|
||||
|
||||
"if instructed to, then change the vim CWD to the dir the NERDTree is
|
||||
"inited in
|
||||
if g:NERDTreeChDirMode != 0
|
||||
call path.changeToDir()
|
||||
endif
|
||||
|
||||
if g:NERDTree.ExistsForTab()
|
||||
if g:NERDTree.IsOpen()
|
||||
call g:NERDTree.Close()
|
||||
endif
|
||||
unlet t:NERDTreeBufName
|
||||
endif
|
||||
|
||||
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
|
||||
|
||||
call b:NERDTree.render()
|
||||
call b:NERDTreeRoot.putCursorHere(0, 0)
|
||||
|
||||
call self._broadcastInitEvent()
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:Creator.CreateSecondary(dir) {{{1
|
||||
function! s:Creator.CreateSecondary(dir)
|
||||
let creator = s:Creator.New()
|
||||
call creator.createSecondary(a:dir)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:Creator.createSecondary(dir) {{{1
|
||||
function! s:Creator.createSecondary(dir)
|
||||
try
|
||||
let path = g:NERDTreePath.New(a:dir)
|
||||
catch /^NERDTree.InvalidArgumentsError/
|
||||
call nerdtree#echo("Invalid directory name:" . a:name)
|
||||
return
|
||||
endtry
|
||||
|
||||
"we want the directory buffer to disappear when we do the :edit below
|
||||
setlocal bufhidden=wipe
|
||||
|
||||
let previousBuf = expand("#")
|
||||
|
||||
"we need a unique name for each secondary tree buffer to ensure they are
|
||||
"all independent
|
||||
exec "silent edit " . self._nextBufferName()
|
||||
|
||||
let b:NERDTreePreviousBuf = bufnr(previousBuf)
|
||||
call self._createNERDTree(path)
|
||||
call self._setCommonBufOptions()
|
||||
let b:NERDTreeType = "secondary"
|
||||
|
||||
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()
|
||||
call creator.createMirror()
|
||||
endfunction
|
||||
|
||||
" FUNCTION: s:Creator.createMirror() {{{1
|
||||
function! s:Creator.createMirror()
|
||||
"get the names off all the nerd tree buffers
|
||||
let treeBufNames = []
|
||||
for i in range(1, tabpagenr("$"))
|
||||
let nextName = self._tabpagevar(i, 'NERDTreeBufName')
|
||||
if nextName != -1 && (!exists("t:NERDTreeBufName") || nextName != t:NERDTreeBufName)
|
||||
call add(treeBufNames, nextName)
|
||||
endif
|
||||
endfor
|
||||
let treeBufNames = self._uniq(treeBufNames)
|
||||
|
||||
"map the option names (that the user will be prompted with) to the nerd
|
||||
"tree buffer names
|
||||
let options = {}
|
||||
let i = 0
|
||||
while i < len(treeBufNames)
|
||||
let bufName = treeBufNames[i]
|
||||
let treeRoot = getbufvar(bufName, "NERDTreeRoot")
|
||||
let options[i+1 . '. ' . treeRoot.path.str() . ' (buf name: ' . bufName . ')'] = bufName
|
||||
let i = i + 1
|
||||
endwhile
|
||||
|
||||
"work out which tree to mirror, if there is more than 1 then ask the user
|
||||
let bufferName = ''
|
||||
if len(keys(options)) > 1
|
||||
let choices = ["Choose a tree to mirror"]
|
||||
let choices = extend(choices, sort(keys(options)))
|
||||
let choice = inputlist(choices)
|
||||
if choice < 1 || choice > len(options) || choice ==# ''
|
||||
return
|
||||
endif
|
||||
|
||||
let bufferName = options[sort(keys(options))[choice-1]]
|
||||
elseif len(keys(options)) ==# 1
|
||||
let bufferName = values(options)[0]
|
||||
else
|
||||
call nerdtree#echo("No trees to mirror")
|
||||
return
|
||||
endif
|
||||
|
||||
if g:NERDTree.ExistsForTab() && g:NERDTree.IsOpen()
|
||||
call g:NERDTree.Close()
|
||||
endif
|
||||
|
||||
let t:NERDTreeBufName = bufferName
|
||||
call self._createTreeWin()
|
||||
exec 'buffer ' . bufferName
|
||||
if !&hidden
|
||||
call b:NERDTree.render()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:Creator._createTreeWin() {{{1
|
||||
"Inits the NERD tree window. ie. opens it, sizes it, sets all the local
|
||||
"options etc
|
||||
function! s:Creator._createTreeWin()
|
||||
"create the nerd tree window
|
||||
let splitLocation = g:NERDTreeWinPos ==# "left" ? "topleft " : "botright "
|
||||
let splitSize = g:NERDTreeWinSize
|
||||
|
||||
if !exists('t:NERDTreeBufName')
|
||||
let t:NERDTreeBufName = self._nextBufferName()
|
||||
silent! exec splitLocation . 'vertical ' . splitSize . ' new'
|
||||
silent! exec "edit " . t:NERDTreeBufName
|
||||
else
|
||||
silent! exec splitLocation . 'vertical ' . splitSize . ' split'
|
||||
silent! exec "buffer " . t:NERDTreeBufName
|
||||
endif
|
||||
|
||||
setlocal winfixwidth
|
||||
call self._setCommonBufOptions()
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:Creator.New() {{{1
|
||||
function! s:Creator.New()
|
||||
let newCreator = copy(self)
|
||||
return newCreator
|
||||
endfunction
|
||||
|
||||
" FUNCTION: s:Creator._nextBufferName() {{{2
|
||||
" returns the buffer name for the next nerd tree
|
||||
function! s:Creator._nextBufferName()
|
||||
let name = s:Creator.BufNamePrefix() . self._nextBufferNumber()
|
||||
return name
|
||||
endfunction
|
||||
|
||||
" FUNCTION: s:Creator._nextBufferNumber() {{{2
|
||||
" the number to add to the nerd tree buffer name to make the buf name unique
|
||||
function! s:Creator._nextBufferNumber()
|
||||
if !exists("s:Creator._NextBufNum")
|
||||
let s:Creator._NextBufNum = 1
|
||||
else
|
||||
let s:Creator._NextBufNum += 1
|
||||
endif
|
||||
|
||||
return s:Creator._NextBufNum
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:Creator._pathForString(str) {{{1
|
||||
"find a bookmark or adirectory for the given string
|
||||
function! s:Creator._pathForString(str)
|
||||
let path = {}
|
||||
if g:NERDTreeBookmark.BookmarkExistsFor(a:str)
|
||||
let path = g:NERDTreeBookmark.BookmarkFor(a:str).path
|
||||
else
|
||||
let dir = a:str ==# '' ? getcwd() : a:str
|
||||
|
||||
"hack to get an absolute path if a relative path is given
|
||||
if dir =~# '^\.'
|
||||
let dir = getcwd() . g:NERDTreePath.Slash() . dir
|
||||
endif
|
||||
let dir = g:NERDTreePath.Resolve(dir)
|
||||
|
||||
try
|
||||
let path = g:NERDTreePath.New(dir)
|
||||
catch /^NERDTree.InvalidArgumentsError/
|
||||
call nerdtree#echo("No bookmark or directory found for: " . a:str)
|
||||
return
|
||||
endtry
|
||||
endif
|
||||
if !path.isDirectory
|
||||
let path = path.getParent()
|
||||
endif
|
||||
|
||||
return path
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:Creator._setCommonBufOptions() {{{1
|
||||
function! s:Creator._setCommonBufOptions()
|
||||
"throwaway buffer options
|
||||
setlocal noswapfile
|
||||
setlocal buftype=nofile
|
||||
setlocal bufhidden=hide
|
||||
setlocal nowrap
|
||||
setlocal foldcolumn=0
|
||||
setlocal foldmethod=manual
|
||||
setlocal nofoldenable
|
||||
setlocal nobuflisted
|
||||
setlocal nospell
|
||||
if g:NERDTreeShowLineNumbers
|
||||
setlocal nu
|
||||
else
|
||||
setlocal nonu
|
||||
if v:version >= 703
|
||||
setlocal nornu
|
||||
endif
|
||||
endif
|
||||
|
||||
iabc <buffer>
|
||||
|
||||
if g:NERDTreeHighlightCursorline
|
||||
setlocal cursorline
|
||||
endif
|
||||
|
||||
call self._setupStatusline()
|
||||
|
||||
let b:treeShowHelp = 0
|
||||
let b:NERDTreeIgnoreEnabled = 1
|
||||
let b:NERDTreeShowFiles = g:NERDTreeShowFiles
|
||||
let b:NERDTreeShowHidden = g:NERDTreeShowHidden
|
||||
let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks
|
||||
call self._bindMappings()
|
||||
setlocal filetype=nerdtree
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:Creator._setupStatusline() {{{1
|
||||
function! s:Creator._setupStatusline()
|
||||
if g:NERDTreeStatusline != -1
|
||||
let &l:statusline = g:NERDTreeStatusline
|
||||
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()
|
||||
call creator.togglePrimary(a:dir)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:Creator.togglePrimary(dir) {{{1
|
||||
"Toggles the NERD tree. I.e the NERD tree is open, it is closed, if it is
|
||||
"closed it is restored or initialized (if it doesnt exist)
|
||||
"
|
||||
"Args:
|
||||
"dir: the full path for the root node (is only used if the NERD tree is being
|
||||
"initialized.
|
||||
function! s:Creator.togglePrimary(dir)
|
||||
if g:NERDTree.ExistsForTab()
|
||||
if !g:NERDTree.IsOpen()
|
||||
call self._createTreeWin()
|
||||
if !&hidden
|
||||
call b:NERDTree.render()
|
||||
endif
|
||||
call b:NERDTree.ui.restoreScreenState()
|
||||
else
|
||||
call g:NERDTree.Close()
|
||||
endif
|
||||
else
|
||||
call self.createPrimary(a: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:
|
||||
@ -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
|
||||
@ -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
|
||||
@ -0,0 +1,159 @@
|
||||
"CLASS: KeyMap
|
||||
"============================================================
|
||||
let s:KeyMap = {}
|
||||
let g:NERDTreeKeyMap = s:KeyMap
|
||||
|
||||
"FUNCTION: KeyMap.All() {{{1
|
||||
function! s:KeyMap.All()
|
||||
if !exists("s:keyMaps")
|
||||
let s:keyMaps = []
|
||||
endif
|
||||
return s:keyMaps
|
||||
endfunction
|
||||
|
||||
"FUNCTION: KeyMap.FindFor(key, scope) {{{1
|
||||
function! s:KeyMap.FindFor(key, scope)
|
||||
for i in s:KeyMap.All()
|
||||
if i.key ==# a:key && i.scope ==# a:scope
|
||||
return i
|
||||
endif
|
||||
endfor
|
||||
return {}
|
||||
endfunction
|
||||
|
||||
"FUNCTION: KeyMap.BindAll() {{{1
|
||||
function! s:KeyMap.BindAll()
|
||||
for i in s:KeyMap.All()
|
||||
call i.bind()
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
"FUNCTION: KeyMap.bind() {{{1
|
||||
function! s:KeyMap.bind()
|
||||
" If the key sequence we're trying to map contains any '<>' notation, we
|
||||
" must replace each of the '<' characters with '<lt>' to ensure the string
|
||||
" is not translated into its corresponding keycode during the later part
|
||||
" of the map command below
|
||||
" :he <>
|
||||
let specialNotationRegex = '\m<\([[:alnum:]_-]\+>\)'
|
||||
if self.key =~# specialNotationRegex
|
||||
let keymapInvokeString = substitute(self.key, specialNotationRegex, '<lt>\1', 'g')
|
||||
else
|
||||
let keymapInvokeString = self.key
|
||||
endif
|
||||
|
||||
let premap = self.key == "<LeftRelease>" ? " <LeftRelease>" : " "
|
||||
|
||||
exec 'nnoremap <buffer> <silent> '. self.key . premap . ':call nerdtree#ui_glue#invokeKeyMap("'. keymapInvokeString .'")<cr>'
|
||||
endfunction
|
||||
|
||||
"FUNCTION: KeyMap.Remove(key, scope) {{{1
|
||||
function! s:KeyMap.Remove(key, scope)
|
||||
let maps = s:KeyMap.All()
|
||||
for i in range(len(maps))
|
||||
if maps[i].key ==# a:key && maps[i].scope ==# a:scope
|
||||
return remove(maps, i)
|
||||
endif
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
"FUNCTION: KeyMap.invoke() {{{1
|
||||
"Call the KeyMaps callback function
|
||||
function! s:KeyMap.invoke(...)
|
||||
let Callback = function(self.callback)
|
||||
if a:0
|
||||
call Callback(a:1)
|
||||
else
|
||||
call Callback()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: KeyMap.Invoke() {{{1
|
||||
"Find a keymapping for a:key and the current scope invoke it.
|
||||
"
|
||||
"Scope is determined as follows:
|
||||
" * if the cursor is on a dir node then "DirNode"
|
||||
" * if the cursor is on a file node then "FileNode"
|
||||
" * if the cursor is on a bookmark then "Bookmark"
|
||||
"
|
||||
"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)
|
||||
|
||||
"try file node
|
||||
if !node.path.isDirectory
|
||||
let km = s:KeyMap.FindFor(a:key, "FileNode")
|
||||
if !empty(km)
|
||||
return km.invoke(node)
|
||||
endif
|
||||
endif
|
||||
|
||||
"try dir node
|
||||
if node.path.isDirectory
|
||||
let km = s:KeyMap.FindFor(a:key, "DirNode")
|
||||
if !empty(km)
|
||||
return km.invoke(node)
|
||||
endif
|
||||
endif
|
||||
|
||||
"try generic node
|
||||
let km = s:KeyMap.FindFor(a:key, "Node")
|
||||
if !empty(km)
|
||||
return km.invoke(node)
|
||||
endif
|
||||
|
||||
endif
|
||||
|
||||
"try bookmark
|
||||
let bm = g:NERDTreeBookmark.GetSelected()
|
||||
if !empty(bm)
|
||||
let km = s:KeyMap.FindFor(a:key, "Bookmark")
|
||||
if !empty(km)
|
||||
return km.invoke(bm)
|
||||
endif
|
||||
endif
|
||||
|
||||
"try all
|
||||
let km = s:KeyMap.FindFor(a:key, "all")
|
||||
if !empty(km)
|
||||
return km.invoke()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: KeyMap.Create(options) {{{1
|
||||
function! s:KeyMap.Create(options)
|
||||
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']
|
||||
let newKeyMap.scope = opts['scope']
|
||||
|
||||
call s:KeyMap.Add(newKeyMap)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: KeyMap.Add(keymap) {{{1
|
||||
function! s:KeyMap.Add(keymap)
|
||||
call s:KeyMap.Remove(a:keymap.key, a:keymap.scope)
|
||||
call add(s:KeyMap.All(), a:keymap)
|
||||
endfunction
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,180 @@
|
||||
"CLASS: MenuController
|
||||
"============================================================
|
||||
let s:MenuController = {}
|
||||
let g:NERDTreeMenuController = s:MenuController
|
||||
|
||||
"FUNCTION: MenuController.New(menuItems) {{{1
|
||||
"create a new menu controller that operates on the given menu items
|
||||
function! s:MenuController.New(menuItems)
|
||||
let newMenuController = copy(self)
|
||||
if a:menuItems[0].isSeparator()
|
||||
let newMenuController.menuItems = a:menuItems[1:-1]
|
||||
else
|
||||
let newMenuController.menuItems = a:menuItems
|
||||
endif
|
||||
return newMenuController
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuController.showMenu() {{{1
|
||||
"start the main loop of the menu and get the user to choose/execute a menu
|
||||
"item
|
||||
function! s:MenuController.showMenu()
|
||||
call self._saveOptions()
|
||||
|
||||
try
|
||||
let self.selection = 0
|
||||
|
||||
let done = 0
|
||||
while !done
|
||||
redraw!
|
||||
call self._echoPrompt()
|
||||
let key = nr2char(getchar())
|
||||
let done = self._handleKeypress(key)
|
||||
endwhile
|
||||
finally
|
||||
call self._restoreOptions()
|
||||
endtry
|
||||
|
||||
if self.selection != -1
|
||||
let m = self._current()
|
||||
call m.execute()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuController._echoPrompt() {{{1
|
||||
function! s:MenuController._echoPrompt()
|
||||
echo "NERDTree Menu. Use j/k/enter and the shortcuts indicated"
|
||||
echo "=========================================================="
|
||||
|
||||
for i in range(0, len(self.menuItems)-1)
|
||||
if self.selection == i
|
||||
echo "> " . self.menuItems[i].text
|
||||
else
|
||||
echo " " . self.menuItems[i].text
|
||||
endif
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuController._current(key) {{{1
|
||||
"get the MenuItem that is currently selected
|
||||
function! s:MenuController._current()
|
||||
return self.menuItems[self.selection]
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuController._handleKeypress(key) {{{1
|
||||
"change the selection (if appropriate) and return 1 if the user has made
|
||||
"their choice, 0 otherwise
|
||||
function! s:MenuController._handleKeypress(key)
|
||||
if a:key == 'j'
|
||||
call self._cursorDown()
|
||||
elseif a:key == 'k'
|
||||
call self._cursorUp()
|
||||
elseif a:key == nr2char(27) "escape
|
||||
let self.selection = -1
|
||||
return 1
|
||||
elseif a:key == "\r" || a:key == "\n" "enter and ctrl-j
|
||||
return 1
|
||||
else
|
||||
let index = self._nextIndexFor(a:key)
|
||||
if index != -1
|
||||
let self.selection = index
|
||||
if len(self._allIndexesFor(a:key)) == 1
|
||||
return 1
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
return 0
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuController._allIndexesFor(shortcut) {{{1
|
||||
"get indexes to all menu items with the given shortcut
|
||||
function! s:MenuController._allIndexesFor(shortcut)
|
||||
let toReturn = []
|
||||
|
||||
for i in range(0, len(self.menuItems)-1)
|
||||
if self.menuItems[i].shortcut == a:shortcut
|
||||
call add(toReturn, i)
|
||||
endif
|
||||
endfor
|
||||
|
||||
return toReturn
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuController._nextIndexFor(shortcut) {{{1
|
||||
"get the index to the next menu item with the given shortcut, starts from the
|
||||
"current cursor location and wraps around to the top again if need be
|
||||
function! s:MenuController._nextIndexFor(shortcut)
|
||||
for i in range(self.selection+1, len(self.menuItems)-1)
|
||||
if self.menuItems[i].shortcut == a:shortcut
|
||||
return i
|
||||
endif
|
||||
endfor
|
||||
|
||||
for i in range(0, self.selection)
|
||||
if self.menuItems[i].shortcut == a:shortcut
|
||||
return i
|
||||
endif
|
||||
endfor
|
||||
|
||||
return -1
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuController._setCmdheight() {{{1
|
||||
"sets &cmdheight to whatever is needed to display the menu
|
||||
function! s:MenuController._setCmdheight()
|
||||
let &cmdheight = len(self.menuItems) + 3
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuController._saveOptions() {{{1
|
||||
"set any vim options that are required to make the menu work (saving their old
|
||||
"values)
|
||||
function! s:MenuController._saveOptions()
|
||||
let self._oldLazyredraw = &lazyredraw
|
||||
let self._oldCmdheight = &cmdheight
|
||||
set nolazyredraw
|
||||
call self._setCmdheight()
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuController._restoreOptions() {{{1
|
||||
"restore the options we saved in _saveOptions()
|
||||
function! s:MenuController._restoreOptions()
|
||||
let &cmdheight = self._oldCmdheight
|
||||
let &lazyredraw = self._oldLazyredraw
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuController._cursorDown() {{{1
|
||||
"move the cursor to the next menu item, skipping separators
|
||||
function! s:MenuController._cursorDown()
|
||||
let done = 0
|
||||
while !done
|
||||
if self.selection < len(self.menuItems)-1
|
||||
let self.selection += 1
|
||||
else
|
||||
let self.selection = 0
|
||||
endif
|
||||
|
||||
if !self._current().isSeparator()
|
||||
let done = 1
|
||||
endif
|
||||
endwhile
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuController._cursorUp() {{{1
|
||||
"move the cursor to the previous menu item, skipping separators
|
||||
function! s:MenuController._cursorUp()
|
||||
let done = 0
|
||||
while !done
|
||||
if self.selection > 0
|
||||
let self.selection -= 1
|
||||
else
|
||||
let self.selection = len(self.menuItems)-1
|
||||
endif
|
||||
|
||||
if !self._current().isSeparator()
|
||||
let done = 1
|
||||
endif
|
||||
endwhile
|
||||
endfunction
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,114 @@
|
||||
"CLASS: MenuItem
|
||||
"============================================================
|
||||
let s:MenuItem = {}
|
||||
let g:NERDTreeMenuItem = s:MenuItem
|
||||
|
||||
"FUNCTION: MenuItem.All() {{{1
|
||||
"get all top level menu items
|
||||
function! s:MenuItem.All()
|
||||
if !exists("s:menuItems")
|
||||
let s:menuItems = []
|
||||
endif
|
||||
return s:menuItems
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuItem.AllEnabled() {{{1
|
||||
"get all top level menu items that are currently enabled
|
||||
function! s:MenuItem.AllEnabled()
|
||||
let toReturn = []
|
||||
for i in s:MenuItem.All()
|
||||
if i.enabled()
|
||||
call add(toReturn, i)
|
||||
endif
|
||||
endfor
|
||||
return toReturn
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuItem.Create(options) {{{1
|
||||
"make a new menu item and add it to the global list
|
||||
function! s:MenuItem.Create(options)
|
||||
let newMenuItem = copy(self)
|
||||
|
||||
let newMenuItem.text = a:options['text']
|
||||
let newMenuItem.shortcut = a:options['shortcut']
|
||||
let newMenuItem.children = []
|
||||
|
||||
let newMenuItem.isActiveCallback = -1
|
||||
if has_key(a:options, 'isActiveCallback')
|
||||
let newMenuItem.isActiveCallback = a:options['isActiveCallback']
|
||||
endif
|
||||
|
||||
let newMenuItem.callback = -1
|
||||
if has_key(a:options, 'callback')
|
||||
let newMenuItem.callback = a:options['callback']
|
||||
endif
|
||||
|
||||
if has_key(a:options, 'parent')
|
||||
call add(a:options['parent'].children, newMenuItem)
|
||||
else
|
||||
call add(s:MenuItem.All(), newMenuItem)
|
||||
endif
|
||||
|
||||
return newMenuItem
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuItem.CreateSeparator(options) {{{1
|
||||
"make a new separator menu item and add it to the global list
|
||||
function! s:MenuItem.CreateSeparator(options)
|
||||
let standard_options = { 'text': '--------------------',
|
||||
\ 'shortcut': -1,
|
||||
\ 'callback': -1 }
|
||||
let options = extend(a:options, standard_options, "force")
|
||||
|
||||
return s:MenuItem.Create(options)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuItem.CreateSubmenu(options) {{{1
|
||||
"make a new submenu and add it to global list
|
||||
function! s:MenuItem.CreateSubmenu(options)
|
||||
let standard_options = { 'callback': -1 }
|
||||
let options = extend(a:options, standard_options, "force")
|
||||
|
||||
return s:MenuItem.Create(options)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuItem.enabled() {{{1
|
||||
"return 1 if this menu item should be displayed
|
||||
"
|
||||
"delegates off to the isActiveCallback, and defaults to 1 if no callback was
|
||||
"specified
|
||||
function! s:MenuItem.enabled()
|
||||
if self.isActiveCallback != -1
|
||||
return {self.isActiveCallback}()
|
||||
endif
|
||||
return 1
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuItem.execute() {{{1
|
||||
"perform the action behind this menu item, if this menuitem has children then
|
||||
"display a new menu for them, otherwise deletegate off to the menuitem's
|
||||
"callback
|
||||
function! s:MenuItem.execute()
|
||||
if len(self.children)
|
||||
let mc = g:NERDTreeMenuController.New(self.children)
|
||||
call mc.showMenu()
|
||||
else
|
||||
if self.callback != -1
|
||||
call {self.callback}()
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuItem.isSeparator() {{{1
|
||||
"return 1 if this menuitem is a separator
|
||||
function! s:MenuItem.isSeparator()
|
||||
return self.callback == -1 && self.children == []
|
||||
endfunction
|
||||
|
||||
"FUNCTION: MenuItem.isSubmenu() {{{1
|
||||
"return 1 if this menuitem is a submenu
|
||||
function! s:MenuItem.isSubmenu()
|
||||
return self.callback == -1 && !empty(self.children)
|
||||
endfunction
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,137 @@
|
||||
"CLASS: NERDTree
|
||||
"============================================================
|
||||
let s:NERDTree = {}
|
||||
let g:NERDTree = s:NERDTree
|
||||
|
||||
"FUNCTION: s:NERDTree.AddPathFilter() {{{1
|
||||
function! s:NERDTree.AddPathFilter(callback)
|
||||
call add(s:NERDTree.PathFilters(), a:callback)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:NERDTree.Close() {{{1
|
||||
"Closes the primary NERD tree window for this tab
|
||||
function! s:NERDTree.Close()
|
||||
if !s:NERDTree.IsOpen()
|
||||
return
|
||||
endif
|
||||
|
||||
if winnr("$") != 1
|
||||
if winnr() == s:NERDTree.GetWinNum()
|
||||
call nerdtree#exec("wincmd p")
|
||||
let bufnr = bufnr("")
|
||||
call nerdtree#exec("wincmd p")
|
||||
else
|
||||
let bufnr = bufnr("")
|
||||
endif
|
||||
|
||||
call nerdtree#exec(s:NERDTree.GetWinNum() . " wincmd w")
|
||||
close
|
||||
call nerdtree#exec(bufwinnr(bufnr) . " wincmd w")
|
||||
else
|
||||
close
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:NERDTree.CloseIfQuitOnOpen() {{{1
|
||||
"Closes the NERD tree window if the close on open option is set
|
||||
function! s:NERDTree.CloseIfQuitOnOpen()
|
||||
if g:NERDTreeQuitOnOpen && s:NERDTree.IsOpen()
|
||||
call s:NERDTree.Close()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:NERDTree.CursorToBookmarkTable(){{{1
|
||||
"Places the cursor at the top of the bookmarks table
|
||||
function! s:NERDTree.CursorToBookmarkTable()
|
||||
if !b:NERDTreeShowBookmarks
|
||||
throw "NERDTree.IllegalOperationError: cant find bookmark table, bookmarks arent active"
|
||||
endif
|
||||
|
||||
if g:NERDTreeMinimalUI
|
||||
return cursor(1, 2)
|
||||
endif
|
||||
|
||||
let rootNodeLine = b:NERDTree.ui.getRootLineNum()
|
||||
|
||||
let line = 1
|
||||
while getline(line) !~# '^>-\+Bookmarks-\+$'
|
||||
let line = line + 1
|
||||
if line >= rootNodeLine
|
||||
throw "NERDTree.BookmarkTableNotFoundError: didnt find the bookmarks table"
|
||||
endif
|
||||
endwhile
|
||||
call cursor(line, 2)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:NERDTree.CursorToTreeWin(){{{1
|
||||
"Places the cursor in the nerd tree window
|
||||
function! s:NERDTree.CursorToTreeWin()
|
||||
call g:NERDTree.MustBeOpen()
|
||||
call nerdtree#exec(g:NERDTree.GetWinNum() . "wincmd w")
|
||||
endfunction
|
||||
|
||||
" 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.GetWinNum() {{{1
|
||||
"gets the nerd tree window number for this tab
|
||||
function! s:NERDTree.GetWinNum()
|
||||
if exists("t:NERDTreeBufName")
|
||||
return bufwinnr(t:NERDTreeBufName)
|
||||
else
|
||||
return -1
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:NERDTree.IsOpen() {{{1
|
||||
function! s:NERDTree.IsOpen()
|
||||
return s:NERDTree.GetWinNum() != -1
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:NERDTree.MustBeOpen() {{{1
|
||||
function! s:NERDTree.MustBeOpen()
|
||||
if !s:NERDTree.IsOpen()
|
||||
throw "NERDTree.TreeNotOpen"
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:NERDTree.New() {{{1
|
||||
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.PathFilters() {{{1
|
||||
function! s:NERDTree.PathFilters()
|
||||
if !exists('s:NERDTree._PathFilters')
|
||||
let s:NERDTree._PathFilters = []
|
||||
endif
|
||||
return s:NERDTree._PathFilters
|
||||
endfunction
|
||||
|
||||
|
||||
"FUNCTION: s:NERDTree.render() {{{1
|
||||
"A convenience function - since this is called often
|
||||
function! s:NERDTree.render()
|
||||
call self.ui.render()
|
||||
endfunction
|
||||
@ -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)
|
||||
|
||||
@ -0,0 +1,352 @@
|
||||
"CLASS: Opener
|
||||
"============================================================
|
||||
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.
|
||||
"
|
||||
"Args:
|
||||
"a:newtab - boolean. If set, only close the tree now if we are opening the
|
||||
"target in a new tab. This is needed because we have to close tree before we
|
||||
"leave the tab
|
||||
function! s:Opener._checkToCloseTree(newtab)
|
||||
if self._keepopen
|
||||
return
|
||||
endif
|
||||
|
||||
if (a:newtab && self._where == 't') || !a:newtab
|
||||
call g:NERDTree.CloseIfQuitOnOpen()
|
||||
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"
|
||||
if self._where == 'v'
|
||||
vsplit
|
||||
elseif self._where == 'h'
|
||||
split
|
||||
elseif self._where == 't'
|
||||
tabnew
|
||||
endif
|
||||
else
|
||||
call self._checkToCloseTree(1)
|
||||
|
||||
if self._where == 'v'
|
||||
call self._newVSplit()
|
||||
elseif self._where == 'h'
|
||||
call self._newSplit()
|
||||
elseif self._where == 't'
|
||||
tabnew
|
||||
elseif self._where == 'p'
|
||||
call self._previousWindow()
|
||||
endif
|
||||
|
||||
call self._checkToCloseTree(0)
|
||||
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:
|
||||
"
|
||||
"a:path: The path object that is to be opened.
|
||||
"
|
||||
"a:opts:
|
||||
"
|
||||
"A dictionary containing the following keys (all optional):
|
||||
" 'where': Specifies whether the node should be opened in new split/tab or in
|
||||
" the previous window. Can be either 'v' or 'h' or 't' (for open in
|
||||
" new tab)
|
||||
" 'reuse': if a window is displaying the file then jump the cursor there. Can
|
||||
" 'all', 'currenttab' or empty to not reuse.
|
||||
" 'keepopen': dont close the tree window
|
||||
" 'stay': open the file, but keep the cursor in the tree win
|
||||
function! s:Opener.New(path, opts)
|
||||
let newObj = copy(self)
|
||||
|
||||
let newObj._path = a:path
|
||||
let newObj._stay = nerdtree#has_opt(a:opts, 'stay')
|
||||
|
||||
if has_key(a:opts, 'reuse')
|
||||
let newObj._reuse = a:opts['reuse']
|
||||
else
|
||||
let newObj._reuse = ''
|
||||
endif
|
||||
|
||||
let newObj._keepopen = nerdtree#has_opt(a:opts, 'keepopen')
|
||||
let newObj._where = has_key(a:opts, 'where') ? a:opts['where'] : ''
|
||||
let newObj._treetype = b:NERDTreeType
|
||||
call newObj._saveCursorPos()
|
||||
|
||||
return newObj
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Opener._newSplit() {{{1
|
||||
function! s:Opener._newSplit()
|
||||
" Save the user's settings for splitbelow and splitright
|
||||
let savesplitbelow=&splitbelow
|
||||
let savesplitright=&splitright
|
||||
|
||||
" 'there' will be set to a command to move from the split window
|
||||
" back to the explorer window
|
||||
"
|
||||
" 'back' will be set to a command to move from the explorer window
|
||||
" back to the newly split window
|
||||
"
|
||||
" 'right' and 'below' will be set to the settings needed for
|
||||
" splitbelow and splitright IF the explorer is the only window.
|
||||
"
|
||||
let there= g:NERDTreeWinPos ==# "left" ? "wincmd h" : "wincmd l"
|
||||
let back = g:NERDTreeWinPos ==# "left" ? "wincmd l" : "wincmd h"
|
||||
let right= g:NERDTreeWinPos ==# "left"
|
||||
let below=0
|
||||
|
||||
" Attempt to go to adjacent window
|
||||
call nerdtree#exec(back)
|
||||
|
||||
let onlyOneWin = (winnr("$") ==# 1)
|
||||
|
||||
" If no adjacent window, set splitright and splitbelow appropriately
|
||||
if onlyOneWin
|
||||
let &splitright=right
|
||||
let &splitbelow=below
|
||||
else
|
||||
" found adjacent window - invert split direction
|
||||
let &splitright=!right
|
||||
let &splitbelow=!below
|
||||
endif
|
||||
|
||||
let splitMode = onlyOneWin ? "vertical" : ""
|
||||
|
||||
" Open the new window
|
||||
try
|
||||
exec(splitMode." sp ")
|
||||
catch /^Vim\%((\a\+)\)\=:E37/
|
||||
call g:NERDTree.CursorToTreeWin()
|
||||
throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self._path.str() ." is already open and modified."
|
||||
catch /^Vim\%((\a\+)\)\=:/
|
||||
"do nothing
|
||||
endtry
|
||||
|
||||
"resize the tree window if no other window was open before
|
||||
if onlyOneWin
|
||||
let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize
|
||||
call nerdtree#exec(there)
|
||||
exec("silent ". splitMode ." resize ". size)
|
||||
call nerdtree#exec('wincmd p')
|
||||
endif
|
||||
|
||||
" Restore splitmode settings
|
||||
let &splitbelow=savesplitbelow
|
||||
let &splitright=savesplitright
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Opener._newVSplit() {{{1
|
||||
function! s:Opener._newVSplit()
|
||||
let winwidth = winwidth(".")
|
||||
if winnr("$")==#1
|
||||
let winwidth = g:NERDTreeWinSize
|
||||
endif
|
||||
|
||||
call nerdtree#exec("wincmd p")
|
||||
vnew
|
||||
|
||||
"resize the nerd tree back to the original size
|
||||
call g:NERDTree.CursorToTreeWin()
|
||||
exec("silent vertical resize ". winwidth)
|
||||
call nerdtree#exec('wincmd p')
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Opener.open(target) {{{1
|
||||
function! s:Opener.open(target)
|
||||
if self._path.isDirectory
|
||||
call self._openDirectory(a:target)
|
||||
else
|
||||
call self._openFile()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Opener._openFile() {{{1
|
||||
function! s:Opener._openFile()
|
||||
if self._reuseWindow()
|
||||
return
|
||||
endif
|
||||
|
||||
call self._gotoTargetWin()
|
||||
|
||||
if self._treetype ==# "secondary"
|
||||
call self._path.edit()
|
||||
else
|
||||
call self._path.edit()
|
||||
|
||||
|
||||
if self._stay
|
||||
call self._restoreCursorPos()
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Opener._openDirectory(node) {{{1
|
||||
function! s:Opener._openDirectory(node)
|
||||
if self._treetype ==# "secondary"
|
||||
call self._gotoTargetWin()
|
||||
call g:NERDTreeCreator.CreateSecondary(a:node.path.str())
|
||||
else
|
||||
call self._gotoTargetWin()
|
||||
if empty(self._where)
|
||||
call a:node.makeRoot()
|
||||
call b:NERDTree.render()
|
||||
call a:node.putCursorHere(0, 0)
|
||||
elseif self._where == 't'
|
||||
call g:NERDTreeCreator.CreatePrimary(a:node.path.str())
|
||||
else
|
||||
call g:NERDTreeCreator.CreateSecondary(a:node.path.str())
|
||||
endif
|
||||
endif
|
||||
|
||||
if self._stay
|
||||
call self._restoreCursorPos()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Opener._previousWindow() {{{1
|
||||
function! s:Opener._previousWindow()
|
||||
if !self._isWindowUsable(winnr("#")) && self._firstUsableWindow() ==# -1
|
||||
call self._newSplit()
|
||||
else
|
||||
try
|
||||
if !self._isWindowUsable(winnr("#"))
|
||||
call nerdtree#exec(self._firstUsableWindow() . "wincmd w")
|
||||
else
|
||||
call nerdtree#exec('wincmd p')
|
||||
endif
|
||||
catch /^Vim\%((\a\+)\)\=:E37/
|
||||
call g:NERDTree.CursorToTreeWin()
|
||||
throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self._path.str() ." is already open and modified."
|
||||
catch /^Vim\%((\a\+)\)\=:/
|
||||
echo v:exception
|
||||
endtry
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Opener._restoreCursorPos(){{{1
|
||||
function! s:Opener._restoreCursorPos()
|
||||
call nerdtree#exec('normal ' . self._tabnr . 'gt')
|
||||
call nerdtree#exec(bufwinnr(self._bufnr) . 'wincmd w')
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Opener._reuseWindow(){{{1
|
||||
"put the cursor in the first window we find for this file
|
||||
"
|
||||
"return 1 if we were successful
|
||||
function! s:Opener._reuseWindow()
|
||||
if empty(self._reuse)
|
||||
return 0
|
||||
endif
|
||||
|
||||
"check the current tab for the window
|
||||
let winnr = bufwinnr('^' . self._path.str() . '$')
|
||||
if winnr != -1
|
||||
call nerdtree#exec(winnr . "wincmd w")
|
||||
call self._checkToCloseTree(0)
|
||||
return 1
|
||||
endif
|
||||
|
||||
if self._reuse == 'currenttab'
|
||||
return 0
|
||||
endif
|
||||
|
||||
"check other tabs
|
||||
let tabnr = self._path.tabnr()
|
||||
if tabnr
|
||||
call self._checkToCloseTree(1)
|
||||
call nerdtree#exec('normal! ' . tabnr . 'gt')
|
||||
let winnr = bufwinnr('^' . self._path.str() . '$')
|
||||
call nerdtree#exec(winnr . "wincmd w")
|
||||
return 1
|
||||
endif
|
||||
|
||||
return 0
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Opener._saveCursorPos(){{{1
|
||||
function! s:Opener._saveCursorPos()
|
||||
let self._bufnr = bufnr("")
|
||||
let self._tabnr = tabpagenr()
|
||||
endfunction
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,761 @@
|
||||
"we need to use this number many times for sorting... so we calculate it only
|
||||
"once here
|
||||
let s:NERDTreeSortStarIndex = index(g:NERDTreeSortOrder, '*')
|
||||
|
||||
"CLASS: Path
|
||||
"============================================================
|
||||
let s:Path = {}
|
||||
let g:NERDTreePath = s:Path
|
||||
|
||||
"FUNCTION: Path.AbsolutePathFor(str) {{{1
|
||||
function! s:Path.AbsolutePathFor(str)
|
||||
let prependCWD = 0
|
||||
if nerdtree#runningWindows()
|
||||
let prependCWD = a:str !~# '^.:\(\\\|\/\)' && a:str !~# '^\(\\\\\|\/\/\)'
|
||||
else
|
||||
let prependCWD = a:str !~# '^/'
|
||||
endif
|
||||
|
||||
let toReturn = a:str
|
||||
if prependCWD
|
||||
let toReturn = getcwd() . s:Path.Slash() . a:str
|
||||
endif
|
||||
|
||||
return toReturn
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.bookmarkNames() {{{1
|
||||
function! s:Path.bookmarkNames()
|
||||
if !exists("self._bookmarkNames")
|
||||
call self.cacheDisplayString()
|
||||
endif
|
||||
return self._bookmarkNames
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.cacheDisplayString() {{{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 . '*'
|
||||
endif
|
||||
|
||||
let self._bookmarkNames = []
|
||||
for i in g:NERDTreeBookmark.Bookmarks()
|
||||
if i.path.equals(self)
|
||||
call add(self._bookmarkNames, i.name)
|
||||
endif
|
||||
endfor
|
||||
if !empty(self._bookmarkNames)
|
||||
let self.cachedDisplayString .= ' {' . join(self._bookmarkNames) . '}'
|
||||
endif
|
||||
|
||||
if self.isSymLink
|
||||
let self.cachedDisplayString .= ' -> ' . self.symLinkDest
|
||||
endif
|
||||
|
||||
if self.isReadOnly
|
||||
let self.cachedDisplayString .= ' [RO]'
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.changeToDir() {{{1
|
||||
function! s:Path.changeToDir()
|
||||
let dir = self.str({'format': 'Cd'})
|
||||
if self.isDirectory ==# 0
|
||||
let dir = self.getParent().str({'format': 'Cd'})
|
||||
endif
|
||||
|
||||
try
|
||||
execute "cd " . dir
|
||||
call nerdtree#echo("CWD is now: " . getcwd())
|
||||
catch
|
||||
throw "NERDTree.PathChangeError: cannot change CWD to " . dir
|
||||
endtry
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.compareTo() {{{1
|
||||
"
|
||||
"Compares this Path to the given path and returns 0 if they are equal, -1 if
|
||||
"this Path is "less than" the given path, or 1 if it is "greater".
|
||||
"
|
||||
"Args:
|
||||
"path: the path object to compare this to
|
||||
"
|
||||
"Return:
|
||||
"1, -1 or 0
|
||||
function! s:Path.compareTo(path)
|
||||
let thisPath = self.getLastPathComponent(1)
|
||||
let thatPath = a:path.getLastPathComponent(1)
|
||||
|
||||
"if the paths are the same then clearly we return 0
|
||||
if thisPath ==# thatPath
|
||||
return 0
|
||||
endif
|
||||
|
||||
let thisSS = self.getSortOrderIndex()
|
||||
let thatSS = a:path.getSortOrderIndex()
|
||||
|
||||
"compare the sort sequences, if they are different then the return
|
||||
"value is easy
|
||||
if thisSS < thatSS
|
||||
return -1
|
||||
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
|
||||
if pathCompare
|
||||
return -1
|
||||
else
|
||||
return 1
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.Create(fullpath) {{{1
|
||||
"
|
||||
"Factory method.
|
||||
"
|
||||
"Creates a path object with the given path. The path is also created on the
|
||||
"filesystem. If the path already exists, a NERDTree.Path.Exists exception is
|
||||
"thrown. If any other errors occur, a NERDTree.Path exception is thrown.
|
||||
"
|
||||
"Args:
|
||||
"fullpath: the full filesystem path to the file/dir to create
|
||||
function! s:Path.Create(fullpath)
|
||||
"bail if the a:fullpath already exists
|
||||
if isdirectory(a:fullpath) || filereadable(a:fullpath)
|
||||
throw "NERDTree.CreatePathError: Directory Exists: '" . a:fullpath . "'"
|
||||
endif
|
||||
|
||||
try
|
||||
|
||||
"if it ends with a slash, assume its a dir create it
|
||||
if a:fullpath =~# '\(\\\|\/\)$'
|
||||
"whack the trailing slash off the end if it exists
|
||||
let fullpath = substitute(a:fullpath, '\(\\\|\/\)$', '', '')
|
||||
|
||||
call mkdir(fullpath, 'p')
|
||||
|
||||
"assume its a file and create
|
||||
else
|
||||
call s:Path.createParentDirectories(a:fullpath)
|
||||
call writefile([], a:fullpath)
|
||||
endif
|
||||
catch
|
||||
throw "NERDTree.CreatePathError: Could not create path: '" . a:fullpath . "'"
|
||||
endtry
|
||||
|
||||
return s:Path.New(a:fullpath)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.copy(dest) {{{1
|
||||
"
|
||||
"Copies the file/dir represented by this Path to the given location
|
||||
"
|
||||
"Args:
|
||||
"dest: the location to copy this dir/file to
|
||||
function! s:Path.copy(dest)
|
||||
if !s:Path.CopyingSupported()
|
||||
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(), self._escChars()) . " " . escape(dest, self._escChars())
|
||||
let success = system(cmd)
|
||||
if success != 0
|
||||
throw "NERDTree.CopyError: Could not copy ''". self.str() ."'' to: '" . a:dest . "'"
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.CopyingSupported() {{{1
|
||||
"
|
||||
"returns 1 if copying is supported for this OS
|
||||
function! s:Path.CopyingSupported()
|
||||
return exists('g:NERDTreeCopyCmd')
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.copyingWillOverwrite(dest) {{{1
|
||||
"
|
||||
"returns 1 if copy this path to the given location will cause files to
|
||||
"overwritten
|
||||
"
|
||||
"Args:
|
||||
"dest: the location this path will be copied to
|
||||
function! s:Path.copyingWillOverwrite(dest)
|
||||
if filereadable(a:dest)
|
||||
return 1
|
||||
endif
|
||||
|
||||
if isdirectory(a:dest)
|
||||
let path = s:Path.JoinPathStrings(a:dest, self.getLastPathComponent(0))
|
||||
if filereadable(path)
|
||||
return 1
|
||||
endif
|
||||
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.
|
||||
"Deletion of directories is not supported
|
||||
"
|
||||
"Throws NERDTree.Path.Deletion exceptions
|
||||
function! s:Path.delete()
|
||||
if self.isDirectory
|
||||
|
||||
let cmd = g:NERDTreeRemoveDirCmd . self.str({'escape': 1})
|
||||
let success = system(cmd)
|
||||
|
||||
if v:shell_error != 0
|
||||
throw "NERDTree.PathDeletionError: Could not delete directory: '" . self.str() . "'"
|
||||
endif
|
||||
else
|
||||
let success = delete(self.str())
|
||||
if success != 0
|
||||
throw "NERDTree.PathDeletionError: Could not delete file: '" . self.str() . "'"
|
||||
endif
|
||||
endif
|
||||
|
||||
"delete all bookmarks for this path
|
||||
for i in self.bookmarkNames()
|
||||
let bookmark = g:NERDTreeBookmark.BookmarkFor(i)
|
||||
call bookmark.delete()
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.displayString() {{{1
|
||||
"
|
||||
"Returns a string that specifies how the path should be represented as a
|
||||
"string
|
||||
function! s:Path.displayString()
|
||||
if self.cachedDisplayString ==# ""
|
||||
call self.cacheDisplayString()
|
||||
endif
|
||||
|
||||
return self.cachedDisplayString
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.edit() {{{1
|
||||
function! s:Path.edit()
|
||||
exec "edit " . self.str({'format': 'Edit'})
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.extractDriveLetter(fullpath) {{{1
|
||||
"
|
||||
"If running windows, cache the drive letter for this path
|
||||
function! s:Path.extractDriveLetter(fullpath)
|
||||
if nerdtree#runningWindows()
|
||||
if a:fullpath =~ '^\(\\\\\|\/\/\)'
|
||||
"For network shares, the 'drive' consists of the first two parts of the path, i.e. \\boxname\share
|
||||
let self.drive = substitute(a:fullpath, '^\(\(\\\\\|\/\/\)[^\\\/]*\(\\\|\/\)[^\\\/]*\).*', '\1', '')
|
||||
let self.drive = substitute(self.drive, '/', '\', "g")
|
||||
else
|
||||
let self.drive = substitute(a:fullpath, '\(^[a-zA-Z]:\).*', '\1', '')
|
||||
endif
|
||||
else
|
||||
let self.drive = ''
|
||||
endif
|
||||
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.exists() {{{1
|
||||
"return 1 if this path points to a location that is readable or is a directory
|
||||
function! s:Path.exists()
|
||||
let p = self.str()
|
||||
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.
|
||||
"
|
||||
"Return:
|
||||
"a Path object
|
||||
function! s:Path.getDir()
|
||||
if self.isDirectory
|
||||
return self
|
||||
else
|
||||
return self.getParent()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.getParent() {{{1
|
||||
"
|
||||
"Returns a new path object for this paths parent
|
||||
"
|
||||
"Return:
|
||||
"a new Path object
|
||||
function! s:Path.getParent()
|
||||
if nerdtree#runningWindows()
|
||||
let path = self.drive . '\' . join(self.pathSegments[0:-2], '\')
|
||||
else
|
||||
let path = '/'. join(self.pathSegments[0:-2], '/')
|
||||
endif
|
||||
|
||||
return s:Path.New(path)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.getLastPathComponent(dirSlash) {{{1
|
||||
"
|
||||
"Gets the last part of this path.
|
||||
"
|
||||
"Args:
|
||||
"dirSlash: if 1 then a trailing slash will be added to the returned value for
|
||||
"directory nodes.
|
||||
function! s:Path.getLastPathComponent(dirSlash)
|
||||
if empty(self.pathSegments)
|
||||
return ''
|
||||
endif
|
||||
let toReturn = self.pathSegments[-1]
|
||||
if a:dirSlash && self.isDirectory
|
||||
let toReturn = toReturn . '/'
|
||||
endif
|
||||
return toReturn
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.getSortOrderIndex() {{{1
|
||||
"returns the index of the pattern in g:NERDTreeSortOrder that this path matches
|
||||
function! s:Path.getSortOrderIndex()
|
||||
let i = 0
|
||||
while i < len(g:NERDTreeSortOrder)
|
||||
if self.getLastPathComponent(1) =~# g:NERDTreeSortOrder[i]
|
||||
return i
|
||||
endif
|
||||
let i = i + 1
|
||||
endwhile
|
||||
return s:NERDTreeSortStarIndex
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.isUnixHiddenFile() {{{1
|
||||
"check for unix hidden files
|
||||
function! s:Path.isUnixHiddenFile()
|
||||
return self.getLastPathComponent(0) =~# '^\.'
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.isUnixHiddenPath() {{{1
|
||||
"check for unix path with hidden components
|
||||
function! s:Path.isUnixHiddenPath()
|
||||
if self.getLastPathComponent(0) =~# '^\.'
|
||||
return 1
|
||||
else
|
||||
for segment in self.pathSegments
|
||||
if segment =~# '^\.'
|
||||
return 1
|
||||
endif
|
||||
endfor
|
||||
return 0
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.ignore() {{{1
|
||||
"returns true if this path should be ignored
|
||||
function! s:Path.ignore()
|
||||
"filter out the user specified paths to ignore
|
||||
if b:NERDTreeIgnoreEnabled
|
||||
for i in g:NERDTreeIgnore
|
||||
if self._ignorePatternMatches(i)
|
||||
return 1
|
||||
endif
|
||||
endfor
|
||||
|
||||
for callback in g:NERDTree.PathFilters()
|
||||
if {callback}({'path': self, 'nerdtree': b:NERDTree})
|
||||
return 1
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
|
||||
"dont show hidden files unless instructed to
|
||||
if b:NERDTreeShowHidden ==# 0 && self.isUnixHiddenFile()
|
||||
return 1
|
||||
endif
|
||||
|
||||
if b:NERDTreeShowFiles ==# 0 && self.isDirectory ==# 0
|
||||
return 1
|
||||
endif
|
||||
|
||||
return 0
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path._ignorePatternMatches(pattern) {{{1
|
||||
"returns true if this path matches the given ignore pattern
|
||||
function! s:Path._ignorePatternMatches(pattern)
|
||||
let pat = a:pattern
|
||||
if strpart(pat,len(pat)-7) == '[[dir]]'
|
||||
if !self.isDirectory
|
||||
return 0
|
||||
endif
|
||||
let pat = strpart(pat,0, len(pat)-7)
|
||||
elseif strpart(pat,len(pat)-8) == '[[file]]'
|
||||
if self.isDirectory
|
||||
return 0
|
||||
endif
|
||||
let pat = strpart(pat,0, len(pat)-8)
|
||||
endif
|
||||
|
||||
return self.getLastPathComponent(0) =~# pat
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.isUnder(path) {{{1
|
||||
"return 1 if this path is somewhere under the given path in the filesystem.
|
||||
"
|
||||
"a:path should be a dir
|
||||
function! s:Path.isUnder(path)
|
||||
if a:path.isDirectory == 0
|
||||
return 0
|
||||
endif
|
||||
|
||||
let this = self.str()
|
||||
let that = a:path.str()
|
||||
return stridx(this, that . s:Path.Slash()) == 0
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.JoinPathStrings(...) {{{1
|
||||
function! s:Path.JoinPathStrings(...)
|
||||
let components = []
|
||||
for i in a:000
|
||||
let components = extend(components, split(i, '/'))
|
||||
endfor
|
||||
return '/' . join(components, '/')
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.equals() {{{1
|
||||
"
|
||||
"Determines whether 2 path objects are "equal".
|
||||
"They are equal if the paths they represent are the same
|
||||
"
|
||||
"Args:
|
||||
"path: the other path obj to compare this with
|
||||
function! s:Path.equals(path)
|
||||
return self.str() ==# a:path.str()
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.New() {{{1
|
||||
"The Constructor for the Path object
|
||||
function! s:Path.New(path)
|
||||
let newPath = copy(self)
|
||||
|
||||
call newPath.readInfoFromDisk(s:Path.AbsolutePathFor(a:path))
|
||||
|
||||
let newPath.cachedDisplayString = ""
|
||||
let newPath.flagSet = g:NERDTreeFlagSet.New()
|
||||
|
||||
return newPath
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.Slash() {{{1
|
||||
"return the slash to use for the current OS
|
||||
function! s:Path.Slash()
|
||||
return nerdtree#runningWindows() ? '\' : '/'
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.Resolve() {{{1
|
||||
"Invoke the vim resolve() function and return the result
|
||||
"This is necessary because in some versions of vim resolve() removes trailing
|
||||
"slashes while in other versions it doesn't. This always removes the trailing
|
||||
"slash
|
||||
function! s:Path.Resolve(path)
|
||||
let tmp = resolve(a:path)
|
||||
return tmp =~# '.\+/$' ? substitute(tmp, '/$', '', '') : tmp
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.readInfoFromDisk(fullpath) {{{1
|
||||
"
|
||||
"
|
||||
"Throws NERDTree.Path.InvalidArguments exception.
|
||||
function! s:Path.readInfoFromDisk(fullpath)
|
||||
call self.extractDriveLetter(a:fullpath)
|
||||
|
||||
let fullpath = s:Path.WinToUnixPath(a:fullpath)
|
||||
|
||||
if getftype(fullpath) ==# "fifo"
|
||||
throw "NERDTree.InvalidFiletypeError: Cant handle FIFO files: " . a:fullpath
|
||||
endif
|
||||
|
||||
let self.pathSegments = split(fullpath, '/')
|
||||
|
||||
let self.isReadOnly = 0
|
||||
if isdirectory(a:fullpath)
|
||||
let self.isDirectory = 1
|
||||
elseif filereadable(a:fullpath)
|
||||
let self.isDirectory = 0
|
||||
let self.isReadOnly = filewritable(a:fullpath) ==# 0
|
||||
else
|
||||
throw "NERDTree.InvalidArgumentsError: Invalid path = " . a:fullpath
|
||||
endif
|
||||
|
||||
let self.isExecutable = 0
|
||||
if !self.isDirectory
|
||||
let self.isExecutable = getfperm(a:fullpath) =~# 'x'
|
||||
endif
|
||||
|
||||
"grab the last part of the path (minus the trailing slash)
|
||||
let lastPathComponent = self.getLastPathComponent(0)
|
||||
|
||||
"get the path to the new node with the parent dir fully resolved
|
||||
let hardPath = s:Path.Resolve(self.strTrunk()) . '/' . lastPathComponent
|
||||
|
||||
"if the last part of the path is a symlink then flag it as such
|
||||
let self.isSymLink = (s:Path.Resolve(hardPath) != hardPath)
|
||||
if self.isSymLink
|
||||
let self.symLinkDest = s:Path.Resolve(fullpath)
|
||||
|
||||
"if the link is a dir then slap a / on the end of its dest
|
||||
if isdirectory(self.symLinkDest)
|
||||
|
||||
"we always wanna treat MS windows shortcuts as files for
|
||||
"simplicity
|
||||
if hardPath !~# '\.lnk$'
|
||||
|
||||
let self.symLinkDest = self.symLinkDest . '/'
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
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
|
||||
|
||||
"FUNCTION: Path.rename() {{{1
|
||||
"
|
||||
"Renames this node on the filesystem
|
||||
function! s:Path.rename(newPath)
|
||||
if a:newPath ==# ''
|
||||
throw "NERDTree.InvalidArgumentsError: Invalid newPath for renaming = ". a:newPath
|
||||
endif
|
||||
|
||||
let success = rename(self.str(), a:newPath)
|
||||
if success != 0
|
||||
throw "NERDTree.PathRenameError: Could not rename: '" . self.str() . "'" . 'to:' . a:newPath
|
||||
endif
|
||||
call self.readInfoFromDisk(a:newPath)
|
||||
|
||||
for i in self.bookmarkNames()
|
||||
let b = g:NERDTreeBookmark.BookmarkFor(i)
|
||||
call b.setPath(copy(self))
|
||||
endfor
|
||||
call g:NERDTreeBookmark.Write()
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.str() {{{1
|
||||
"
|
||||
"Returns a string representation of this Path
|
||||
"
|
||||
"Takes an optional dictionary param to specify how the output should be
|
||||
"formatted.
|
||||
"
|
||||
"The dict may have the following keys:
|
||||
" 'format'
|
||||
" 'escape'
|
||||
" 'truncateTo'
|
||||
"
|
||||
"The 'format' key may have a value of:
|
||||
" 'Cd' - a string to be used with the :cd command
|
||||
" 'Edit' - a string to be used with :e :sp :new :tabedit etc
|
||||
" 'UI' - a string used in the NERD tree UI
|
||||
"
|
||||
"The 'escape' key, if specified will cause the output to be escaped with
|
||||
"shellescape()
|
||||
"
|
||||
"The 'truncateTo' key causes the resulting string to be truncated to the value
|
||||
"'truncateTo' maps to. A '<' char will be prepended.
|
||||
function! s:Path.str(...)
|
||||
let options = a:0 ? a:1 : {}
|
||||
let toReturn = ""
|
||||
|
||||
if has_key(options, 'format')
|
||||
let format = options['format']
|
||||
if has_key(self, '_strFor' . format)
|
||||
exec 'let toReturn = self._strFor' . format . '()'
|
||||
else
|
||||
raise 'NERDTree.UnknownFormatError: unknown format "'. format .'"'
|
||||
endif
|
||||
else
|
||||
let toReturn = self._str()
|
||||
endif
|
||||
|
||||
if nerdtree#has_opt(options, 'escape')
|
||||
let toReturn = shellescape(toReturn)
|
||||
endif
|
||||
|
||||
if has_key(options, 'truncateTo')
|
||||
let limit = options['truncateTo']
|
||||
if len(toReturn) > limit-1
|
||||
let toReturn = toReturn[(len(toReturn)-limit+1):]
|
||||
if len(split(toReturn, '/')) > 1
|
||||
let toReturn = '</' . join(split(toReturn, '/')[1:], '/') . '/'
|
||||
else
|
||||
let toReturn = '<' . toReturn
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
return toReturn
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path._strForUI() {{{1
|
||||
function! s:Path._strForUI()
|
||||
let toReturn = '/' . join(self.pathSegments, '/')
|
||||
if self.isDirectory && toReturn != '/'
|
||||
let toReturn = toReturn . '/'
|
||||
endif
|
||||
return toReturn
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path._strForCd() {{{1
|
||||
"
|
||||
" returns a string that can be used with :cd
|
||||
function! s:Path._strForCd()
|
||||
return escape(self.str(), self._escChars())
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path._strForEdit() {{{1
|
||||
"
|
||||
"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(), self._escChars())
|
||||
|
||||
"make it relative
|
||||
let p = fnamemodify(p, ':.')
|
||||
|
||||
"handle the edge case where the file begins with a + (vim interprets
|
||||
"the +foo in `:e +foo` as an option to :edit)
|
||||
if p[0] == "+"
|
||||
let p = '\' . p
|
||||
endif
|
||||
|
||||
if p ==# ''
|
||||
let p = '.'
|
||||
endif
|
||||
|
||||
return p
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path._strForGlob() {{{1
|
||||
function! s:Path._strForGlob()
|
||||
let lead = s:Path.Slash()
|
||||
|
||||
"if we are running windows then slap a drive letter on the front
|
||||
if nerdtree#runningWindows()
|
||||
let lead = self.drive . '\'
|
||||
endif
|
||||
|
||||
let toReturn = lead . join(self.pathSegments, s:Path.Slash())
|
||||
|
||||
if !nerdtree#runningWindows()
|
||||
let toReturn = escape(toReturn, self._escChars())
|
||||
endif
|
||||
return toReturn
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path._str() {{{1
|
||||
"
|
||||
"Gets the string path for this path object that is appropriate for the OS.
|
||||
"EG, in windows c:\foo\bar
|
||||
" in *nix /foo/bar
|
||||
function! s:Path._str()
|
||||
let lead = s:Path.Slash()
|
||||
|
||||
"if we are running windows then slap a drive letter on the front
|
||||
if nerdtree#runningWindows()
|
||||
let lead = self.drive . '\'
|
||||
endif
|
||||
|
||||
return lead . join(self.pathSegments, s:Path.Slash())
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.strTrunk() {{{1
|
||||
"Gets the path without the last segment on the end.
|
||||
function! s:Path.strTrunk()
|
||||
return self.drive . '/' . join(self.pathSegments[0:-2], '/')
|
||||
endfunction
|
||||
|
||||
" FUNCTION: Path.tabnr() {{{1
|
||||
" return the number of the first tab that is displaying this file
|
||||
"
|
||||
" return 0 if no tab was found
|
||||
function! s:Path.tabnr()
|
||||
let str = self.str()
|
||||
for t in range(tabpagenr('$'))
|
||||
for b in tabpagebuflist(t+1)
|
||||
if str == expand('#' . b . ':p')
|
||||
return t+1
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
return 0
|
||||
endfunction
|
||||
|
||||
"FUNCTION: Path.WinToUnixPath(pathstr){{{1
|
||||
"Takes in a windows path and returns the unix equiv
|
||||
"
|
||||
"A class level method
|
||||
"
|
||||
"Args:
|
||||
"pathstr: the windows path to convert
|
||||
function! s:Path.WinToUnixPath(pathstr)
|
||||
if !nerdtree#runningWindows()
|
||||
return a:pathstr
|
||||
endif
|
||||
|
||||
let toReturn = a:pathstr
|
||||
|
||||
"remove the x:\ of the front
|
||||
let toReturn = substitute(toReturn, '^.*:\(\\\|/\)\?', '/', "")
|
||||
|
||||
"remove the \\ network share from the front
|
||||
let toReturn = substitute(toReturn, '^\(\\\\\|\/\/\)[^\\\/]*\(\\\|\/\)[^\\\/]*\(\\\|\/\)\?', '/', "")
|
||||
|
||||
"convert all \ chars to /
|
||||
let toReturn = substitute(toReturn, '\', '/', "g")
|
||||
|
||||
return toReturn
|
||||
endfunction
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,543 @@
|
||||
"CLASS: TreeDirNode
|
||||
"A subclass of NERDTreeFileNode.
|
||||
"
|
||||
"The 'composite' part of the file/dir composite.
|
||||
"============================================================
|
||||
let s:TreeDirNode = copy(g:NERDTreeFileNode)
|
||||
let g:NERDTreeDirNode = s:TreeDirNode
|
||||
|
||||
"FUNCTION: TreeDirNode.AbsoluteTreeRoot(){{{1
|
||||
"class method that returns the highest cached ancestor of the current root
|
||||
function! s:TreeDirNode.AbsoluteTreeRoot()
|
||||
let currentNode = b:NERDTreeRoot
|
||||
while currentNode.parent != {}
|
||||
let currentNode = currentNode.parent
|
||||
endwhile
|
||||
return currentNode
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.activate([options]) {{{1
|
||||
unlet s:TreeDirNode.activate
|
||||
function! s:TreeDirNode.activate(...)
|
||||
let opts = a:0 ? a:1 : {}
|
||||
call self.toggleOpen(opts)
|
||||
call b:NERDTree.render()
|
||||
call self.putCursorHere(0, 0)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.addChild(treenode, inOrder) {{{1
|
||||
"Adds the given treenode to the list of children for this node
|
||||
"
|
||||
"Args:
|
||||
"-treenode: the node to add
|
||||
"-inOrder: 1 if the new node should be inserted in sorted order
|
||||
function! s:TreeDirNode.addChild(treenode, inOrder)
|
||||
call add(self.children, a:treenode)
|
||||
let a:treenode.parent = self
|
||||
|
||||
if a:inOrder
|
||||
call self.sortChildren()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.close() {{{1
|
||||
"Closes this directory
|
||||
function! s:TreeDirNode.close()
|
||||
let self.isOpen = 0
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.closeChildren() {{{1
|
||||
"Closes all the child dir nodes of this node
|
||||
function! s:TreeDirNode.closeChildren()
|
||||
for i in self.children
|
||||
if i.path.isDirectory
|
||||
call i.close()
|
||||
call i.closeChildren()
|
||||
endif
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.createChild(path, inOrder) {{{1
|
||||
"Instantiates a new child node for this node with the given path. The new
|
||||
"nodes parent is set to this node.
|
||||
"
|
||||
"Args:
|
||||
"path: a Path object that this node will represent/contain
|
||||
"inOrder: 1 if the new node should be inserted in sorted order
|
||||
"
|
||||
"Returns:
|
||||
"the newly created node
|
||||
function! s:TreeDirNode.createChild(path, inOrder)
|
||||
let newTreeNode = g:NERDTreeFileNode.New(a:path)
|
||||
call self.addChild(newTreeNode, a:inOrder)
|
||||
return newTreeNode
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.findNode(path) {{{1
|
||||
"Will find one of the children (recursively) that has the given path
|
||||
"
|
||||
"Args:
|
||||
"path: a path object
|
||||
unlet s:TreeDirNode.findNode
|
||||
function! s:TreeDirNode.findNode(path)
|
||||
if a:path.equals(self.path)
|
||||
return self
|
||||
endif
|
||||
if stridx(a:path.str(), self.path.str(), 0) ==# -1
|
||||
return {}
|
||||
endif
|
||||
|
||||
if self.path.isDirectory
|
||||
for i in self.children
|
||||
let retVal = i.findNode(a:path)
|
||||
if retVal != {}
|
||||
return retVal
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
return {}
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.getChildCount() {{{1
|
||||
"Returns the number of children this node has
|
||||
function! s:TreeDirNode.getChildCount()
|
||||
return len(self.children)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.getChild(path) {{{1
|
||||
"Returns child node of this node that has the given path or {} if no such node
|
||||
"exists.
|
||||
"
|
||||
"This function doesnt not recurse into child dir nodes
|
||||
"
|
||||
"Args:
|
||||
"path: a path object
|
||||
function! s:TreeDirNode.getChild(path)
|
||||
if stridx(a:path.str(), self.path.str(), 0) ==# -1
|
||||
return {}
|
||||
endif
|
||||
|
||||
let index = self.getChildIndex(a:path)
|
||||
if index ==# -1
|
||||
return {}
|
||||
else
|
||||
return self.children[index]
|
||||
endif
|
||||
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.getChildByIndex(indx, visible) {{{1
|
||||
"returns the child at the given index
|
||||
"Args:
|
||||
"indx: the index to get the child from
|
||||
"visible: 1 if only the visible children array should be used, 0 if all the
|
||||
"children should be searched.
|
||||
function! s:TreeDirNode.getChildByIndex(indx, visible)
|
||||
let array_to_search = a:visible? self.getVisibleChildren() : self.children
|
||||
if a:indx > len(array_to_search)
|
||||
throw "NERDTree.InvalidArgumentsError: Index is out of bounds."
|
||||
endif
|
||||
return array_to_search[a:indx]
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.getChildIndex(path) {{{1
|
||||
"Returns the index of the child node of this node that has the given path or
|
||||
"-1 if no such node exists.
|
||||
"
|
||||
"This function doesnt not recurse into child dir nodes
|
||||
"
|
||||
"Args:
|
||||
"path: a path object
|
||||
function! s:TreeDirNode.getChildIndex(path)
|
||||
if stridx(a:path.str(), self.path.str(), 0) ==# -1
|
||||
return -1
|
||||
endif
|
||||
|
||||
"do a binary search for the child
|
||||
let a = 0
|
||||
let z = self.getChildCount()
|
||||
while a < z
|
||||
let mid = (a+z)/2
|
||||
let diff = a:path.compareTo(self.children[mid].path)
|
||||
|
||||
if diff ==# -1
|
||||
let z = mid
|
||||
elseif diff ==# 1
|
||||
let a = mid+1
|
||||
else
|
||||
return mid
|
||||
endif
|
||||
endwhile
|
||||
return -1
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.GetSelected() {{{1
|
||||
"Returns the current node if it is a dir node, or else returns the current
|
||||
"nodes parent
|
||||
unlet s:TreeDirNode.GetSelected
|
||||
function! s:TreeDirNode.GetSelected()
|
||||
let currentDir = g:NERDTreeFileNode.GetSelected()
|
||||
if currentDir != {} && !currentDir.isRoot()
|
||||
if currentDir.path.isDirectory ==# 0
|
||||
let currentDir = currentDir.parent
|
||||
endif
|
||||
endif
|
||||
return currentDir
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.getVisibleChildCount() {{{1
|
||||
"Returns the number of visible children this node has
|
||||
function! s:TreeDirNode.getVisibleChildCount()
|
||||
return len(self.getVisibleChildren())
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.getVisibleChildren() {{{1
|
||||
"Returns a list of children to display for this node, in the correct order
|
||||
"
|
||||
"Return:
|
||||
"an array of treenodes
|
||||
function! s:TreeDirNode.getVisibleChildren()
|
||||
let toReturn = []
|
||||
for i in self.children
|
||||
if i.path.ignore() ==# 0
|
||||
call add(toReturn, i)
|
||||
endif
|
||||
endfor
|
||||
return toReturn
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.hasVisibleChildren() {{{1
|
||||
"returns 1 if this node has any childre, 0 otherwise..
|
||||
function! s:TreeDirNode.hasVisibleChildren()
|
||||
return self.getVisibleChildCount() != 0
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode._initChildren() {{{1
|
||||
"Removes all childen from this node and re-reads them
|
||||
"
|
||||
"Args:
|
||||
"silent: 1 if the function should not echo any "please wait" messages for
|
||||
"large directories
|
||||
"
|
||||
"Return: the number of child nodes read
|
||||
function! s:TreeDirNode._initChildren(silent)
|
||||
"remove all the current child nodes
|
||||
let self.children = []
|
||||
|
||||
"get an array of all the files in the nodes dir
|
||||
let dir = self.path
|
||||
let globDir = dir.str({'format': 'Glob'})
|
||||
|
||||
if version >= 703
|
||||
let filesStr = globpath(globDir, '*', !g:NERDTreeRespectWildIgnore) . "\n" . globpath(globDir, '.*', !g:NERDTreeRespectWildIgnore)
|
||||
else
|
||||
let filesStr = globpath(globDir, '*') . "\n" . globpath(globDir, '.*')
|
||||
endif
|
||||
|
||||
let files = split(filesStr, "\n")
|
||||
|
||||
if !a:silent && len(files) > g:NERDTreeNotificationThreshold
|
||||
call nerdtree#echo("Please wait, caching a large dir ...")
|
||||
endif
|
||||
|
||||
let invalidFilesFound = 0
|
||||
for i in files
|
||||
|
||||
"filter out the .. and . directories
|
||||
"Note: we must match .. AND ../ cos sometimes the globpath returns
|
||||
"../ for path with strange chars (eg $)
|
||||
if i !~# '\/\.\.\/\?$' && i !~# '\/\.\/\?$'
|
||||
|
||||
"put the next file in a new node and attach it
|
||||
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
|
||||
endif
|
||||
endfor
|
||||
|
||||
call self.sortChildren()
|
||||
|
||||
if !a:silent && len(files) > g:NERDTreeNotificationThreshold
|
||||
call nerdtree#echo("Please wait, caching a large dir ... DONE (". self.getChildCount() ." nodes cached).")
|
||||
endif
|
||||
|
||||
if invalidFilesFound
|
||||
call nerdtree#echoWarning(invalidFilesFound . " file(s) could not be loaded into the NERD tree")
|
||||
endif
|
||||
return self.getChildCount()
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.New(path) {{{1
|
||||
"Returns a new TreeNode object with the given path and parent
|
||||
"
|
||||
"Args:
|
||||
"path: a path object representing the full filesystem path to the file/dir that the node represents
|
||||
unlet s:TreeDirNode.New
|
||||
function! s:TreeDirNode.New(path)
|
||||
if a:path.isDirectory != 1
|
||||
throw "NERDTree.InvalidArgumentsError: A TreeDirNode object must be instantiated with a directory Path object."
|
||||
endif
|
||||
|
||||
let newTreeNode = copy(self)
|
||||
let newTreeNode.path = a:path
|
||||
|
||||
let newTreeNode.isOpen = 0
|
||||
let newTreeNode.children = []
|
||||
|
||||
let newTreeNode.parent = {}
|
||||
|
||||
return newTreeNode
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.open([opts]) {{{1
|
||||
"Open the dir in the current tree or in a new tree elsewhere.
|
||||
"
|
||||
"If opening in the current tree, return the number of cached nodes.
|
||||
unlet s:TreeDirNode.open
|
||||
function! s:TreeDirNode.open(...)
|
||||
let opts = a:0 ? a:1 : {}
|
||||
|
||||
if has_key(opts, 'where') && !empty(opts['where'])
|
||||
let opener = g:NERDTreeOpener.New(self.path, opts)
|
||||
call opener.open(self)
|
||||
else
|
||||
let self.isOpen = 1
|
||||
if self.children ==# []
|
||||
return self._initChildren(0)
|
||||
else
|
||||
return 0
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.openAlong([opts]) {{{1
|
||||
"recursive open the dir if it has only one directory child.
|
||||
"
|
||||
"return the level of opened directories.
|
||||
function! s:TreeDirNode.openAlong(...)
|
||||
let opts = a:0 ? a:1 : {}
|
||||
let level = 0
|
||||
|
||||
let node = self
|
||||
while node.path.isDirectory
|
||||
call node.open(opts)
|
||||
let level += 1
|
||||
if node.getVisibleChildCount() == 1
|
||||
let node = node.getChildByIndex(0, 1)
|
||||
else
|
||||
break
|
||||
endif
|
||||
endwhile
|
||||
return level
|
||||
endfunction
|
||||
|
||||
" FUNCTION: TreeDirNode.openExplorer() {{{1
|
||||
" opens an explorer window for this node in the previous window (could be a
|
||||
" nerd tree or a netrw)
|
||||
function! s:TreeDirNode.openExplorer()
|
||||
call self.open({'where': 'p'})
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.openInNewTab(options) {{{1
|
||||
unlet s:TreeDirNode.openInNewTab
|
||||
function! s:TreeDirNode.openInNewTab(options)
|
||||
call nerdtree#deprecated('TreeDirNode.openInNewTab', 'is deprecated, use open() instead')
|
||||
call self.open({'where': 't'})
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode._openInNewTab() {{{1
|
||||
function! s:TreeDirNode._openInNewTab()
|
||||
tabnew
|
||||
call g:NERDTreeCreator.CreatePrimary(self.path.str())
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.openRecursively() {{{1
|
||||
"Opens this treenode and all of its children whose paths arent 'ignored'
|
||||
"because of the file filters.
|
||||
"
|
||||
"This method is actually a wrapper for the OpenRecursively2 method which does
|
||||
"the work.
|
||||
function! s:TreeDirNode.openRecursively()
|
||||
call self._openRecursively2(1)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode._openRecursively2() {{{1
|
||||
"Opens this all children of this treenode recursively if either:
|
||||
" *they arent filtered by file filters
|
||||
" *a:forceOpen is 1
|
||||
"
|
||||
"Args:
|
||||
"forceOpen: 1 if this node should be opened regardless of file filters
|
||||
function! s:TreeDirNode._openRecursively2(forceOpen)
|
||||
if self.path.ignore() ==# 0 || a:forceOpen
|
||||
let self.isOpen = 1
|
||||
if self.children ==# []
|
||||
call self._initChildren(1)
|
||||
endif
|
||||
|
||||
for i in self.children
|
||||
if i.path.isDirectory ==# 1
|
||||
call i._openRecursively2(0)
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.refresh() {{{1
|
||||
unlet s:TreeDirNode.refresh
|
||||
function! s:TreeDirNode.refresh()
|
||||
call self.path.refresh()
|
||||
|
||||
"if this node was ever opened, refresh its children
|
||||
if self.isOpen || !empty(self.children)
|
||||
"go thru all the files/dirs under this node
|
||||
let newChildNodes = []
|
||||
let invalidFilesFound = 0
|
||||
let dir = self.path
|
||||
let globDir = dir.str({'format': 'Glob'})
|
||||
let filesStr = globpath(globDir, '*') . "\n" . globpath(globDir, '.*')
|
||||
let files = split(filesStr, "\n")
|
||||
for i in files
|
||||
"filter out the .. and . directories
|
||||
"Note: we must match .. AND ../ cos sometimes the globpath returns
|
||||
"../ for path with strange chars (eg $)
|
||||
if i !~# '\/\.\.\/\?$' && i !~# '\/\.\/\?$'
|
||||
|
||||
try
|
||||
"create a new path and see if it exists in this nodes children
|
||||
let path = g:NERDTreePath.New(i)
|
||||
let newNode = self.getChild(path)
|
||||
if newNode != {}
|
||||
call newNode.refresh()
|
||||
call add(newChildNodes, newNode)
|
||||
|
||||
"the node doesnt exist so create it
|
||||
else
|
||||
let newNode = g:NERDTreeFileNode.New(path)
|
||||
let newNode.parent = self
|
||||
call add(newChildNodes, newNode)
|
||||
endif
|
||||
|
||||
|
||||
catch /^NERDTree.\(InvalidArguments\|InvalidFiletype\)Error/
|
||||
let invalidFilesFound = 1
|
||||
endtry
|
||||
endif
|
||||
endfor
|
||||
|
||||
"swap this nodes children out for the children we just read/refreshed
|
||||
let self.children = newChildNodes
|
||||
call self.sortChildren()
|
||||
|
||||
if invalidFilesFound
|
||||
call nerdtree#echoWarning("some files could not be loaded into the NERD tree")
|
||||
endif
|
||||
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
|
||||
function! s:TreeDirNode.reveal(path)
|
||||
if !a:path.isUnder(self.path)
|
||||
throw "NERDTree.InvalidArgumentsError: " . a:path.str() . " should be under " . self.path.str()
|
||||
endif
|
||||
|
||||
call self.open()
|
||||
|
||||
if self.path.equals(a:path.getParent())
|
||||
let n = self.findNode(a:path)
|
||||
call b:NERDTree.render()
|
||||
call n.putCursorHere(1,0)
|
||||
return
|
||||
endif
|
||||
|
||||
let p = a:path
|
||||
while !p.getParent().equals(self.path)
|
||||
let p = p.getParent()
|
||||
endwhile
|
||||
|
||||
let n = self.findNode(p)
|
||||
call n.reveal(a:path)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.removeChild(treenode) {{{1
|
||||
"
|
||||
"Removes the given treenode from this nodes set of children
|
||||
"
|
||||
"Args:
|
||||
"treenode: the node to remove
|
||||
"
|
||||
"Throws a NERDTree.ChildNotFoundError if the given treenode is not found
|
||||
function! s:TreeDirNode.removeChild(treenode)
|
||||
for i in range(0, self.getChildCount()-1)
|
||||
if self.children[i].equals(a:treenode)
|
||||
call remove(self.children, i)
|
||||
return
|
||||
endif
|
||||
endfor
|
||||
|
||||
throw "NERDTree.ChildNotFoundError: child node was not found"
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.sortChildren() {{{1
|
||||
"
|
||||
"Sorts the children of this node according to alphabetical order and the
|
||||
"directory priority.
|
||||
"
|
||||
function! s:TreeDirNode.sortChildren()
|
||||
let CompareFunc = function("nerdtree#compareNodes")
|
||||
call sort(self.children, CompareFunc)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.toggleOpen([options]) {{{1
|
||||
"Opens this directory if it is closed and vice versa
|
||||
function! s:TreeDirNode.toggleOpen(...)
|
||||
let opts = a:0 ? a:1 : {}
|
||||
if self.isOpen ==# 1
|
||||
call self.close()
|
||||
else
|
||||
if g:NERDTreeCascadeOpenSingleChildDir == 0
|
||||
call self.open(opts)
|
||||
else
|
||||
call self.openAlong(opts)
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeDirNode.transplantChild(newNode) {{{1
|
||||
"Replaces the child of this with the given node (where the child node's full
|
||||
"path matches a:newNode's fullpath). The search for the matching node is
|
||||
"non-recursive
|
||||
"
|
||||
"Arg:
|
||||
"newNode: the node to graft into the tree
|
||||
function! s:TreeDirNode.transplantChild(newNode)
|
||||
for i in range(0, self.getChildCount()-1)
|
||||
if self.children[i].equals(a:newNode)
|
||||
let self.children[i] = a:newNode
|
||||
let a:newNode.parent = self
|
||||
break
|
||||
endif
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,431 @@
|
||||
"CLASS: TreeFileNode
|
||||
"This class is the parent of the TreeDirNode class and is the
|
||||
"'Component' part of the composite design pattern between the treenode
|
||||
"classes.
|
||||
"============================================================
|
||||
let s:TreeFileNode = {}
|
||||
let g:NERDTreeFileNode = s:TreeFileNode
|
||||
|
||||
"FUNCTION: TreeFileNode.activate(...) {{{1
|
||||
function! s:TreeFileNode.activate(...)
|
||||
call self.open(a:0 ? a:1 : {})
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.bookmark(name) {{{1
|
||||
"bookmark this node with a:name
|
||||
function! s:TreeFileNode.bookmark(name)
|
||||
|
||||
"if a bookmark exists with the same name and the node is cached then save
|
||||
"it so we can update its display string
|
||||
let oldMarkedNode = {}
|
||||
try
|
||||
let oldMarkedNode = g:NERDTreeBookmark.GetNodeForName(a:name, 1)
|
||||
catch /^NERDTree.BookmarkNotFoundError/
|
||||
catch /^NERDTree.BookmarkedNodeNotFoundError/
|
||||
endtry
|
||||
|
||||
call g:NERDTreeBookmark.AddBookmark(a:name, self.path)
|
||||
call self.path.cacheDisplayString()
|
||||
call g:NERDTreeBookmark.Write()
|
||||
|
||||
if !empty(oldMarkedNode)
|
||||
call oldMarkedNode.path.cacheDisplayString()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.cacheParent() {{{1
|
||||
"initializes self.parent if it isnt already
|
||||
function! s:TreeFileNode.cacheParent()
|
||||
if empty(self.parent)
|
||||
let parentPath = self.path.getParent()
|
||||
if parentPath.equals(self.path)
|
||||
throw "NERDTree.CannotCacheParentError: already at root"
|
||||
endif
|
||||
let self.parent = s:TreeFileNode.New(parentPath)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.clearBookmarks() {{{1
|
||||
function! s:TreeFileNode.clearBookmarks()
|
||||
for i in g:NERDTreeBookmark.Bookmarks()
|
||||
if i.path.equals(self.path)
|
||||
call i.delete()
|
||||
end
|
||||
endfor
|
||||
call self.path.cacheDisplayString()
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.copy(dest) {{{1
|
||||
function! s:TreeFileNode.copy(dest)
|
||||
call self.path.copy(a:dest)
|
||||
let newPath = g:NERDTreePath.New(a:dest)
|
||||
let parent = b:NERDTreeRoot.findNode(newPath.getParent())
|
||||
if !empty(parent)
|
||||
call parent.refresh()
|
||||
return parent.findNode(newPath)
|
||||
else
|
||||
return {}
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.delete {{{1
|
||||
"Removes this node from the tree and calls the Delete method for its path obj
|
||||
function! s:TreeFileNode.delete()
|
||||
call self.path.delete()
|
||||
call self.parent.removeChild(self)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.displayString() {{{1
|
||||
"
|
||||
"Returns a string that specifies how the node should be represented as a
|
||||
"string
|
||||
"
|
||||
"Return:
|
||||
"a string that can be used in the view to represent this node
|
||||
function! s:TreeFileNode.displayString()
|
||||
return self.path.displayString()
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.equals(treenode) {{{1
|
||||
"
|
||||
"Compares this treenode to the input treenode and returns 1 if they are the
|
||||
"same node.
|
||||
"
|
||||
"Use this method instead of == because sometimes when the treenodes contain
|
||||
"many children, vim seg faults when doing ==
|
||||
"
|
||||
"Args:
|
||||
"treenode: the other treenode to compare to
|
||||
function! s:TreeFileNode.equals(treenode)
|
||||
return self.path.str() ==# a:treenode.path.str()
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.findNode(path) {{{1
|
||||
"Returns self if this node.path.Equals the given path.
|
||||
"Returns {} if not equal.
|
||||
"
|
||||
"Args:
|
||||
"path: the path object to compare against
|
||||
function! s:TreeFileNode.findNode(path)
|
||||
if a:path.equals(self.path)
|
||||
return self
|
||||
endif
|
||||
return {}
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.findOpenDirSiblingWithVisibleChildren(direction) {{{1
|
||||
"
|
||||
"Finds the next sibling for this node in the indicated direction. This sibling
|
||||
"must be a directory and may/may not have children as specified.
|
||||
"
|
||||
"Args:
|
||||
"direction: 0 if you want to find the previous sibling, 1 for the next sibling
|
||||
"
|
||||
"Return:
|
||||
"a treenode object or {} if no appropriate sibling could be found
|
||||
function! s:TreeFileNode.findOpenDirSiblingWithVisibleChildren(direction)
|
||||
"if we have no parent then we can have no siblings
|
||||
if self.parent != {}
|
||||
let nextSibling = self.findSibling(a:direction)
|
||||
|
||||
while nextSibling != {}
|
||||
if nextSibling.path.isDirectory && nextSibling.hasVisibleChildren() && nextSibling.isOpen
|
||||
return nextSibling
|
||||
endif
|
||||
let nextSibling = nextSibling.findSibling(a:direction)
|
||||
endwhile
|
||||
endif
|
||||
|
||||
return {}
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.findSibling(direction) {{{1
|
||||
"
|
||||
"Finds the next sibling for this node in the indicated direction
|
||||
"
|
||||
"Args:
|
||||
"direction: 0 if you want to find the previous sibling, 1 for the next sibling
|
||||
"
|
||||
"Return:
|
||||
"a treenode object or {} if no sibling could be found
|
||||
function! s:TreeFileNode.findSibling(direction)
|
||||
"if we have no parent then we can have no siblings
|
||||
if self.parent != {}
|
||||
|
||||
"get the index of this node in its parents children
|
||||
let siblingIndx = self.parent.getChildIndex(self.path)
|
||||
|
||||
if siblingIndx != -1
|
||||
"move a long to the next potential sibling node
|
||||
let siblingIndx = a:direction ==# 1 ? siblingIndx+1 : siblingIndx-1
|
||||
|
||||
"keep moving along to the next sibling till we find one that is valid
|
||||
let numSiblings = self.parent.getChildCount()
|
||||
while siblingIndx >= 0 && siblingIndx < numSiblings
|
||||
|
||||
"if the next node is not an ignored node (i.e. wont show up in the
|
||||
"view) then return it
|
||||
if self.parent.children[siblingIndx].path.ignore() ==# 0
|
||||
return self.parent.children[siblingIndx]
|
||||
endif
|
||||
|
||||
"go to next node
|
||||
let siblingIndx = a:direction ==# 1 ? siblingIndx+1 : siblingIndx-1
|
||||
endwhile
|
||||
endif
|
||||
endif
|
||||
|
||||
return {}
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.GetRootForTab(){{{1
|
||||
"get the root node for this tab
|
||||
function! s:TreeFileNode.GetRootForTab()
|
||||
if g:NERDTree.ExistsForTab()
|
||||
return getbufvar(t:NERDTreeBufName, 'NERDTreeRoot')
|
||||
end
|
||||
return {}
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.GetSelected() {{{1
|
||||
"gets the treenode that the cursor is currently over
|
||||
function! s:TreeFileNode.GetSelected()
|
||||
try
|
||||
let path = b:NERDTree.ui.getPath(line("."))
|
||||
if path ==# {}
|
||||
return {}
|
||||
endif
|
||||
return b:NERDTreeRoot.findNode(path)
|
||||
catch /^NERDTree/
|
||||
return {}
|
||||
endtry
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.isVisible() {{{1
|
||||
"returns 1 if this node should be visible according to the tree filters and
|
||||
"hidden file filters (and their on/off status)
|
||||
function! s:TreeFileNode.isVisible()
|
||||
return !self.path.ignore()
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.isRoot() {{{1
|
||||
"returns 1 if this node is b:NERDTreeRoot
|
||||
function! s:TreeFileNode.isRoot()
|
||||
if !g:NERDTree.ExistsForBuf()
|
||||
throw "NERDTree.NoTreeError: No tree exists for the current buffer"
|
||||
endif
|
||||
|
||||
return self.equals(b:NERDTreeRoot)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.makeRoot() {{{1
|
||||
"Make this node the root of the tree
|
||||
function! s:TreeFileNode.makeRoot()
|
||||
if self.path.isDirectory
|
||||
let b:NERDTreeRoot = self
|
||||
else
|
||||
call self.cacheParent()
|
||||
let b:NERDTreeRoot = self.parent
|
||||
endif
|
||||
|
||||
call b:NERDTreeRoot.open()
|
||||
|
||||
"change dir to the dir of the new root if instructed to
|
||||
if g:NERDTreeChDirMode ==# 2
|
||||
exec "cd " . b:NERDTreeRoot.path.str({'format': 'Edit'})
|
||||
endif
|
||||
|
||||
silent doautocmd User NERDTreeNewRoot
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.New(path) {{{1
|
||||
"Returns a new TreeNode object with the given path and parent
|
||||
"
|
||||
"Args:
|
||||
"path: a path object representing the full filesystem path to the file/dir that the node represents
|
||||
function! s:TreeFileNode.New(path)
|
||||
if a:path.isDirectory
|
||||
return g:NERDTreeDirNode.New(a:path)
|
||||
else
|
||||
let newTreeNode = copy(self)
|
||||
let newTreeNode.path = a:path
|
||||
let newTreeNode.parent = {}
|
||||
return newTreeNode
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.open() {{{1
|
||||
function! s:TreeFileNode.open(...)
|
||||
let opts = a:0 ? a:1 : {}
|
||||
let opener = g:NERDTreeOpener.New(self.path, opts)
|
||||
call opener.open(self)
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.openSplit() {{{1
|
||||
"Open this node in a new window
|
||||
function! s:TreeFileNode.openSplit()
|
||||
call nerdtree#deprecated('TreeFileNode.openSplit', 'is deprecated, use .open() instead.')
|
||||
call self.open({'where': 'h'})
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.openVSplit() {{{1
|
||||
"Open this node in a new vertical window
|
||||
function! s:TreeFileNode.openVSplit()
|
||||
call nerdtree#deprecated('TreeFileNode.openVSplit', 'is deprecated, use .open() instead.')
|
||||
call self.open({'where': 'v'})
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.openInNewTab(options) {{{1
|
||||
function! s:TreeFileNode.openInNewTab(options)
|
||||
echomsg 'TreeFileNode.openInNewTab is deprecated'
|
||||
call self.open(extend({'where': 't'}, a:options))
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.putCursorHere(isJump, recurseUpward){{{1
|
||||
"Places the cursor on the line number this node is rendered on
|
||||
"
|
||||
"Args:
|
||||
"isJump: 1 if this cursor movement should be counted as a jump by vim
|
||||
"recurseUpward: try to put the cursor on the parent if the this node isnt
|
||||
"visible
|
||||
function! s:TreeFileNode.putCursorHere(isJump, recurseUpward)
|
||||
let ln = b:NERDTree.ui.getLineNum(self)
|
||||
if ln != -1
|
||||
if a:isJump
|
||||
mark '
|
||||
endif
|
||||
call cursor(ln, col("."))
|
||||
else
|
||||
if a:recurseUpward
|
||||
let node = self
|
||||
while node != {} && b:NERDTree.ui.getLineNum(node) ==# -1
|
||||
let node = node.parent
|
||||
call node.open()
|
||||
endwhile
|
||||
call b:NERDTree.render()
|
||||
call node.putCursorHere(a:isJump, 0)
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.refresh() {{{1
|
||||
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)
|
||||
let newName = substitute(a:newName, '\(\\\|\/\)$', '', '')
|
||||
call self.path.rename(newName)
|
||||
call self.parent.removeChild(self)
|
||||
|
||||
let parentPath = self.path.getParent()
|
||||
let newParent = b:NERDTreeRoot.findNode(parentPath)
|
||||
|
||||
if newParent != {}
|
||||
call newParent.createChild(self.path, 1)
|
||||
call newParent.refresh()
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: TreeFileNode.renderToString {{{1
|
||||
"returns a string representation for this tree to be rendered in the view
|
||||
function! s:TreeFileNode.renderToString()
|
||||
return self._renderToString(0, 0, [], self.getChildCount() ==# 1)
|
||||
endfunction
|
||||
|
||||
"Args:
|
||||
"depth: the current depth in the tree for this call
|
||||
"drawText: 1 if we should actually draw the line for this node (if 0 then the
|
||||
"child nodes are rendered only)
|
||||
"vertMap: a binary array that indicates whether a vertical bar should be draw
|
||||
"for each depth in the tree
|
||||
"isLastChild:true if this curNode is the last child of its parent
|
||||
function! s:TreeFileNode._renderToString(depth, drawText, vertMap, isLastChild)
|
||||
let output = ""
|
||||
if a:drawText ==# 1
|
||||
|
||||
let treeParts = ''
|
||||
|
||||
"get all the leading spaces and vertical tree parts for this line
|
||||
if a:depth > 1
|
||||
for j in a:vertMap[0:-2]
|
||||
if g:NERDTreeDirArrows
|
||||
let treeParts = treeParts . ' '
|
||||
else
|
||||
if j ==# 1
|
||||
let treeParts = treeParts . '| '
|
||||
else
|
||||
let treeParts = treeParts . ' '
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
|
||||
"get the last vertical tree part for this line which will be different
|
||||
"if this node is the last child of its parent
|
||||
if !g:NERDTreeDirArrows
|
||||
if a:isLastChild
|
||||
let treeParts = treeParts . '`'
|
||||
else
|
||||
let treeParts = treeParts . '|'
|
||||
endif
|
||||
endif
|
||||
|
||||
"smack the appropriate dir/file symbol on the line before the file/dir
|
||||
"name itself
|
||||
if self.path.isDirectory
|
||||
if self.isOpen
|
||||
if g:NERDTreeDirArrows
|
||||
let treeParts = treeParts . '▾ '
|
||||
else
|
||||
let treeParts = treeParts . '~'
|
||||
endif
|
||||
else
|
||||
if g:NERDTreeDirArrows
|
||||
let treeParts = treeParts . '▸ '
|
||||
else
|
||||
let treeParts = treeParts . '+'
|
||||
endif
|
||||
endif
|
||||
else
|
||||
if g:NERDTreeDirArrows
|
||||
let treeParts = treeParts . ' '
|
||||
else
|
||||
let treeParts = treeParts . '-'
|
||||
endif
|
||||
endif
|
||||
let line = treeParts . self.displayString()
|
||||
|
||||
let output = output . line . "\n"
|
||||
endif
|
||||
|
||||
"if the node is an open dir, draw its children
|
||||
if self.path.isDirectory ==# 1 && self.isOpen ==# 1
|
||||
|
||||
let childNodesToDraw = self.getVisibleChildren()
|
||||
if len(childNodesToDraw) > 0
|
||||
|
||||
"draw all the nodes children except the last
|
||||
let lastIndx = len(childNodesToDraw)-1
|
||||
if lastIndx > 0
|
||||
for i in childNodesToDraw[0:lastIndx-1]
|
||||
let output = output . i._renderToString(a:depth + 1, 1, add(copy(a:vertMap), 1), 0)
|
||||
endfor
|
||||
endif
|
||||
|
||||
"draw the last child, indicating that it IS the last
|
||||
let output = output . childNodesToDraw[lastIndx]._renderToString(a:depth + 1, 1, add(copy(a:vertMap), 0), 1)
|
||||
endif
|
||||
endif
|
||||
|
||||
return output
|
||||
endfunction
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,506 @@
|
||||
"CLASS: UI
|
||||
"============================================================
|
||||
let s:UI = {}
|
||||
let g:NERDTreeUI = s:UI
|
||||
|
||||
"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(g:NERDTree.GetWinNum()) - current_line
|
||||
if lines_to_top < g:NERDTreeAutoCenterThreshold || lines_to_bottom < g:NERDTreeAutoCenterThreshold
|
||||
normal! zz
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:UI._dumpHelp {{{1
|
||||
"prints out the quick help
|
||||
function! s:UI._dumpHelp()
|
||||
let old_h = @h
|
||||
if b:treeShowHelp ==# 1
|
||||
let @h= "\" NERD tree (" . nerdtree#version() . ") quickhelp~\n"
|
||||
let @h=@h."\" ============================\n"
|
||||
let @h=@h."\" File node mappings~\n"
|
||||
let @h=@h."\" ". (g:NERDTreeMouseMode ==# 3 ? "single" : "double") ."-click,\n"
|
||||
let @h=@h."\" <CR>,\n"
|
||||
if b:NERDTreeType ==# "primary"
|
||||
let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in prev window\n"
|
||||
else
|
||||
let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in current window\n"
|
||||
endif
|
||||
if b:NERDTreeType ==# "primary"
|
||||
let @h=@h."\" ". g:NERDTreeMapPreview .": preview\n"
|
||||
endif
|
||||
let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
|
||||
let @h=@h."\" middle-click,\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapOpenSplit .": open split\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapPreviewSplit .": preview split\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapOpenVSplit .": open vsplit\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapPreviewVSplit .": preview vsplit\n"
|
||||
|
||||
let @h=@h."\"\n\" ----------------------------\n"
|
||||
let @h=@h."\" Directory node mappings~\n"
|
||||
let @h=@h."\" ". (g:NERDTreeMouseMode ==# 1 ? "double" : "single") ."-click,\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapActivateNode .": open & close node\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapOpenRecursively .": recursively open node\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapCloseDir .": close parent of node\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapCloseChildren .": close all child nodes of\n"
|
||||
let @h=@h."\" current node recursively\n"
|
||||
let @h=@h."\" middle-click,\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapOpenExpl.": explore selected dir\n"
|
||||
|
||||
let @h=@h."\"\n\" ----------------------------\n"
|
||||
let @h=@h."\" Bookmark table mappings~\n"
|
||||
let @h=@h."\" double-click,\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapActivateNode .": open bookmark\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapDeleteBookmark .": delete bookmark\n"
|
||||
|
||||
let @h=@h."\"\n\" ----------------------------\n"
|
||||
let @h=@h."\" Tree navigation mappings~\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapJumpRoot .": go to root\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapJumpParent .": go to parent\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapJumpFirstChild .": go to first child\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapJumpLastChild .": go to last child\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapJumpNextSibling .": go to next sibling\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapJumpPrevSibling .": go to prev sibling\n"
|
||||
|
||||
let @h=@h."\"\n\" ----------------------------\n"
|
||||
let @h=@h."\" Filesystem mappings~\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapChangeRoot .": change tree root to the\n"
|
||||
let @h=@h."\" selected dir\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapUpdir .": move tree root up a dir\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapUpdirKeepOpen .": move tree root up a dir\n"
|
||||
let @h=@h."\" but leave old root open\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapRefresh .": refresh cursor dir\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapRefreshRoot .": refresh current root\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapMenu .": Show menu\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapChdir .":change the CWD to the\n"
|
||||
let @h=@h."\" selected dir\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapCWD .":change tree root to CWD\n"
|
||||
|
||||
let @h=@h."\"\n\" ----------------------------\n"
|
||||
let @h=@h."\" Tree filtering mappings~\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapToggleHidden .": hidden files (" . (b:NERDTreeShowHidden ? "on" : "off") . ")\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapToggleFilters .": file filters (" . (b:NERDTreeIgnoreEnabled ? "on" : "off") . ")\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapToggleFiles .": files (" . (b:NERDTreeShowFiles ? "on" : "off") . ")\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapToggleBookmarks .": bookmarks (" . (b:NERDTreeShowBookmarks ? "on" : "off") . ")\n"
|
||||
|
||||
"add quickhelp entries for each custom key map
|
||||
let @h=@h."\"\n\" ----------------------------\n"
|
||||
let @h=@h."\" Custom mappings~\n"
|
||||
for i in g:NERDTreeKeyMap.All()
|
||||
if !empty(i.quickhelpText)
|
||||
let @h=@h."\" ". i.key .": ". i.quickhelpText ."\n"
|
||||
endif
|
||||
endfor
|
||||
|
||||
let @h=@h."\"\n\" ----------------------------\n"
|
||||
let @h=@h."\" Other mappings~\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapQuit .": Close the NERDTree window\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapToggleZoom .": Zoom (maximize-minimize)\n"
|
||||
let @h=@h."\" the NERDTree window\n"
|
||||
let @h=@h."\" ". g:NERDTreeMapHelp .": toggle help\n"
|
||||
let @h=@h."\"\n\" ----------------------------\n"
|
||||
let @h=@h."\" Bookmark commands~\n"
|
||||
let @h=@h."\" :Bookmark [<name>]\n"
|
||||
let @h=@h."\" :BookmarkToRoot <name>\n"
|
||||
let @h=@h."\" :RevealBookmark <name>\n"
|
||||
let @h=@h."\" :OpenBookmark <name>\n"
|
||||
let @h=@h."\" :ClearBookmarks [<names>]\n"
|
||||
let @h=@h."\" :ClearAllBookmarks\n"
|
||||
silent! put h
|
||||
elseif g:NERDTreeMinimalUI == 0
|
||||
let @h="\" Press ". g:NERDTreeMapHelp ." for help\n"
|
||||
silent! put h
|
||||
endif
|
||||
|
||||
let @h = old_h
|
||||
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 ==# s:UI.UpDirLine()
|
||||
return b:NERDTreeRoot.path.getParent()
|
||||
endif
|
||||
|
||||
let indent = self._indentLevelFor(line)
|
||||
|
||||
"remove the tree parts and the leading space
|
||||
let curFile = self._stripMarkup(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 = self._stripMarkup(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 = self._stripMarkup(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) {{{1
|
||||
function! s:UI._indentLevelFor(line)
|
||||
let level = match(a:line, '[^ \-+~▸▾`|]') / s:UI.IndentWid()
|
||||
" 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.IndentWid() {{{1
|
||||
function! s:UI.IndentWid()
|
||||
return 2
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:UI.MarkupReg() {{{1
|
||||
function! s:UI.MarkupReg()
|
||||
if g:NERDTreeDirArrows
|
||||
return '^\([▾▸] \| \+[▾▸] \| \+\)'
|
||||
endif
|
||||
|
||||
return '^[ `|]*[\-+~]'
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:UI._renderBookmarks {{{1
|
||||
function! s:UI._renderBookmarks()
|
||||
|
||||
if g:NERDTreeMinimalUI == 0
|
||||
call setline(line(".")+1, ">----------Bookmarks----------")
|
||||
call cursor(line(".")+1, col("."))
|
||||
endif
|
||||
|
||||
for i in g:NERDTreeBookmark.Bookmarks()
|
||||
call setline(line(".")+1, i.str())
|
||||
call cursor(line(".")+1, col("."))
|
||||
endfor
|
||||
|
||||
call setline(line(".")+1, '')
|
||||
call cursor(line(".")+1, col("."))
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:UI.restoreScreenState() {{{1
|
||||
"
|
||||
"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() {{{1
|
||||
"Saves the current cursor position in the current buffer and the window
|
||||
"scroll position
|
||||
function! s:UI.saveScreenState()
|
||||
let win = winnr()
|
||||
call g:NERDTree.CursorToTreeWin()
|
||||
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")
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:UI._stripMarkup(line, removeLeadingSpaces){{{1
|
||||
"returns the given line with all the tree parts stripped off
|
||||
"
|
||||
"Args:
|
||||
"line: the subject line
|
||||
"removeLeadingSpaces: 1 if leading spaces are to be removed (leading spaces =
|
||||
"any spaces before the actual text of the node)
|
||||
function! s:UI._stripMarkup(line, removeLeadingSpaces)
|
||||
let line = a:line
|
||||
"remove the tree parts and the leading space
|
||||
let line = substitute (line, g:NERDTreeUI.MarkupReg(),"","")
|
||||
|
||||
"strip off any read only flag
|
||||
let line = substitute (line, ' \[RO\]', "","")
|
||||
|
||||
"strip off any bookmark flags
|
||||
let line = substitute (line, ' {[^}]*}', "","")
|
||||
|
||||
"strip off any executable flags
|
||||
let line = substitute (line, '*\ze\($\| \)', "","")
|
||||
|
||||
"strip off any generic flags
|
||||
let line = substitute (line, '\[[^]]*\]', "","")
|
||||
|
||||
let wasdir = 0
|
||||
if line =~# '/$'
|
||||
let wasdir = 1
|
||||
endif
|
||||
let line = substitute (line,' -> .*',"","") " remove link to
|
||||
if wasdir ==# 1
|
||||
let line = substitute (line, '/\?$', '/', "")
|
||||
endif
|
||||
|
||||
if a:removeLeadingSpaces
|
||||
let line = substitute (line, '^ *', '', '')
|
||||
endif
|
||||
|
||||
return line
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:UI.render() {{{1
|
||||
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 self._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 self._renderBookmarks()
|
||||
endif
|
||||
|
||||
"add the 'up a dir' line
|
||||
if !g:NERDTreeMinimalUI
|
||||
call setline(line(".")+1, s:UI.UpDirLine())
|
||||
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 g:NERDTree.CursorToBookmarkTable()
|
||||
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
|
||||
|
||||
"FUNCTION: s:UI.UpDirLine() {{{1
|
||||
function! s:UI.UpDirLine()
|
||||
return '.. (up a dir)'
|
||||
endfunction
|
||||
@ -0,0 +1,41 @@
|
||||
" ============================================================================
|
||||
" File: exec_menuitem.vim
|
||||
" Description: plugin for NERD Tree that provides an execute file menu item
|
||||
" Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
" Last Change: 22 July, 2009
|
||||
" 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_nerdtree_exec_menuitem")
|
||||
finish
|
||||
endif
|
||||
let g:loaded_nerdtree_exec_menuitem = 1
|
||||
|
||||
call NERDTreeAddMenuItem({
|
||||
\ 'text': '(!)Execute file',
|
||||
\ 'shortcut': '!',
|
||||
\ 'callback': 'NERDTreeExecFile',
|
||||
\ 'isActiveCallback': 'NERDTreeExecFileActive' })
|
||||
|
||||
function! NERDTreeExecFileActive()
|
||||
let node = g:NERDTreeFileNode.GetSelected()
|
||||
return !node.path.isDirectory && node.path.isExecutable
|
||||
endfunction
|
||||
|
||||
function! NERDTreeExecFile()
|
||||
let treenode = g:NERDTreeFileNode.GetSelected()
|
||||
echo "==========================================================\n"
|
||||
echo "Complete the command to execute (add arguments etc):\n"
|
||||
let cmd = treenode.path.str({'escape': 1})
|
||||
let cmd = input(':!', cmd . ' ')
|
||||
|
||||
if cmd != ''
|
||||
exec ':!' . cmd
|
||||
else
|
||||
echo "Aborted"
|
||||
endif
|
||||
endfunction
|
||||
@ -0,0 +1,270 @@
|
||||
" ============================================================================
|
||||
" File: fs_menu.vim
|
||||
" Description: plugin for the NERD Tree that provides a file system menu
|
||||
" Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
" Last Change: 17 July, 2009
|
||||
" 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_nerdtree_fs_menu")
|
||||
finish
|
||||
endif
|
||||
let g:loaded_nerdtree_fs_menu = 1
|
||||
|
||||
"Automatically delete the buffer after deleting or renaming a file
|
||||
if !exists("g:NERDTreeAutoDeleteBuffer")
|
||||
let g:NERDTreeAutoDeleteBuffer = 0
|
||||
endif
|
||||
|
||||
call NERDTreeAddMenuItem({'text': '(a)dd a childnode', 'shortcut': 'a', 'callback': 'NERDTreeAddNode'})
|
||||
call NERDTreeAddMenuItem({'text': '(m)ove the current node', 'shortcut': 'm', 'callback': 'NERDTreeMoveNode'})
|
||||
call NERDTreeAddMenuItem({'text': '(d)elete the current node', 'shortcut': 'd', 'callback': 'NERDTreeDeleteNode'})
|
||||
|
||||
if has("gui_mac") || has("gui_macvim")
|
||||
call NERDTreeAddMenuItem({'text': '(r)eveal in Finder the current node', 'shortcut': 'r', 'callback': 'NERDTreeRevealInFinder'})
|
||||
call NERDTreeAddMenuItem({'text': '(o)pen the current node with system editor', 'shortcut': 'o', 'callback': 'NERDTreeExecuteFile'})
|
||||
call NERDTreeAddMenuItem({'text': '(q)uicklook the current node', 'shortcut': 'q', 'callback': 'NERDTreeQuickLook'})
|
||||
endif
|
||||
|
||||
if g:NERDTreePath.CopyingSupported()
|
||||
call NERDTreeAddMenuItem({'text': '(c)opy the current node', 'shortcut': 'c', 'callback': 'NERDTreeCopyNode'})
|
||||
endif
|
||||
|
||||
"FUNCTION: s:echo(msg){{{1
|
||||
function! s:echo(msg)
|
||||
redraw
|
||||
echomsg "NERDTree: " . a:msg
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:echoWarning(msg){{{1
|
||||
function! s:echoWarning(msg)
|
||||
echohl warningmsg
|
||||
call s:echo(a:msg)
|
||||
echohl normal
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:promptToDelBuffer(bufnum, msg){{{1
|
||||
"prints out the given msg and, if the user responds by pushing 'y' then the
|
||||
"buffer with the given bufnum is deleted
|
||||
"
|
||||
"Args:
|
||||
"bufnum: the buffer that may be deleted
|
||||
"msg: a message that will be echoed to the user asking them if they wish to
|
||||
" del the buffer
|
||||
function! s:promptToDelBuffer(bufnum, msg)
|
||||
echo a:msg
|
||||
if g:NERDTreeAutoDeleteBuffer || nr2char(getchar()) ==# 'y'
|
||||
" 1. ensure that all windows which display the just deleted filename
|
||||
" now display an empty buffer (so a layout is preserved).
|
||||
" Is not it better to close single tabs with this file only ?
|
||||
let s:originalTabNumber = tabpagenr()
|
||||
let s:originalWindowNumber = winnr()
|
||||
exec "tabdo windo if winbufnr(0) == " . a:bufnum . " | exec ':enew! ' | endif"
|
||||
exec "tabnext " . s:originalTabNumber
|
||||
exec s:originalWindowNumber . "wincmd w"
|
||||
" 3. We don't need a previous buffer anymore
|
||||
exec "bwipeout! " . a:bufnum
|
||||
endif
|
||||
endfunction
|
||||
|
||||
"FUNCTION: s:promptToRenameBuffer(bufnum, msg){{{1
|
||||
"prints out the given msg and, if the user responds by pushing 'y' then the
|
||||
"buffer with the given bufnum is replaced with a new one
|
||||
"
|
||||
"Args:
|
||||
"bufnum: the buffer that may be deleted
|
||||
"msg: a message that will be echoed to the user asking them if they wish to
|
||||
" del the buffer
|
||||
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 " . 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()
|
||||
let editStr = g:NERDTreePath.New(a:newFileName).str({'format': 'Edit'})
|
||||
exec "tabdo windo if winbufnr(0) == " . a:bufnum . " | exec ':e! " . editStr . "' | endif"
|
||||
exec "tabnext " . s:originalTabNumber
|
||||
exec s:originalWindowNumber . "wincmd w"
|
||||
" 3. We don't need a previous buffer anymore
|
||||
exec "bwipeout! " . a:bufnum
|
||||
endif
|
||||
endfunction
|
||||
"FUNCTION: NERDTreeAddNode(){{{1
|
||||
function! NERDTreeAddNode()
|
||||
let curDirNode = g:NERDTreeDirNode.GetSelected()
|
||||
|
||||
let newNodeName = input("Add a childnode\n".
|
||||
\ "==========================================================\n".
|
||||
\ "Enter the dir/file name to be created. Dirs end with a '/'\n" .
|
||||
\ "", curDirNode.path.str() . g:NERDTreePath.Slash(), "file")
|
||||
|
||||
if newNodeName ==# ''
|
||||
call s:echo("Node Creation Aborted.")
|
||||
return
|
||||
endif
|
||||
|
||||
try
|
||||
let newPath = g:NERDTreePath.Create(newNodeName)
|
||||
let parentNode = b:NERDTreeRoot.findNode(newPath.getParent())
|
||||
|
||||
let newTreeNode = g:NERDTreeFileNode.New(newPath)
|
||||
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)
|
||||
endif
|
||||
catch /^NERDTree/
|
||||
call s:echoWarning("Node Not Created.")
|
||||
endtry
|
||||
endfunction
|
||||
|
||||
"FUNCTION: NERDTreeMoveNode(){{{1
|
||||
function! NERDTreeMoveNode()
|
||||
let curNode = g:NERDTreeFileNode.GetSelected()
|
||||
let newNodePath = input("Rename the current node\n" .
|
||||
\ "==========================================================\n" .
|
||||
\ "Enter the new path for the node: \n" .
|
||||
\ "", curNode.path.str(), "file")
|
||||
|
||||
if newNodePath ==# ''
|
||||
call s:echo("Node Renaming Aborted.")
|
||||
return
|
||||
endif
|
||||
|
||||
try
|
||||
let bufnum = bufnr("^".curNode.path.str()."$")
|
||||
|
||||
call curNode.rename(newNodePath)
|
||||
call NERDTreeRender()
|
||||
|
||||
"if the node is open in a buffer, ask the user if they want to
|
||||
"close that buffer
|
||||
if bufnum != -1
|
||||
let prompt = "\nNode renamed.\n\nThe old file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Replace this buffer with a new file? (yN)"
|
||||
call s:promptToRenameBuffer(bufnum, prompt, newNodePath)
|
||||
endif
|
||||
|
||||
call curNode.putCursorHere(1, 0)
|
||||
|
||||
redraw
|
||||
catch /^NERDTree/
|
||||
call s:echoWarning("Node Not Renamed.")
|
||||
endtry
|
||||
endfunction
|
||||
|
||||
" FUNCTION: NERDTreeDeleteNode() {{{1
|
||||
function! NERDTreeDeleteNode()
|
||||
let currentNode = g:NERDTreeFileNode.GetSelected()
|
||||
let confirmed = 0
|
||||
|
||||
if currentNode.path.isDirectory
|
||||
let choice =input("Delete the current node\n" .
|
||||
\ "==========================================================\n" .
|
||||
\ "STOP! To delete this entire directory, type 'yes'\n" .
|
||||
\ "" . currentNode.path.str() . ": ")
|
||||
let confirmed = choice ==# 'yes'
|
||||
else
|
||||
echo "Delete the current node\n" .
|
||||
\ "==========================================================\n".
|
||||
\ "Are you sure you wish to delete the node:\n" .
|
||||
\ "" . currentNode.path.str() . " (yN):"
|
||||
let choice = nr2char(getchar())
|
||||
let confirmed = choice ==# 'y'
|
||||
endif
|
||||
|
||||
|
||||
if confirmed
|
||||
try
|
||||
call currentNode.delete()
|
||||
call NERDTreeRender()
|
||||
|
||||
"if the node is open in a buffer, ask the user if they want to
|
||||
"close that buffer
|
||||
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)
|
||||
endif
|
||||
|
||||
redraw
|
||||
catch /^NERDTree/
|
||||
call s:echoWarning("Could not remove node")
|
||||
endtry
|
||||
else
|
||||
call s:echo("delete aborted")
|
||||
endif
|
||||
|
||||
endfunction
|
||||
|
||||
" FUNCTION: NERDTreeCopyNode() {{{1
|
||||
function! NERDTreeCopyNode()
|
||||
let currentNode = g:NERDTreeFileNode.GetSelected()
|
||||
let newNodePath = input("Copy the current node\n" .
|
||||
\ "==========================================================\n" .
|
||||
\ "Enter the new path to copy the node to: \n" .
|
||||
\ "", currentNode.path.str(), "file")
|
||||
|
||||
if newNodePath != ""
|
||||
"strip trailing slash
|
||||
let newNodePath = substitute(newNodePath, '\/$', '', '')
|
||||
|
||||
let confirmed = 1
|
||||
if currentNode.path.copyingWillOverwrite(newNodePath)
|
||||
call s:echo("Warning: copying may overwrite files! Continue? (yN)")
|
||||
let choice = nr2char(getchar())
|
||||
let confirmed = choice ==# 'y'
|
||||
endif
|
||||
|
||||
if confirmed
|
||||
try
|
||||
let newNode = currentNode.copy(newNodePath)
|
||||
if empty(newNode)
|
||||
call b:NERDTreeRoot.refresh()
|
||||
call b:NERDTree.render()
|
||||
else
|
||||
call NERDTreeRender()
|
||||
call newNode.putCursorHere(0, 0)
|
||||
endif
|
||||
catch /^NERDTree/
|
||||
call s:echoWarning("Could not copy node")
|
||||
endtry
|
||||
endif
|
||||
else
|
||||
call s:echo("Copy aborted.")
|
||||
endif
|
||||
redraw
|
||||
endfunction
|
||||
|
||||
function! NERDTreeQuickLook()
|
||||
let treenode = g:NERDTreeFileNode.GetSelected()
|
||||
if treenode != {}
|
||||
call system("qlmanage -p 2>/dev/null '" . treenode.path.str() . "'")
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! NERDTreeRevealInFinder()
|
||||
let treenode = g:NERDTreeFileNode.GetSelected()
|
||||
if treenode != {}
|
||||
let x = system("open -R '" . treenode.path.str() . "'")
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! NERDTreeExecuteFile()
|
||||
let treenode = g:NERDTreeFileNode.GetSelected()
|
||||
if treenode != {}
|
||||
let x = system("open '" . treenode.path.str() . "'")
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,210 @@
|
||||
" ============================================================================
|
||||
" File: NERD_tree.vim
|
||||
" Description: vim global plugin that provides a nice tree explorer
|
||||
" Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
" Last Change: 28 December, 2011
|
||||
" License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
" ============================================================================
|
||||
"
|
||||
" SECTION: Script init stuff {{{1
|
||||
"============================================================
|
||||
if exists("loaded_nerd_tree")
|
||||
finish
|
||||
endif
|
||||
if v:version < 700
|
||||
echoerr "NERDTree: this plugin requires vim >= 7. DOWNLOAD IT! You'll thank me later!"
|
||||
finish
|
||||
endif
|
||||
let loaded_nerd_tree = 1
|
||||
|
||||
"for line continuation - i.e dont want C in &cpo
|
||||
let s:old_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
"Function: s:initVariable() function {{{2
|
||||
"This function is used to initialise a given variable to a given value. The
|
||||
"variable is only initialised if it does not exist prior
|
||||
"
|
||||
"Args:
|
||||
"var: the name of the var to be initialised
|
||||
"value: the value to initialise var to
|
||||
"
|
||||
"Returns:
|
||||
"1 if the var is set, 0 otherwise
|
||||
function! s:initVariable(var, value)
|
||||
if !exists(a:var)
|
||||
exec 'let ' . a:var . ' = ' . "'" . substitute(a:value, "'", "''", "g") . "'"
|
||||
return 1
|
||||
endif
|
||||
return 0
|
||||
endfunction
|
||||
|
||||
"SECTION: Init variable calls and other random constants {{{2
|
||||
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:NERDTreeCascadeOpenSingleChildDir", 1)
|
||||
|
||||
if !exists("g:NERDTreeSortOrder")
|
||||
let g:NERDTreeSortOrder = ['\/$', '*', '\.swp$', '\.bak$', '\~$']
|
||||
else
|
||||
"if there isnt a * in the sort sequence then add one
|
||||
if count(g:NERDTreeSortOrder, '*') < 1
|
||||
call add(g:NERDTreeSortOrder, '*')
|
||||
endif
|
||||
endif
|
||||
|
||||
if !exists('g:NERDTreeStatusline')
|
||||
|
||||
"the exists() crap here is a hack to stop vim spazzing out when
|
||||
"loading a session that was created with an open nerd tree. It spazzes
|
||||
"because it doesnt store b:NERDTreeRoot (its a b: var, and its a hash)
|
||||
let g:NERDTreeStatusline = "%{exists('b:NERDTreeRoot')?b:NERDTreeRoot.path.str():''}"
|
||||
|
||||
endif
|
||||
call s:initVariable("g:NERDTreeWinPos", "left")
|
||||
call s:initVariable("g:NERDTreeWinSize", 31)
|
||||
|
||||
"init the shell commands that will be used to copy nodes, and remove dir trees
|
||||
"
|
||||
"Note: the space after the command is important
|
||||
if nerdtree#runningWindows()
|
||||
call s:initVariable("g:NERDTreeRemoveDirCmd", 'rmdir /s /q ')
|
||||
else
|
||||
call s:initVariable("g:NERDTreeRemoveDirCmd", 'rm -rf ')
|
||||
call s:initVariable("g:NERDTreeCopyCmd", 'cp -r ')
|
||||
endif
|
||||
|
||||
|
||||
"SECTION: Init variable calls for key mappings {{{2
|
||||
call s:initVariable("g:NERDTreeMapActivateNode", "o")
|
||||
call s:initVariable("g:NERDTreeMapChangeRoot", "C")
|
||||
call s:initVariable("g:NERDTreeMapChdir", "cd")
|
||||
call s:initVariable("g:NERDTreeMapCloseChildren", "X")
|
||||
call s:initVariable("g:NERDTreeMapCloseDir", "x")
|
||||
call s:initVariable("g:NERDTreeMapDeleteBookmark", "D")
|
||||
call s:initVariable("g:NERDTreeMapMenu", "m")
|
||||
call s:initVariable("g:NERDTreeMapHelp", "?")
|
||||
call s:initVariable("g:NERDTreeMapJumpFirstChild", "K")
|
||||
call s:initVariable("g:NERDTreeMapJumpLastChild", "J")
|
||||
call s:initVariable("g:NERDTreeMapJumpNextSibling", "<C-j>")
|
||||
call s:initVariable("g:NERDTreeMapJumpParent", "p")
|
||||
call s:initVariable("g:NERDTreeMapJumpPrevSibling", "<C-k>")
|
||||
call s:initVariable("g:NERDTreeMapJumpRoot", "P")
|
||||
call s:initVariable("g:NERDTreeMapOpenExpl", "e")
|
||||
call s:initVariable("g:NERDTreeMapOpenInTab", "t")
|
||||
call s:initVariable("g:NERDTreeMapOpenInTabSilent", "T")
|
||||
call s:initVariable("g:NERDTreeMapOpenRecursively", "O")
|
||||
call s:initVariable("g:NERDTreeMapOpenSplit", "i")
|
||||
call s:initVariable("g:NERDTreeMapOpenVSplit", "s")
|
||||
call s:initVariable("g:NERDTreeMapPreview", "g" . NERDTreeMapActivateNode)
|
||||
call s:initVariable("g:NERDTreeMapPreviewSplit", "g" . NERDTreeMapOpenSplit)
|
||||
call s:initVariable("g:NERDTreeMapPreviewVSplit", "g" . NERDTreeMapOpenVSplit)
|
||||
call s:initVariable("g:NERDTreeMapQuit", "q")
|
||||
call s:initVariable("g:NERDTreeMapRefresh", "r")
|
||||
call s:initVariable("g:NERDTreeMapRefreshRoot", "R")
|
||||
call s:initVariable("g:NERDTreeMapToggleBookmarks", "B")
|
||||
call s:initVariable("g:NERDTreeMapToggleFiles", "F")
|
||||
call s:initVariable("g:NERDTreeMapToggleFilters", "f")
|
||||
call s:initVariable("g:NERDTreeMapToggleHidden", "I")
|
||||
call s:initVariable("g:NERDTreeMapToggleZoom", "A")
|
||||
call s:initVariable("g:NERDTreeMapUpdir", "u")
|
||||
call s:initVariable("g:NERDTreeMapUpdirKeepOpen", "U")
|
||||
call s:initVariable("g:NERDTreeMapCWD", "CD")
|
||||
|
||||
"SECTION: Load class files{{{2
|
||||
call nerdtree#loadClassFiles()
|
||||
|
||||
" SECTION: Commands {{{1
|
||||
"============================================================
|
||||
call nerdtree#ui_glue#setupCommands()
|
||||
|
||||
" SECTION: Auto commands {{{1
|
||||
"============================================================
|
||||
augroup NERDTree
|
||||
"Save the cursor position whenever we close the nerd tree
|
||||
exec "autocmd BufLeave ". g:NERDTreeCreator.BufNamePrefix() ."* if g:NERDTree.IsOpen() | call b:NERDTree.ui.saveScreenState() | endif"
|
||||
|
||||
"disallow insert mode in the NERDTree
|
||||
exec "autocmd BufEnter ". g:NERDTreeCreator.BufNamePrefix() ."* stopinsert"
|
||||
augroup END
|
||||
|
||||
if g:NERDTreeHijackNetrw
|
||||
augroup NERDTreeHijackNetrw
|
||||
autocmd VimEnter * silent! autocmd! FileExplorer
|
||||
au BufEnter,VimEnter * call nerdtree#checkForBrowse(expand("<amatch>"))
|
||||
augroup END
|
||||
endif
|
||||
|
||||
" SECTION: Public API {{{1
|
||||
"============================================================
|
||||
function! NERDTreeAddMenuItem(options)
|
||||
call g:NERDTreeMenuItem.Create(a:options)
|
||||
endfunction
|
||||
|
||||
function! NERDTreeAddMenuSeparator(...)
|
||||
let opts = a:0 ? a:1 : {}
|
||||
call g:NERDTreeMenuItem.CreateSeparator(opts)
|
||||
endfunction
|
||||
|
||||
function! NERDTreeAddSubmenu(options)
|
||||
return g:NERDTreeMenuItem.Create(a:options)
|
||||
endfunction
|
||||
|
||||
function! NERDTreeAddKeyMap(options)
|
||||
call g:NERDTreeKeyMap.Create(a:options)
|
||||
endfunction
|
||||
|
||||
function! NERDTreeRender()
|
||||
call nerdtree#renderView()
|
||||
endfunction
|
||||
|
||||
function! NERDTreeFocus()
|
||||
if g:NERDTree.IsOpen()
|
||||
call g:NERDTree.CursorToTreeWin()
|
||||
else
|
||||
call g:NERDTreeCreator.TogglePrimary("")
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! NERDTreeCWD()
|
||||
call NERDTreeFocus()
|
||||
call nerdtree#ui_glue#chRootCwd()
|
||||
endfunction
|
||||
|
||||
function! NERDTreeAddPathFilter(callback)
|
||||
call g:NERDTree.AddPathFilter(a:callback)
|
||||
endfunction
|
||||
|
||||
" SECTION: Post Source Actions {{{1
|
||||
call nerdtree#postSourceActions()
|
||||
|
||||
"reset &cpo back to users setting
|
||||
let &cpo = s:old_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,105 @@
|
||||
let s:tree_up_dir_line = '.. (up a dir)'
|
||||
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 ."#"
|
||||
|
||||
"quickhelp syntax elements
|
||||
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,NERDTreeIgnore,NERDTreeToggleOff,NERDTreeToggleOn,NERDTreeHelpCommand
|
||||
|
||||
"highlighting for sym links
|
||||
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 #/# 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
|
||||
syn match NERDTreeBookmark # {.*}#hs=s+1
|
||||
|
||||
"highlighting for the bookmarks table
|
||||
syn match NERDTreeBookmarksLeader #^>#
|
||||
syn match NERDTreeBookmarksHeader #^>-\+Bookmarks-\+$# contains=NERDTreeBookmarksLeader
|
||||
syn match NERDTreeBookmarkName #^>.\{-} #he=e-1 contains=NERDTreeBookmarksLeader
|
||||
syn match NERDTreeBookmark #^>.*$# contains=NERDTreeBookmarksLeader,NERDTreeBookmarkName,NERDTreeBookmarksHeader
|
||||
|
||||
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
|
||||
hi def link NERDTreeBookmarkName Identifier
|
||||
hi def link NERDTreeBookmark normal
|
||||
|
||||
hi def link NERDTreeHelp String
|
||||
hi def link NERDTreeHelpKey Identifier
|
||||
hi def link NERDTreeHelpCommand Identifier
|
||||
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 NERDTreeOpenable Title
|
||||
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
|
||||
@ -0,0 +1,4 @@
|
||||
*~
|
||||
*.swp
|
||||
tags
|
||||
.DS_Store
|
||||
@ -0,0 +1,105 @@
|
||||
# CONTRIBUTING
|
||||
- - -
|
||||
1\. [Bug reports / GitHub issues](#bugreps)
|
||||
2\. [Submitting a patch](#patches)
|
||||
3\. [General style notes](#generalstyle)
|
||||
4\. [Syntax checker notes](#checkerstyle)
|
||||
- - -
|
||||
|
||||
<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 (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. Adding debugging information is typically useful
|
||||
too:
|
||||
|
||||
* open a file handled by your checker;
|
||||
* set `g:syntastic_debug` to 1 or 3;
|
||||
* run the checker;
|
||||
* copy the output of `:mes`.
|
||||
|
||||
<a name="patches"></a>
|
||||
|
||||
## 2. Submitting a patch
|
||||
|
||||
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.
|
||||
|
||||
To submit a patch:
|
||||
|
||||
* fork the [repo][2] on GitHub;
|
||||
* make a [topic branch][3] and start hacking;
|
||||
* submit a pull request based off your topic branch.
|
||||
|
||||
Small, focused patches are preferred.
|
||||
|
||||
Large changes to the code should be discussed with the core team first.
|
||||
Create an issue and explain your plan and see what we say.
|
||||
|
||||
Also make sure to update the manual whenever applicable. Nobody can use
|
||||
features that aren't documented.
|
||||
|
||||
<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,' .
|
||||
\ '%W%f(%l): lint warning: %m,' .
|
||||
\ '%W%f(%l): warning: %m,' .
|
||||
\ '%E%f(%l): SyntaxError: %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
|
||||
@ -0,0 +1,13 @@
|
||||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
Version 2, December 2004
|
||||
|
||||
Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
|
||||
|
||||
Everyone is permitted to copy and distribute verbatim or modified
|
||||
copies of this license document, and changing it is allowed as long
|
||||
as the name is changed.
|
||||
|
||||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. You just DO WHAT THE FUCK YOU WANT TO.
|
||||
@ -0,0 +1,462 @@
|
||||
,
|
||||
/ \,,_ .'|
|
||||
,{{| /}}}}/_.' _____________________________________________
|
||||
}}}}` '{{' '. / \
|
||||
{{{{{ _ ;, \ / Ladies and Gentlemen, \
|
||||
,}}}}}} /o`\ ` ;) | |
|
||||
{{{{{{ / ( | this is ... |
|
||||
}}}}}} | \ | |
|
||||
{{{{{{{{ \ \ | |
|
||||
}}}}}}}}} '.__ _ | | _____ __ __ _ |
|
||||
{{{{{{{{ /`._ (_\ / | / ___/__ ______ / /_____ ______/ /_(_)____ |
|
||||
}}}}}}' | //___/ --=: \__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ |
|
||||
jgs `{{{{` | '--' | ___/ / /_/ / / / / /_/ /_/ (__ ) /_/ / /__ |
|
||||
}}}` | /____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/ |
|
||||
| /____/ |
|
||||
| /
|
||||
\_____________________________________________/
|
||||
|
||||
|
||||
- - -
|
||||
1. [Introduction](#introduction)
|
||||
2. [Installation](#installation)
|
||||
2.1. [Requirements](#requirements)
|
||||
2.2. [Installing syntastic with Pathogen](#installpathogen)
|
||||
3. [Recommended settings](#settings)
|
||||
4. [FAQ](#faq)
|
||||
4.1. [I installed syntastic but it isn't reporting any errors...](#faqinfo)
|
||||
4.2. [The `python` checker complains about syntactically valid Python 3 constructs...](#faqpython3)
|
||||
4.3. [Are there any local checkers for HTML5 that I can use with syntastic?](#faqhtml5)
|
||||
4.4. [The `perl` checker has stopped working...](#faqperl)
|
||||
4.5. [What happened to the `rustc` checker?](#faqrust)
|
||||
4.6. [What happened to the `xcrun` checker?](#faqxcrun)
|
||||
4.7. [I run a checker and the location list is not updated...](#faqloclist)
|
||||
4.7. [I run`:lopen` or `:lwindow` and the error window is empty...](#faqloclist)
|
||||
4.8. [How can I pass additional arguments to a checker?](#faqargs)
|
||||
4.9. [Syntastic supports several checkers for my filetype - how do I tell which one(s) to use?](#faqcheckers)
|
||||
4.10. [What is the difference between syntax checkers and style checkers?](#faqstyle)
|
||||
4.11. [I have enabled multiple checkers for the current filetype. How can I display all of the errors from all of the checkers together?](#faqaggregate)
|
||||
4.12. [How can I jump between the different errors without using the location list at the bottom of the window?](#faqlnext)
|
||||
4.13. [The error window is closed automatically when I :quit the current buffer but not when I :bdelete it?](#faqbdelete)
|
||||
5. [Resources](#otherresources)
|
||||
|
||||
- - -
|
||||
|
||||
<a name="introduction"></a>
|
||||
|
||||
## 1\. Introduction
|
||||
|
||||
Syntastic is a syntax checking plugin for [Vim][13] that runs files through
|
||||
external syntax checkers and displays any resulting errors to the user. This
|
||||
can be done on demand, or automatically as files are saved. If syntax errors
|
||||
are detected, the user is notified and is happy because they didn't have to
|
||||
compile their code or execute their script to find them.
|
||||
|
||||
At the time of this writing, syntastic has checking plugins for ActionScript,
|
||||
Ada, API Blueprint, AppleScript, 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, Markdown, MATLAB,
|
||||
Mercury, NASM, Objective-C, Objective-C++, OCaml, Perl, Perl POD, PHP, gettext
|
||||
Portable Object, OS X and iOS property lists, Puppet, Python, R, Racket, Relax
|
||||
NG, reStructuredText, RPM spec, Ruby, SASS/SCSS, Scala, Slim, SML, 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.
|
||||
|
||||
A number of third-party Vim plugins also provide checkers for syntastic,
|
||||
for example: [omnisharp-vim][25], [rust.vim][12], [syntastic-extras][26],
|
||||
[syntastic-more][27], and [vim-swift][24].
|
||||
|
||||
Below is a screenshot showing the methods that Syntastic uses to display syntax
|
||||
errors. Note that, in practise, you will only have a subset of these methods
|
||||
enabled.
|
||||
|
||||
![Screenshot 1][0]
|
||||
|
||||
1. Errors are loaded into the location list for the corresponding window.
|
||||
2. When the cursor is on a line containing an error, the error message is echoed in the command window.
|
||||
3. Signs are placed beside lines with errors - note that warnings are displayed in a different color.
|
||||
4. There is a configurable statusline flag you can include in your statusline config.
|
||||
5. Hover the mouse over a line containing an error and the error message is displayed as a balloon.
|
||||
6. (not shown) Highlighting errors with syntax highlighting. Erroneous parts of lines can be highlighted.
|
||||
|
||||
<a name="installation"></a>
|
||||
|
||||
## 2\. Installation
|
||||
|
||||
<a name="requirements"></a>
|
||||
|
||||
### 2.1\. Requirements
|
||||
|
||||
Syntastic itself has rather relaxed requirements: it doesn't have any external
|
||||
dependencies, and it needs a version of [Vim][13] compiled with a few common
|
||||
features: `autocmd`, `eval`, `file_in_path`, `modify_fname`, `quickfix`,
|
||||
`reltime`, and `user_commands`. Not all possible combinations of features that
|
||||
include the ones above make equal sense on all operating systems, but Vim
|
||||
version 7 or later with the "normal", "big", or "huge" feature sets should be
|
||||
fine.
|
||||
|
||||
Syntastic should work with any modern plugin managers for Vim, such as
|
||||
[NeoBundle][14], [Pathogen][1], [Vim-Addon-Manager][15], [Vim-Plug][16], or
|
||||
[Vundle][17]. Instructions for installing syntastic with [Pathogen][1] are
|
||||
included below for completeness.
|
||||
|
||||
Last but not least: syntastic doesn't know how to do any syntax checks by
|
||||
itself. In order to get meaningful results you need to install external
|
||||
checkers corresponding to the types of files you use. Please consult the
|
||||
[wiki][3] for a list of supported checkers.
|
||||
|
||||
<a name="installpathogen"></a>
|
||||
|
||||
### 2.2\. Installing syntastic with Pathogen
|
||||
|
||||
If you already have [Pathogen][1] working then skip [Step 1](#step1) and go to
|
||||
[Step 2](#step2).
|
||||
|
||||
<a name="step1"></a>
|
||||
|
||||
#### 2.2.1\. Step 1: Install pathogen.vim
|
||||
|
||||
First I'll show you how to install Tim Pope's [Pathogen][1] so that it's easy to
|
||||
install syntastic. Do this in your terminal so that you get the `pathogen.vim`
|
||||
file and the directories it needs:
|
||||
```sh
|
||||
mkdir -p ~/.vim/autoload ~/.vim/bundle && \
|
||||
curl -LSso ~/.vim/autoload/pathogen.vim https://tpo.pe/pathogen.vim
|
||||
```
|
||||
Next you *need* to add this to your `~/.vimrc`:
|
||||
```vim
|
||||
execute pathogen#infect()
|
||||
```
|
||||
|
||||
<a name="step2"></a>
|
||||
|
||||
#### 2.2.2\. Step 2: Install syntastic as a Pathogen bundle
|
||||
|
||||
You now have pathogen installed and can put syntastic into `~/.vim/bundle` like
|
||||
this:
|
||||
```sh
|
||||
cd ~/.vim/bundle && \
|
||||
git clone https://github.com/scrooloose/syntastic.git
|
||||
```
|
||||
Quit vim and start it back up to reload it, then type:
|
||||
```vim
|
||||
:Helptags
|
||||
```
|
||||
If you get an error when you do this, then you probably didn't install
|
||||
[Pathogen][1] right. Go back to [Step 1](#step1) and make sure you did the
|
||||
following:
|
||||
|
||||
1. Created both the `~/.vim/autoload` and `~/.vim/bundle` directories.
|
||||
2. Added the `execute pathogen#infect()` line to your `~/.vimrc` file
|
||||
3. Did the `git clone` of syntastic inside `~/.vim/bundle`
|
||||
4. Have permissions to access all of these directories.
|
||||
|
||||
<a name="settings"></a>
|
||||
|
||||
## 3\. Recommended settings
|
||||
|
||||
Syntastic has a large number of options that can be configured, and the
|
||||
defaults are not particularly well suitable for new users. It is recommended
|
||||
that you start by adding the following lines to your `vimrc` file, and return
|
||||
to them after reading the manual (see `:help syntastic` in Vim):
|
||||
```vim
|
||||
set statusline+=%#warningmsg#
|
||||
set statusline+=%{SyntasticStatuslineFlag()}
|
||||
set statusline+=%*
|
||||
|
||||
let g:syntastic_always_populate_loc_list = 1
|
||||
let g:syntastic_auto_loc_list = 1
|
||||
let g:syntastic_check_on_open = 1
|
||||
let g:syntastic_check_on_wq = 0
|
||||
```
|
||||
|
||||
<a name="faq"></a>
|
||||
|
||||
## 4\. FAQ
|
||||
|
||||
<a name="faqinfo"></a>
|
||||
|
||||
__4.1. Q. I installed syntastic but it isn't reporting any errors...__
|
||||
|
||||
A. The most likely reason is that none of the syntax checkers that it requires
|
||||
is installed. For example: by default, python requires either `flake8` or
|
||||
`pylint` to be installed and in your `$PATH`. To see which executables are
|
||||
supported, look at the [wiki][3]. Note that aliases do not work; the actual
|
||||
executables must be available in your `$PATH`. Symbolic links are okay though.
|
||||
You can see syntastic's idea of available checkers by running `:SyntasticInfo`.
|
||||
|
||||
A second probable reason is that none of the available checkers are
|
||||
enabled. Syntastic comes preconfigured with a default list of enabled checkers
|
||||
per filetype, but this list is kept short in order to prevent slowing down Vim
|
||||
or trying to run conflicting checks. The command `:SyntasticInfo` will show you
|
||||
which checkers are enabled. You can tell syntastic which checkers (among the
|
||||
available ones) you want to run by setting `g:syntastic_<filetype>_checkers` in
|
||||
your `vimrc` (see [below](#faqcheckers)).
|
||||
|
||||
A third possible reason is that the `$PATH` seen by syntastic might not be same
|
||||
as the `$PATH` in your login shell. Syntastic runs checkers using the shell
|
||||
pointed to by Vim's `shell` (or by `g:syntastic_shell`, if set), and that's the
|
||||
shell you need to configure to set the proper `$PATH` and environment variables
|
||||
for your checkers. You can see syntastic's idea of `$PATH` by running
|
||||
```vim
|
||||
:echo syntastic#util#system('echo "$PATH"')
|
||||
```
|
||||
on UNIX and Mac OS-X systems, or
|
||||
```vim
|
||||
:echo syntastic#util#system('echo %PATH%')
|
||||
```
|
||||
on Windows.
|
||||
|
||||
Finally, another reason it could fail is that either the command line options
|
||||
or the error output for a syntax checker may have changed. In this case, make
|
||||
sure you have the latest version of the syntax checker installed. If it still
|
||||
fails then post an [issue][4] - or better yet, create a pull request.
|
||||
|
||||
<a name="faqpython3"></a>
|
||||
|
||||
__4.2. Q. The `python` checker complains about syntactically valid Python 3 constructs...__
|
||||
|
||||
A. Configure the `python` checker to call a Python 3 interpreter rather than
|
||||
Python 2, e.g:
|
||||
```vim
|
||||
let g:syntastic_python_python_exec = '/path/to/python3'
|
||||
```
|
||||
|
||||
<a name="faqhtml5"></a>
|
||||
|
||||
__4.3. Q. Are there any local checkers for HTML5 that I can use with syntastic?__
|
||||
|
||||
[HTML Tidy][18] has a fork named [HTML Tidy for HTML5][19]. It's a drop
|
||||
in replacement, and syntastic can use it without changes. Just install it
|
||||
somewhere and point `g:syntastic_html_tidy_exec` to its executable:
|
||||
```vim
|
||||
let g:syntastic_html_tidy_exec = 'tidy5'
|
||||
```
|
||||
Alternatively, you can install [vnu.jar][21] from the [validator.nu][20]
|
||||
project and run it as a [HTTP server][23]:
|
||||
```sh
|
||||
$ java -Xss512k -cp /path/to/vnu.jar nu.validator.servlet.Main 8888
|
||||
```
|
||||
Then you can [configure][22] syntastic to use it:
|
||||
```vim
|
||||
let g:syntastic_html_validator_api = 'http://localhost:8888/'
|
||||
```
|
||||
|
||||
<a name="faqperl"></a>
|
||||
|
||||
__4.4. Q. The `perl` checker has stopped working...__
|
||||
|
||||
A. The `perl` checker runs `perl -c` against your file, which in turn
|
||||
__executes__ any `BEGIN`, `UNITCHECK`, and `CHECK` blocks, and any `use`
|
||||
statements in your file (cf. [perlrun][10]). This is probably fine if you
|
||||
wrote the file yourself, but it's a security problem if you're checking third
|
||||
party files. Since there is currently no way to disable this behaviour while
|
||||
still producing useful results, the checker is now disabled by default. To
|
||||
(re-)enable it, 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>
|
||||
|
||||
__4.5. Q. What happened to the `rustc` checker?__
|
||||
|
||||
A. It is now part of the [rust.vim][12] plugin. If you install this plugin the
|
||||
checker should be picked up automatically by syntastic.
|
||||
|
||||
<a name="faqxcrun"></a>
|
||||
|
||||
__4.6. Q. What happened to the `xcrun` checker?__
|
||||
|
||||
A. The `xcrun` checker used to have a security problem and it has been removed.
|
||||
A better checker for __Swift__ is part of the [vim-swift][24] plugin. If you
|
||||
install this plugin the checker should be picked up automatically by syntastic.
|
||||
|
||||
<a name="faqloclist"></a>
|
||||
|
||||
__4.7. Q. I run a checker and the location list is not updated...__
|
||||
__4.7. Q. I run`:lopen` or `:lwindow` and the error window is empty...__
|
||||
|
||||
A. By default the location list is changed only when you run the `:Errors`
|
||||
command, in order to minimise conflicts with other plugins. If you want the
|
||||
location list to always be updated when you run the checkers, add this line to
|
||||
your `vimrc`:
|
||||
```vim
|
||||
let g:syntastic_always_populate_loc_list = 1
|
||||
```
|
||||
|
||||
<a name="faqargs"></a>
|
||||
|
||||
__4.8. Q. How can I pass additional arguments to a checker?__
|
||||
|
||||
A. Almost all syntax checkers use the `makeprgBuild()` function. Those checkers
|
||||
that do can be configured using global variables. The general form of the
|
||||
global `args` variables is `syntastic_<filetype>_<checker>_args`.
|
||||
|
||||
So, If you wanted to pass `--my --args --here` to the ruby mri checker you
|
||||
would add this line to your `vimrc`:
|
||||
```vim
|
||||
let g:syntastic_ruby_mri_args = "--my --args --here"
|
||||
```
|
||||
|
||||
See `:help syntastic-checker-options` for more information.
|
||||
|
||||
<a name="faqcheckers"></a>
|
||||
|
||||
__4.9. Q. Syntastic supports several checkers for my filetype - how do I tell it
|
||||
which one(s) to use?__
|
||||
|
||||
A. Stick a line like this in your `vimrc`:
|
||||
```vim
|
||||
let g:syntastic_<filetype>_checkers = ['<checker-name>']
|
||||
```
|
||||
|
||||
To see the list of supported checkers for your filetype look at the
|
||||
[wiki][3].
|
||||
|
||||
e.g. Python has the following checkers, among others: `flake8`, `pyflakes`,
|
||||
`pylint` and a native `python` checker.
|
||||
|
||||
To tell syntastic to use `pylint`, you would use this setting:
|
||||
```vim
|
||||
let g:syntastic_python_checkers = ['pylint']
|
||||
```
|
||||
|
||||
Checkers can be chained together like this:
|
||||
```vim
|
||||
let g:syntastic_php_checkers = ['php', 'phpcs', 'phpmd']
|
||||
```
|
||||
|
||||
This is telling syntastic to run the `php` checker first, and if no errors are
|
||||
found, run `phpcs`, and then `phpmd`.
|
||||
|
||||
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
|
||||
filetype of the current file is `php`).
|
||||
|
||||
<a name="faqstyle"></a>
|
||||
|
||||
__4.10. Q. What is the difference between syntax checkers and style checkers?__
|
||||
|
||||
A. The errors and warnings they produce are highlighted differently and can
|
||||
be filtered by different rules, but otherwise the distinction is pretty much
|
||||
arbitrary. There is an ongoing effort to keep things consistent, so you can
|
||||
_generally_ expect messages produced by syntax checkers to be _mostly_ related
|
||||
to syntax, and messages produced by style checkers to be _mostly_ about style.
|
||||
But there can be no formal guarantee that, say, a style checker that runs into
|
||||
a syntax error wouldn't die with a fatal message, nor that a syntax checker
|
||||
wouldn't give you warnings against using some constructs as being bad practice.
|
||||
There is also no guarantee that messages marked as "style" are less severe than
|
||||
the ones marked as "syntax" (whatever that might mean). And there are even a
|
||||
few Frankenstein checkers (for example `flake8` and `pylama`) that, by their
|
||||
nature, produce both kinds of messages. Syntastic is not smart enough to be
|
||||
able to sort out these things by itself.
|
||||
|
||||
In fact it's more useful to look at this from the perspective of filtering
|
||||
unwanted messages, rather than as an indicator of severity levels. The
|
||||
distinction between syntax and style is orthogonal to the distinction between
|
||||
errors and warnings, and thus you can turn off messages based on level, on
|
||||
type, or both.
|
||||
|
||||
e.g. To disable all style messages:
|
||||
```vim
|
||||
let g:syntastic_quiet_messages = { "type": "style" }
|
||||
```
|
||||
See `:help syntastic_quiet_messages` for details.
|
||||
|
||||
<a name="faqaggregate"></a>
|
||||
|
||||
__4.11. Q. I have enabled multiple checkers for the current filetype. How can I
|
||||
display all of the errors from all of the checkers together?__
|
||||
|
||||
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>
|
||||
|
||||
__4.12. Q. How can I jump between the different errors without using the location
|
||||
list at the bottom of the window?__
|
||||
|
||||
A. Vim provides several built-in commands for this. See `:help :lnext` and
|
||||
`:help :lprevious`.
|
||||
|
||||
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="faqbdelete"></a>
|
||||
|
||||
__4.13. Q. The error window is closed automatically when I :quit the current buffer
|
||||
but not when I :bdelete it?__
|
||||
|
||||
A. There is no safe way to handle that situation automatically, but you can
|
||||
work around it:
|
||||
|
||||
```vim
|
||||
nnoremap <silent> <C-d> :lclose<CR>:bdelete<CR>
|
||||
cabbrev <silent> bd lclose\|bdelete
|
||||
```
|
||||
|
||||
<a name="otherresources"></a>
|
||||
|
||||
## 5\. Resources
|
||||
|
||||
The preferred place for posting suggestions, reporting bugs, and general
|
||||
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
|
||||
plugins that provide more functionality than syntastic. You might want to take
|
||||
a look at [jedi-vim][7], [python-mode][8], or [YouCompleteMe][9].
|
||||
|
||||
[0]: https://github.com/scrooloose/syntastic/raw/master/_assets/screenshot_1.png
|
||||
[1]: https://github.com/tpope/vim-pathogen
|
||||
[2]: https://github.com/tpope/vim-unimpaired
|
||||
[3]: https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
|
||||
[4]: https://github.com/scrooloose/syntastic/issues
|
||||
[5]: https://groups.google.com/group/vim-syntastic
|
||||
[6]: http://stackoverflow.com/questions/tagged/syntastic
|
||||
[7]: https://github.com/davidhalter/jedi-vim
|
||||
[8]: https://github.com/klen/python-mode
|
||||
[9]: 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.vim
|
||||
[13]: http://www.vim.org/
|
||||
[14]: https://github.com/Shougo/neobundle.vim
|
||||
[15]: https://github.com/MarcWeber/vim-addon-manager
|
||||
[16]: https://github.com/junegunn/vim-plug/
|
||||
[17]: https://github.com/gmarik/Vundle.vim
|
||||
[18]: http://tidy.sourceforge.net/
|
||||
[19]: http://www.htacg.org/tidy-html5/
|
||||
[20]: http://about.validator.nu/
|
||||
[21]: https://github.com/validator/validator/releases/latest
|
||||
[22]: https://github.com/scrooloose/syntastic/wiki/HTML%3A---validator
|
||||
[23]: http://validator.github.io/validator/#standalone
|
||||
[24]: https://github.com/kballard/vim-swift
|
||||
[25]: https://github.com/OmniSharp/omnisharp-vim
|
||||
[26]: https://github.com/myint/syntastic-extras
|
||||
[27]: https://github.com/roktas/syntastic-more
|
||||
|
||||
<!--
|
||||
vim:tw=79:sw=4:
|
||||
-->
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 90 KiB |
@ -0,0 +1,345 @@
|
||||
if exists('g:loaded_syntastic_c_autoload') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_autoload = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
" Public functions {{{1
|
||||
|
||||
" convenience function to determine the 'null device' parameter
|
||||
" based on the current operating system
|
||||
function! syntastic#c#NullOutput() abort " {{{2
|
||||
let known_os = has('unix') || has('mac') || syntastic#util#isRunningWindows()
|
||||
return known_os ? '-o ' . syntastic#util#DevNull() : ''
|
||||
endfunction " }}}2
|
||||
|
||||
" read additional compiler flags from the given configuration file
|
||||
" the file format and its parsing mechanism is inspired by clang_complete
|
||||
function! syntastic#c#ReadConfig(file) abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: looking for', a:file)
|
||||
|
||||
" search upwards from the current file's directory
|
||||
let config = findfile(a:file, '.;')
|
||||
if config ==# ''
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: file not found')
|
||||
return ''
|
||||
endif
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: config file:', config)
|
||||
if !filereadable(config)
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: file unreadable')
|
||||
return ''
|
||||
endif
|
||||
|
||||
" convert filename into absolute path
|
||||
let filepath = fnamemodify(config, ':p:h')
|
||||
|
||||
" try to read config file
|
||||
try
|
||||
let lines = readfile(config)
|
||||
catch /\m^Vim\%((\a\+)\)\=:E48[45]/
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, 'ReadConfig: error reading file')
|
||||
return ''
|
||||
endtry
|
||||
|
||||
" filter out empty lines and comments
|
||||
call filter(lines, 'v:val !~# ''\v^(\s*#|$)''')
|
||||
|
||||
" remove leading and trailing spaces
|
||||
call map(lines, 'substitute(v:val, ''\m^\s\+'', "", "")')
|
||||
call map(lines, 'substitute(v:val, ''\m\s\+$'', "", "")')
|
||||
|
||||
let parameters = []
|
||||
for line in lines
|
||||
let matches = matchstr(line, '\m\C^\s*-I\s*\zs.\+')
|
||||
if matches !=# ''
|
||||
" this one looks like an absolute path
|
||||
if match(matches, '\m^\%(/\|\a:\)') != -1
|
||||
call add(parameters, '-I' . matches)
|
||||
else
|
||||
call add(parameters, '-I' . filepath . syntastic#util#Slash() . matches)
|
||||
endif
|
||||
else
|
||||
call add(parameters, line)
|
||||
endif
|
||||
endfor
|
||||
|
||||
return join(map(parameters, 'syntastic#util#shescape(v:val)'))
|
||||
endfunction " }}}2
|
||||
|
||||
" GetLocList() for C-like compilers
|
||||
function! syntastic#c#GetLocList(filetype, subchecker, options) abort " {{{2
|
||||
try
|
||||
let flags = s:_get_cflags(a:filetype, a:subchecker, a:options)
|
||||
catch /\m\C^Syntastic: skip checks$/
|
||||
return []
|
||||
endtry
|
||||
|
||||
let makeprg = syntastic#util#shexpand(g:syntastic_{a:filetype}_compiler) .
|
||||
\ ' ' . flags . ' ' . syntastic#util#shexpand('%')
|
||||
|
||||
let errorformat = s:_get_checker_var('g', a:filetype, a:subchecker, 'errorformat', a:options['errorformat'])
|
||||
|
||||
let postprocess = s:_get_checker_var('g', a:filetype, a:subchecker, 'remove_include_errors', 0) ?
|
||||
\ ['filterForeignErrors'] : []
|
||||
|
||||
" process makeprg
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'postprocess': postprocess })
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private functions {{{1
|
||||
|
||||
" initialize c/cpp syntax checker handlers
|
||||
function! s:_init() abort " {{{2
|
||||
let s:handlers = []
|
||||
let s:cflags = {}
|
||||
|
||||
call s:_registerHandler('\m\<cairo', 's:_checkPackage', ['cairo', 'cairo'])
|
||||
call s:_registerHandler('\m\<freetype', 's:_checkPackage', ['freetype', 'freetype2', 'freetype'])
|
||||
call s:_registerHandler('\m\<glade', 's:_checkPackage', ['glade', 'libglade-2.0', 'libglade'])
|
||||
call s:_registerHandler('\m\<glib', 's:_checkPackage', ['glib', 'glib-2.0', 'glib'])
|
||||
call s:_registerHandler('\m\<gtk', 's:_checkPackage', ['gtk', 'gtk+-2.0', 'gtk+', 'glib-2.0', 'glib'])
|
||||
call s:_registerHandler('\m\<libsoup', 's:_checkPackage', ['libsoup', 'libsoup-2.4', 'libsoup-2.2'])
|
||||
call s:_registerHandler('\m\<libxml', 's:_checkPackage', ['libxml', 'libxml-2.0', 'libxml'])
|
||||
call s:_registerHandler('\m\<pango', 's:_checkPackage', ['pango', 'pango'])
|
||||
call s:_registerHandler('\m\<SDL', 's:_checkPackage', ['sdl', 'sdl'])
|
||||
call s:_registerHandler('\m\<opengl', 's:_checkPackage', ['opengl', 'gl'])
|
||||
call s:_registerHandler('\m\<webkit', 's:_checkPackage', ['webkit', 'webkit-1.0'])
|
||||
|
||||
call s:_registerHandler('\m\<php\.h\>', 's:_checkPhp', [])
|
||||
call s:_registerHandler('\m\<Python\.h\>', 's:_checkPython', [])
|
||||
call s:_registerHandler('\m\<ruby', 's:_checkRuby', [])
|
||||
endfunction " }}}2
|
||||
|
||||
" register a handler dictionary object
|
||||
function! s:_registerHandler(regex, function, args) abort " {{{2
|
||||
let handler = {}
|
||||
let handler['regex'] = a:regex
|
||||
let handler['func'] = function(a:function)
|
||||
let handler['args'] = a:args
|
||||
call add(s:handlers, handler)
|
||||
endfunction " }}}2
|
||||
|
||||
" try to find library with 'pkg-config'
|
||||
" search possible libraries from first to last given
|
||||
" argument until one is found
|
||||
function! s:_checkPackage(name, ...) abort " {{{2
|
||||
if executable('pkg-config')
|
||||
if !has_key(s:cflags, a:name)
|
||||
for pkg in a:000
|
||||
let pkg_flags = syntastic#util#system('pkg-config --cflags ' . pkg)
|
||||
" since we cannot necessarily trust the pkg-config exit code
|
||||
" we have to check for an error output as well
|
||||
if v:shell_error == 0 && pkg_flags !~? 'not found'
|
||||
let pkg_flags = ' ' . substitute(pkg_flags, "\n", '', '')
|
||||
let s:cflags[a:name] = pkg_flags
|
||||
return pkg_flags
|
||||
endif
|
||||
endfor
|
||||
else
|
||||
return s:cflags[a:name]
|
||||
endif
|
||||
endif
|
||||
return ''
|
||||
endfunction " }}}2
|
||||
|
||||
" try to find PHP includes with 'php-config'
|
||||
function! s:_checkPhp() abort " {{{2
|
||||
if executable('php-config')
|
||||
if !has_key(s:cflags, 'php')
|
||||
let s:cflags['php'] = syntastic#util#system('php-config --includes')
|
||||
let s:cflags['php'] = ' ' . substitute(s:cflags['php'], "\n", '', '')
|
||||
endif
|
||||
return s:cflags['php']
|
||||
endif
|
||||
return ''
|
||||
endfunction " }}}2
|
||||
|
||||
" try to find the python headers with distutils
|
||||
function! s:_checkPython() abort " {{{2
|
||||
if executable('python')
|
||||
if !has_key(s:cflags, 'python')
|
||||
let s:cflags['python'] = syntastic#util#system('python -c ''from distutils import ' .
|
||||
\ 'sysconfig; import sys; sys.stdout.write(sysconfig.get_python_inc())''')
|
||||
let s:cflags['python'] = substitute(s:cflags['python'], "\n", '', '')
|
||||
let s:cflags['python'] = ' -I' . s:cflags['python']
|
||||
endif
|
||||
return s:cflags['python']
|
||||
endif
|
||||
return ''
|
||||
endfunction " }}}2
|
||||
|
||||
" try to find the ruby headers with 'rbconfig'
|
||||
function! s:_checkRuby() abort " {{{2
|
||||
if executable('ruby')
|
||||
if !has_key(s:cflags, 'ruby')
|
||||
let s:cflags['ruby'] = syntastic#util#system('ruby -r rbconfig -e ' .
|
||||
\ '''puts RbConfig::CONFIG["rubyhdrdir"] || RbConfig::CONFIG["archdir"]''')
|
||||
let s:cflags['ruby'] = substitute(s:cflags['ruby'], "\n", '', '')
|
||||
let s:cflags['ruby'] = ' -I' . s:cflags['ruby']
|
||||
endif
|
||||
return s:cflags['ruby']
|
||||
endif
|
||||
return ''
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Utilities {{{1
|
||||
|
||||
" resolve checker-related user variables
|
||||
function! s:_get_checker_var(scope, filetype, subchecker, name, default) abort " {{{2
|
||||
let prefix = a:scope . ':' . 'syntastic_'
|
||||
if exists(prefix . a:filetype . '_' . a:subchecker . '_' . a:name)
|
||||
return {a:scope}:syntastic_{a:filetype}_{a:subchecker}_{a:name}
|
||||
elseif exists(prefix . a:filetype . '_' . a:name)
|
||||
return {a:scope}:syntastic_{a:filetype}_{a:name}
|
||||
else
|
||||
return a:default
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" resolve user CFLAGS
|
||||
function! s:_get_cflags(ft, ck, opts) abort " {{{2
|
||||
" determine whether to parse header files as well
|
||||
if has_key(a:opts, 'header_names') && expand('%', 1) =~? a:opts['header_names']
|
||||
if s:_get_checker_var('g', a:ft, a:ck, 'check_header', 0)
|
||||
let flags = get(a:opts, 'header_flags', '') . ' -c ' . syntastic#c#NullOutput()
|
||||
else
|
||||
" checking headers when check_header is unset: bail out
|
||||
throw 'Syntastic: skip checks'
|
||||
endif
|
||||
else
|
||||
let flags = get(a:opts, 'main_flags', '')
|
||||
endif
|
||||
|
||||
let flags .= ' ' . s:_get_checker_var('g', a:ft, a:ck, 'compiler_options', '') . ' ' . s:_get_include_dirs(a:ft)
|
||||
|
||||
" check if the user manually set some cflags
|
||||
let b_cflags = s:_get_checker_var('b', a:ft, a:ck, 'cflags', '')
|
||||
if b_cflags ==# ''
|
||||
if a:ft ==# 'c' || a:ft ==# 'cpp'
|
||||
" check whether to search for include files at all
|
||||
if !s:_get_checker_var('g', a:ft, a:ck, 'no_include_search', 0)
|
||||
" refresh the include file search if desired
|
||||
if s:_get_checker_var('g', a:ft, a:ck, 'auto_refresh_includes', 0)
|
||||
let flags .= ' ' . s:_search_headers()
|
||||
else
|
||||
" search for header includes if not cached already
|
||||
if !exists('b:syntastic_' . a:ft . '_includes')
|
||||
let b:syntastic_{a:ft}_includes = s:_search_headers()
|
||||
endif
|
||||
let flags .= ' ' . b:syntastic_{a:ft}_includes
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
else
|
||||
" user-defined cflags
|
||||
let flags .= ' ' . b_cflags
|
||||
endif
|
||||
|
||||
" add optional config file parameters
|
||||
let config_file = s:_get_checker_var('g', a:ft, a:ck, 'config_file', '.syntastic_' . a:ft . '_config')
|
||||
let flags .= ' ' . syntastic#c#ReadConfig(config_file)
|
||||
|
||||
return flags
|
||||
endfunction " }}}2
|
||||
|
||||
" get the gcc include directory argument depending on the default
|
||||
" includes and the optional user-defined 'g:syntastic_c_include_dirs'
|
||||
function! s:_get_include_dirs(filetype) abort " {{{2
|
||||
let include_dirs = []
|
||||
|
||||
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)
|
||||
endif
|
||||
|
||||
if exists('g:syntastic_'.a:filetype.'_include_dirs')
|
||||
call extend(include_dirs, g:syntastic_{a:filetype}_include_dirs)
|
||||
endif
|
||||
|
||||
return join(map(syntastic#util#unique(include_dirs), 'syntastic#util#shescape("-I" . v:val)'))
|
||||
endfunction " }}}2
|
||||
|
||||
" search the first 100 lines for include statements that are
|
||||
" given in the handlers dictionary
|
||||
function! s:_search_headers() abort " {{{2
|
||||
let includes = ''
|
||||
let files = []
|
||||
let found = []
|
||||
let lines = filter(getline(1, 100), 'v:val =~# ''\m^\s*#\s*include''')
|
||||
|
||||
" search current buffer
|
||||
for line in lines
|
||||
let file = matchstr(line, '\m"\zs\S\+\ze"')
|
||||
if file !=# ''
|
||||
call add(files, file)
|
||||
continue
|
||||
endif
|
||||
|
||||
for handler in s:handlers
|
||||
if line =~# handler['regex']
|
||||
let includes .= call(handler['func'], handler['args'])
|
||||
call add(found, handler['regex'])
|
||||
break
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
|
||||
" search included headers
|
||||
for hfile in files
|
||||
if hfile !=# ''
|
||||
let filename = expand('%:p:h', 1) . syntastic#util#Slash() . hfile
|
||||
|
||||
try
|
||||
let lines = readfile(filename, '', 100)
|
||||
catch /\m^Vim\%((\a\+)\)\=:E484/
|
||||
continue
|
||||
endtry
|
||||
|
||||
call filter(lines, 'v:val =~# ''\m^\s*#\s*include''')
|
||||
|
||||
for handler in s:handlers
|
||||
if index(found, handler['regex']) != -1
|
||||
continue
|
||||
endif
|
||||
|
||||
for line in lines
|
||||
if line =~# handler['regex']
|
||||
let includes .= call(handler['func'], handler['args'])
|
||||
call add(found, handler['regex'])
|
||||
break
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
endif
|
||||
endfor
|
||||
|
||||
return includes
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" default include directories
|
||||
let s:default_includes = [
|
||||
\ '.',
|
||||
\ '..',
|
||||
\ 'include',
|
||||
\ 'includes',
|
||||
\ '..' . syntastic#util#Slash() . 'include',
|
||||
\ '..' . syntastic#util#Slash() . 'includes' ]
|
||||
|
||||
call s:_init()
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,182 @@
|
||||
if exists('g:loaded_syntastic_log_autoload') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_log_autoload = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
let s:one_time_notices_issued = []
|
||||
|
||||
" Public functions {{{1
|
||||
|
||||
function! syntastic#log#info(msg) abort " {{{2
|
||||
echomsg 'syntastic: info: ' . a:msg
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#log#warn(msg) abort " {{{2
|
||||
echohl WarningMsg
|
||||
echomsg 'syntastic: warning: ' . a:msg
|
||||
echohl None
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#log#error(msg) abort " {{{2
|
||||
execute "normal \<Esc>"
|
||||
echohl ErrorMsg
|
||||
echomsg 'syntastic: error: ' . a:msg
|
||||
echohl None
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#log#oneTimeWarn(msg) abort " {{{2
|
||||
if index(s:one_time_notices_issued, a:msg) >= 0
|
||||
return
|
||||
endif
|
||||
|
||||
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, ...) abort " {{{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, ...) abort " {{{2
|
||||
if !s:_isDebugEnabled(a:level)
|
||||
return
|
||||
endif
|
||||
|
||||
let leader = s:_log_timestamp()
|
||||
call s:_logRedirect(1)
|
||||
|
||||
if a:0 > 0
|
||||
" filter out dictionary functions
|
||||
echomsg leader . a:msg . ' ' .
|
||||
\ strtrans(string(type(a:1) == type({}) || type(a:1) == type([]) ?
|
||||
\ filter(copy(a:1), 'type(v:val) != type(function("tr"))') : a:1))
|
||||
else
|
||||
echomsg leader . a:msg
|
||||
endif
|
||||
|
||||
call s:_logRedirect(0)
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#log#debugShowOptions(level, names) abort " {{{2
|
||||
if !s:_isDebugEnabled(a:level)
|
||||
return
|
||||
endif
|
||||
|
||||
let leader = s:_log_timestamp()
|
||||
call s:_logRedirect(1)
|
||||
|
||||
let vlist = copy(type(a:names) == type('') ? [a:names] : a:names)
|
||||
if !empty(vlist)
|
||||
call map(vlist, "'&' . v:val . ' = ' . strtrans(string(eval('&' . v:val)))")
|
||||
echomsg leader . join(vlist, ', ')
|
||||
endif
|
||||
call s:_logRedirect(0)
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#log#debugShowVariables(level, names) abort " {{{2
|
||||
if !s:_isDebugEnabled(a:level)
|
||||
return
|
||||
endif
|
||||
|
||||
let leader = s:_log_timestamp()
|
||||
call s:_logRedirect(1)
|
||||
|
||||
let vlist = type(a:names) == type('') ? [a:names] : a:names
|
||||
for name in vlist
|
||||
let msg = s:_format_variable(name)
|
||||
if msg !=# ''
|
||||
echomsg leader . msg
|
||||
endif
|
||||
endfor
|
||||
|
||||
call s:_logRedirect(0)
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#log#debugDump(level) abort " {{{2
|
||||
if !s:_isDebugEnabled(a:level)
|
||||
return
|
||||
endif
|
||||
|
||||
call syntastic#log#debugShowVariables( a:level, sort(keys(g:_SYNTASTIC_DEFAULTS)) )
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private functions {{{1
|
||||
|
||||
function! s:_isDebugEnabled_smart(level) abort " {{{2
|
||||
return and(g:syntastic_debug, a:level)
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_isDebugEnabled_dumb(level) abort " {{{2
|
||||
" poor man's bit test for bit N, assuming a:level == 2**N
|
||||
return (g:syntastic_debug / a:level) % 2
|
||||
endfunction " }}}2
|
||||
|
||||
let s:_isDebugEnabled = function(exists('*and') ? 's:_isDebugEnabled_smart' : 's:_isDebugEnabled_dumb')
|
||||
lockvar s:_isDebugEnabled
|
||||
|
||||
function! s:_logRedirect(on) abort " {{{2
|
||||
if exists('g:syntastic_debug_file')
|
||||
if a:on
|
||||
try
|
||||
execute 'redir >> ' . fnameescape(expand(g:syntastic_debug_file, 1))
|
||||
catch /\m^Vim\%((\a\+)\)\=:/
|
||||
silent! redir END
|
||||
unlet g:syntastic_debug_file
|
||||
endtry
|
||||
else
|
||||
silent! redir END
|
||||
endif
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Utilities {{{1
|
||||
|
||||
function! s:_log_timestamp() abort " {{{2
|
||||
return 'syntastic: ' . split(reltimestr(reltime(g:_SYNTASTIC_START)))[0] . ': '
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_format_variable(name) abort " {{{2
|
||||
let vals = []
|
||||
if exists('g:syntastic_' . a:name)
|
||||
call add(vals, 'g:syntastic_' . a:name . ' = ' . strtrans(string(g:syntastic_{a:name})))
|
||||
endif
|
||||
if exists('b:syntastic_' . a:name)
|
||||
call add(vals, 'b:syntastic_' . a:name . ' = ' . strtrans(string(b:syntastic_{a:name})))
|
||||
endif
|
||||
|
||||
return join(vals, ', ')
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,73 @@
|
||||
if exists('g:loaded_syntastic_postprocess_autoload') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_postprocess_autoload = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
" Public functions {{{1
|
||||
|
||||
" merge consecutive blanks
|
||||
function! syntastic#postprocess#compressWhitespace(errors) abort " {{{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
|
||||
endfunction " }}}2
|
||||
|
||||
" remove spurious CR under Cygwin
|
||||
function! syntastic#postprocess#cygwinRemoveCR(errors) abort " {{{2
|
||||
if has('win32unix')
|
||||
for e in a:errors
|
||||
let e['text'] = substitute(e['text'], '\r', '', 'g')
|
||||
endfor
|
||||
endif
|
||||
|
||||
return a:errors
|
||||
endfunction " }}}2
|
||||
|
||||
" decode XML entities
|
||||
function! syntastic#postprocess#decodeXMLEntities(errors) abort " {{{2
|
||||
for e in a:errors
|
||||
let e['text'] = syntastic#util#decodeXMLEntities(e['text'])
|
||||
endfor
|
||||
|
||||
return a:errors
|
||||
endfunction " }}}2
|
||||
|
||||
" filter out errors referencing other files
|
||||
function! syntastic#postprocess#filterForeignErrors(errors) abort " {{{2
|
||||
return filter(copy(a:errors), 'get(v:val, "bufnr") == ' . bufnr(''))
|
||||
endfunction " }}}2
|
||||
|
||||
" make sure line numbers are not past end of buffers
|
||||
" XXX: this loads all referenced buffers in memory
|
||||
function! syntastic#postprocess#guards(errors) abort " {{{2
|
||||
let buffers = syntastic#util#unique(map(filter(copy(a:errors), 'v:val["valid"]'), 'str2nr(v:val["bufnr"])'))
|
||||
|
||||
let guards = {}
|
||||
for b in buffers
|
||||
let guards[b] = len(getbufline(b, 1, '$'))
|
||||
endfor
|
||||
|
||||
for e in a:errors
|
||||
if e['valid'] && e['lnum'] > guards[e['bufnr']]
|
||||
let e['lnum'] = guards[e['bufnr']]
|
||||
endif
|
||||
endfor
|
||||
|
||||
return a:errors
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,316 @@
|
||||
if exists('g:loaded_syntastic_preprocess_autoload') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_preprocess_autoload = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
" Public functions {{{1
|
||||
|
||||
function! syntastic#preprocess#cabal(errors) abort " {{{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) abort " {{{2
|
||||
let out = []
|
||||
let fname = expand('%', 1)
|
||||
for err in a:errors
|
||||
if match(err, '\m<error\>') > -1
|
||||
let line = str2nr(matchstr(err, '\m\<line="\zs\d\+\ze"'))
|
||||
if line == 0
|
||||
continue
|
||||
endif
|
||||
|
||||
let col = str2nr(matchstr(err, '\m\<column="\zs\d\+\ze"'))
|
||||
|
||||
let type = matchstr(err, '\m\<severity="\zs.\ze')
|
||||
if type !~? '^[EW]'
|
||||
let type = 'E'
|
||||
endif
|
||||
|
||||
let message = syntastic#util#decodeXMLEntities(matchstr(err, '\m\<message="\zs[^"]\+\ze"'))
|
||||
|
||||
call add(out, join([fname, type, line, col, message], ':'))
|
||||
elseif match(err, '\m<file name="') > -1
|
||||
let fname = syntastic#util#decodeXMLEntities(matchstr(err, '\v\<file name\="\zs[^"]+\ze"'))
|
||||
endif
|
||||
endfor
|
||||
return out
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#preprocess#cppcheck(errors) abort " {{{2
|
||||
return map(copy(a:errors), 'substitute(v:val, ''\v^\[[^]]+\]\zs( -\> \[[^]]+\])+\ze:'', "", "")')
|
||||
endfunction " }}}2
|
||||
|
||||
" @vimlint(EVL102, 1, l:true)
|
||||
" @vimlint(EVL102, 1, l:false)
|
||||
" @vimlint(EVL102, 1, l:null)
|
||||
function! syntastic#preprocess#flow(errors) abort " {{{2
|
||||
" JSON artifacts
|
||||
let true = 1
|
||||
let false = 0
|
||||
let null = ''
|
||||
|
||||
" A hat tip to Marc Weber for this trick
|
||||
" http://stackoverflow.com/questions/17751186/iterating-over-a-string-in-vimscript-or-parse-a-json-file/19105763#19105763
|
||||
try
|
||||
let errs = eval(join(a:errors, ''))
|
||||
catch
|
||||
let errs = {}
|
||||
endtry
|
||||
|
||||
let out = []
|
||||
if type(errs) == type({}) && has_key(errs, 'errors') && type(errs['errors']) == type([])
|
||||
for e in errs['errors']
|
||||
if type(e) == type({}) && has_key(e, 'message') && type(e['message']) == type([]) && len(e['message'])
|
||||
let m = e['message'][0]
|
||||
let t = e['message'][1:]
|
||||
|
||||
try
|
||||
let msg =
|
||||
\ m['path'] . ':' .
|
||||
\ m['line'] . ':' .
|
||||
\ m['start'] . ':' .
|
||||
\ (m['line'] ==# m['endline'] && str2nr(m['end']) > 0 ? m['end'] . ':' : '') .
|
||||
\ ' ' . m['descr']
|
||||
|
||||
if len(t)
|
||||
let msg .= ' ' . join(map(t,
|
||||
\ 'v:val["descr"] . " (" . v:val["path"] . ":" . v:val["line"] . ":" . v:val["start"] . ' .
|
||||
\ '"," . (v:val["line"] !=# v:val["endline"] ? v:val["endline"] . ":" : "") . ' .
|
||||
\ 'v:val["end"] . ")"'))
|
||||
endif
|
||||
|
||||
let msg = substitute(msg, '\r', '', 'g')
|
||||
let msg = substitute(msg, '\n', ' ', 'g')
|
||||
|
||||
call add(out, msg)
|
||||
catch /\m^Vim\%((\a\+)\)\=:E716/
|
||||
call syntastic#log#warn('checker javascript/flow: unknown error format')
|
||||
let out = []
|
||||
break
|
||||
endtry
|
||||
else
|
||||
call syntastic#log#warn('checker javascript/flow: unknown error format')
|
||||
let out = []
|
||||
break
|
||||
endif
|
||||
endfor
|
||||
else
|
||||
call syntastic#log#warn('checker javascript/flow: unknown error format')
|
||||
endif
|
||||
|
||||
return out
|
||||
endfunction " }}}2
|
||||
" @vimlint(EVL102, 0, l:true)
|
||||
" @vimlint(EVL102, 0, l:false)
|
||||
" @vimlint(EVL102, 0, l:null)
|
||||
|
||||
function! syntastic#preprocess#killEmpty(errors) abort " {{{2
|
||||
return filter(copy(a:errors), 'v:val !=# ""')
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#preprocess#perl(errors) abort " {{{2
|
||||
let out = []
|
||||
|
||||
for e in a:errors
|
||||
let parts = matchlist(e, '\v^(.*)\sat\s(.{-})\sline\s(\d+)(.*)$')
|
||||
if !empty(parts)
|
||||
call add(out, parts[2] . ':' . parts[3] . ':' . parts[1] . parts[4])
|
||||
endif
|
||||
endfor
|
||||
|
||||
return syntastic#util#unique(out)
|
||||
endfunction " }}}2
|
||||
|
||||
" @vimlint(EVL102, 1, l:true)
|
||||
" @vimlint(EVL102, 1, l:false)
|
||||
" @vimlint(EVL102, 1, l:null)
|
||||
function! syntastic#preprocess#prospector(errors) abort " {{{2
|
||||
" JSON artifacts
|
||||
let true = 1
|
||||
let false = 0
|
||||
let null = ''
|
||||
|
||||
" A hat tip to Marc Weber for this trick
|
||||
" http://stackoverflow.com/questions/17751186/iterating-over-a-string-in-vimscript-or-parse-a-json-file/19105763#19105763
|
||||
try
|
||||
let errs = eval(join(a:errors, ''))
|
||||
catch
|
||||
let errs = {}
|
||||
endtry
|
||||
|
||||
let out = []
|
||||
if type(errs) == type({}) && has_key(errs, 'messages')
|
||||
if type(errs['messages']) == type([])
|
||||
for e in errs['messages']
|
||||
if type(e) == type({})
|
||||
try
|
||||
if e['source'] ==# 'pylint'
|
||||
let e['location']['character'] += 1
|
||||
endif
|
||||
|
||||
let msg =
|
||||
\ e['location']['path'] . ':' .
|
||||
\ e['location']['line'] . ':' .
|
||||
\ e['location']['character'] . ': ' .
|
||||
\ e['code'] . ' ' .
|
||||
\ e['message'] . ' ' .
|
||||
\ '[' . e['source'] . ']'
|
||||
|
||||
call add(out, msg)
|
||||
catch /\m^Vim\%((\a\+)\)\=:E716/
|
||||
call syntastic#log#warn('checker python/prospector: unknown error format')
|
||||
let out = []
|
||||
break
|
||||
endtry
|
||||
else
|
||||
call syntastic#log#warn('checker python/prospector: unknown error format')
|
||||
let out = []
|
||||
break
|
||||
endif
|
||||
endfor
|
||||
else
|
||||
call syntastic#log#warn('checker python/prospector: unknown error format')
|
||||
endif
|
||||
endif
|
||||
|
||||
return out
|
||||
endfunction " }}}2
|
||||
" @vimlint(EVL102, 0, l:true)
|
||||
" @vimlint(EVL102, 0, l:false)
|
||||
" @vimlint(EVL102, 0, l:null)
|
||||
|
||||
function! syntastic#preprocess#rparse(errors) abort " {{{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) abort " {{{2
|
||||
return map(copy(a:errors), 'substitute(v:val, ''\m^\(([^)]\+)\)\s\(.\+\)$'', ''\2 \1'', "")')
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#preprocess#validator(errors) abort " {{{2
|
||||
let out = []
|
||||
for e in a:errors
|
||||
let parts = matchlist(e, '\v^"([^"]+)"(.+)')
|
||||
if len(parts) >= 3
|
||||
" URL decode, except leave alone any "+"
|
||||
let parts[1] = substitute(parts[1], '\m%\(\x\x\)', '\=nr2char("0x".submatch(1))', 'g')
|
||||
let parts[1] = substitute(parts[1], '\m\\"', '"', 'g')
|
||||
let parts[1] = substitute(parts[1], '\m\\\\', '\\', 'g')
|
||||
call add(out, '"' . parts[1] . '"' . parts[2])
|
||||
endif
|
||||
endfor
|
||||
return out
|
||||
endfunction " }}}2
|
||||
|
||||
" @vimlint(EVL102, 1, l:true)
|
||||
" @vimlint(EVL102, 1, l:false)
|
||||
" @vimlint(EVL102, 1, l:null)
|
||||
function! syntastic#preprocess#vint(errors) abort " {{{2
|
||||
" JSON artifacts
|
||||
let true = 1
|
||||
let false = 0
|
||||
let null = ''
|
||||
|
||||
" A hat tip to Marc Weber for this trick
|
||||
" http://stackoverflow.com/questions/17751186/iterating-over-a-string-in-vimscript-or-parse-a-json-file/19105763#19105763
|
||||
try
|
||||
let errs = eval(join(a:errors, ''))
|
||||
catch
|
||||
let errs = []
|
||||
endtry
|
||||
|
||||
let out = []
|
||||
if type(errs) == type([])
|
||||
for e in errs
|
||||
if type(e) == type({})
|
||||
try
|
||||
let msg =
|
||||
\ e['file_path'] . ':' .
|
||||
\ e['line_number'] . ':' .
|
||||
\ e['column_number'] . ':' .
|
||||
\ e['severity'][0] . ': ' .
|
||||
\ e['description'] . ' (' .
|
||||
\ e['policy_name'] . ')'
|
||||
|
||||
call add(out, msg)
|
||||
catch /\m^Vim\%((\a\+)\)\=:E716/
|
||||
call syntastic#log#warn('checker vim/vint: unknown error format')
|
||||
let out = []
|
||||
break
|
||||
endtry
|
||||
else
|
||||
call syntastic#log#warn('checker vim/vint: unknown error format')
|
||||
let out = []
|
||||
break
|
||||
endif
|
||||
endfor
|
||||
else
|
||||
call syntastic#log#warn('checker vim/vint: unknown error format')
|
||||
endif
|
||||
|
||||
return out
|
||||
endfunction " }}}2
|
||||
" @vimlint(EVL102, 0, l:true)
|
||||
" @vimlint(EVL102, 0, l:false)
|
||||
" @vimlint(EVL102, 0, l:null)
|
||||
|
||||
" }}}1
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,414 @@
|
||||
if exists('g:loaded_syntastic_util_autoload') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_util_autoload = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
" Public functions {{{1
|
||||
|
||||
function! syntastic#util#isRunningWindows() abort " {{{2
|
||||
return has('win16') || has('win32') || has('win64')
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#util#DevNull() abort " {{{2
|
||||
if syntastic#util#isRunningWindows()
|
||||
return 'NUL'
|
||||
endif
|
||||
return '/dev/null'
|
||||
endfunction " }}}2
|
||||
|
||||
" Get directory separator
|
||||
function! syntastic#util#Slash() abort " {{{2
|
||||
return (!exists('+shellslash') || &shellslash) ? '/' : '\'
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#util#CygwinPath(path) abort " {{{2
|
||||
return substitute(syntastic#util#system('cygpath -m ' . syntastic#util#shescape(a:path)), "\n", '', 'g')
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#util#system(command) abort " {{{2
|
||||
let old_shell = &shell
|
||||
let old_lc_messages = $LC_MESSAGES
|
||||
let old_lc_all = $LC_ALL
|
||||
|
||||
let &shell = syntastic#util#var('shell')
|
||||
let $LC_MESSAGES = 'C'
|
||||
let $LC_ALL = ''
|
||||
|
||||
let out = system(a:command)
|
||||
|
||||
let $LC_ALL = old_lc_all
|
||||
let $LC_MESSAGES = old_lc_messages
|
||||
|
||||
let &shell = old_shell
|
||||
|
||||
return out
|
||||
endfunction " }}}2
|
||||
|
||||
" Create a temporary directory
|
||||
function! syntastic#util#tmpdir() abort " {{{2
|
||||
let tempdir = ''
|
||||
|
||||
if (has('unix') || has('mac')) && executable('mktemp')
|
||||
" TODO: option "-t" to mktemp(1) is not portable
|
||||
let tmp = $TMPDIR !=# '' ? $TMPDIR : $TMP !=# '' ? $TMP : '/tmp'
|
||||
let out = split(syntastic#util#system('mktemp -q -d ' . tmp . '/vim-syntastic-' . getpid() . '-XXXXXXXX'), "\n")
|
||||
if v:shell_error == 0 && len(out) == 1
|
||||
let tempdir = out[0]
|
||||
endif
|
||||
endif
|
||||
|
||||
if tempdir ==# ''
|
||||
if has('win32') || has('win64')
|
||||
let tempdir = $TEMP . syntastic#util#Slash() . 'vim-syntastic-' . getpid()
|
||||
elseif has('win32unix')
|
||||
let tempdir = syntastic#util#CygwinPath('/tmp/vim-syntastic-' . getpid())
|
||||
elseif $TMPDIR !=# ''
|
||||
let tempdir = $TMPDIR . '/vim-syntastic-' . getpid()
|
||||
else
|
||||
let tempdir = '/tmp/vim-syntastic-' . getpid()
|
||||
endif
|
||||
|
||||
try
|
||||
call mkdir(tempdir, 'p', 0700)
|
||||
catch /\m^Vim\%((\a\+)\)\=:E739/
|
||||
call syntastic#log#error(v:exception)
|
||||
let tempdir = '.'
|
||||
endtry
|
||||
endif
|
||||
|
||||
return tempdir
|
||||
endfunction " }}}2
|
||||
|
||||
" Recursively remove a directory
|
||||
function! syntastic#util#rmrf(what) abort " {{{2
|
||||
" try to make sure we don't delete directories we didn't create
|
||||
if a:what !~? 'vim-syntastic-'
|
||||
return
|
||||
endif
|
||||
|
||||
if getftype(a:what) ==# 'dir'
|
||||
if !exists('s:rmrf')
|
||||
let s:rmrf =
|
||||
\ has('unix') || has('mac') ? 'rm -rf' :
|
||||
\ has('win32') || has('win64') ? 'rmdir /S /Q' :
|
||||
\ has('win16') || has('win95') || has('dos16') || has('dos32') ? 'deltree /Y' : ''
|
||||
endif
|
||||
|
||||
if s:rmrf !=# ''
|
||||
silent! call syntastic#util#system(s:rmrf . ' ' . syntastic#util#shescape(a:what))
|
||||
else
|
||||
call s:_rmrf(a:what)
|
||||
endif
|
||||
else
|
||||
silent! call delete(a:what)
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
"search the first 5 lines of the file for a magic number and return a map
|
||||
"containing the args and the executable
|
||||
"
|
||||
"e.g.
|
||||
"
|
||||
"#!/usr/bin/perl -f -bar
|
||||
"
|
||||
"returns
|
||||
"
|
||||
"{'exe': '/usr/bin/perl', 'args': ['-f', '-bar']}
|
||||
function! syntastic#util#parseShebang() abort " {{{2
|
||||
for lnum in range(1, 5)
|
||||
let line = getline(lnum)
|
||||
if line =~# '^#!'
|
||||
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
|
||||
|
||||
return { 'exe': '', 'args': [] }
|
||||
endfunction " }}}2
|
||||
|
||||
" Get the value of a variable. Allow local variables to override global ones.
|
||||
function! syntastic#util#var(name, ...) abort " {{{2
|
||||
return
|
||||
\ exists('b:syntastic_' . a:name) ? b:syntastic_{a:name} :
|
||||
\ exists('g:syntastic_' . a:name) ? g:syntastic_{a:name} :
|
||||
\ a:0 > 0 ? a:1 : ''
|
||||
endfunction " }}}2
|
||||
|
||||
" Parse a version string. Return an array of version components.
|
||||
function! syntastic#util#parseVersion(version, ...) abort " {{{2
|
||||
return map(split(matchstr( a:version, a:0 ? a:1 : '\v^\D*\zs\d+(\.\d+)+\ze' ), '\m\.'), 'str2nr(v:val)')
|
||||
endfunction " }}}2
|
||||
|
||||
" Verify that the 'installed' version is at least the 'required' version.
|
||||
"
|
||||
" 'installed' and 'required' must be arrays. If they have different lengths,
|
||||
" the "missing" elements will be assumed to be 0 for the purposes of checking.
|
||||
"
|
||||
" See http://semver.org for info about version numbers.
|
||||
function! syntastic#util#versionIsAtLeast(installed, required) abort " {{{2
|
||||
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) abort " {{{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
|
||||
" still here, thus everything matched
|
||||
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
|
||||
|
||||
function! syntastic#util#screenWidth(str, tabstop) abort " {{{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
|
||||
|
||||
"print as much of a:msg as possible without "Press Enter" prompt appearing
|
||||
function! syntastic#util#wideMsg(msg) abort " {{{2
|
||||
let old_ruler = &ruler
|
||||
let old_showcmd = &showcmd
|
||||
|
||||
"This is here because it is possible for some error messages to
|
||||
"begin with \n which will cause a "press enter" prompt.
|
||||
let msg = substitute(a:msg, "\n", '', 'g')
|
||||
|
||||
"convert tabs to spaces so that the tabs count towards the window
|
||||
"width as the proper amount of characters
|
||||
let chunks = split(msg, "\t", 1)
|
||||
let msg = join(map(chunks[:-2], 'v:val . repeat(" ", &tabstop - s:_width(v:val) % &tabstop)'), '') . chunks[-1]
|
||||
let msg = strpart(msg, 0, &columns - 1)
|
||||
|
||||
set noruler noshowcmd
|
||||
call syntastic#util#redraw(0)
|
||||
|
||||
echo msg
|
||||
|
||||
let &ruler = old_ruler
|
||||
let &showcmd = old_showcmd
|
||||
endfunction " }}}2
|
||||
|
||||
" Check whether a buffer is loaded, listed, and not hidden
|
||||
function! syntastic#util#bufIsActive(buffer) abort " {{{2
|
||||
" convert to number, or hell breaks loose
|
||||
let buf = str2nr(a:buffer)
|
||||
|
||||
if !bufloaded(buf) || !buflisted(buf)
|
||||
return 0
|
||||
endif
|
||||
|
||||
" get rid of hidden buffers
|
||||
for tab in range(1, tabpagenr('$'))
|
||||
if index(tabpagebuflist(tab), buf) >= 0
|
||||
return 1
|
||||
endif
|
||||
endfor
|
||||
|
||||
return 0
|
||||
endfunction " }}}2
|
||||
|
||||
" start in directory a:where and walk up the parent folders until it
|
||||
" finds a file matching a:what; return path to that file
|
||||
function! syntastic#util#findInParent(what, where) abort " {{{2
|
||||
let here = fnamemodify(a:where, ':p')
|
||||
|
||||
let root = syntastic#util#Slash()
|
||||
if syntastic#util#isRunningWindows() && here[1] ==# ':'
|
||||
" The drive letter is an ever-green source of fun. That's because
|
||||
" we don't care about running syntastic on Amiga these days. ;)
|
||||
let root = fnamemodify(root, ':p')
|
||||
let root = here[0] . root[1:]
|
||||
endif
|
||||
|
||||
let old = ''
|
||||
while here !=# ''
|
||||
let p = split(globpath(here, a:what, 1), '\n')
|
||||
|
||||
if !empty(p)
|
||||
return fnamemodify(p[0], ':p')
|
||||
elseif here ==? root || here ==? old
|
||||
break
|
||||
endif
|
||||
|
||||
let old = here
|
||||
|
||||
" we use ':h:h' rather than ':h' since ':p' adds a trailing '/'
|
||||
" if 'here' is a directory
|
||||
let here = fnamemodify(here, ':p:h:h')
|
||||
endwhile
|
||||
|
||||
return ''
|
||||
endfunction " }}}2
|
||||
|
||||
" Returns unique elements in a list
|
||||
function! syntastic#util#unique(list) abort " {{{2
|
||||
let seen = {}
|
||||
let uniques = []
|
||||
for e in a:list
|
||||
if !has_key(seen, e)
|
||||
let seen[e] = 1
|
||||
call add(uniques, e)
|
||||
endif
|
||||
endfor
|
||||
return uniques
|
||||
endfunction " }}}2
|
||||
|
||||
" A less noisy shellescape()
|
||||
function! syntastic#util#shescape(string) abort " {{{2
|
||||
return a:string =~# '\m^[A-Za-z0-9_/.-]\+$' ? a:string : shellescape(a:string)
|
||||
endfunction " }}}2
|
||||
|
||||
" A less noisy shellescape(expand())
|
||||
function! syntastic#util#shexpand(string, ...) abort " {{{2
|
||||
return syntastic#util#shescape(a:0 ? expand(a:string, a:1) : expand(a:string, 1))
|
||||
endfunction " }}}2
|
||||
|
||||
" Escape arguments
|
||||
function! syntastic#util#argsescape(opt) abort " {{{2
|
||||
if type(a:opt) == type('') && a:opt !=# ''
|
||||
return [a:opt]
|
||||
elseif type(a:opt) == type([])
|
||||
return map(copy(a:opt), 'syntastic#util#shescape(v:val)')
|
||||
endif
|
||||
|
||||
return []
|
||||
endfunction " }}}2
|
||||
|
||||
" decode XML entities
|
||||
function! syntastic#util#decodeXMLEntities(string) abort " {{{2
|
||||
let str = a:string
|
||||
let str = substitute(str, '\m<', '<', 'g')
|
||||
let str = substitute(str, '\m>', '>', 'g')
|
||||
let str = substitute(str, '\m"', '"', 'g')
|
||||
let str = substitute(str, '\m'', "'", 'g')
|
||||
let str = substitute(str, '\m&', '\&', 'g')
|
||||
return str
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#util#redraw(full) abort " {{{2
|
||||
if a:full
|
||||
redraw!
|
||||
else
|
||||
redraw
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! syntastic#util#dictFilter(errors, filter) abort " {{{2
|
||||
let rules = s:_translateFilter(a:filter)
|
||||
" call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, "applying filter:", rules)
|
||||
try
|
||||
call filter(a:errors, rules)
|
||||
catch /\m^Vim\%((\a\+)\)\=:E/
|
||||
let msg = matchstr(v:exception, '\m^Vim\%((\a\+)\)\=:\zs.*')
|
||||
call syntastic#log#error('quiet_messages: ' . msg)
|
||||
endtry
|
||||
endfunction " }}}2
|
||||
|
||||
" Return a [seconds, fractions] list of strings, representing the
|
||||
" (hopefully high resolution) time since program start
|
||||
function! syntastic#util#stamp() abort " {{{2
|
||||
return split( split(reltimestr(reltime(g:_SYNTASTIC_START)))[0], '\.' )
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private functions {{{1
|
||||
|
||||
function! s:_translateFilter(filters) abort " {{{2
|
||||
let conditions = []
|
||||
for k in keys(a:filters)
|
||||
if type(a:filters[k]) == type([])
|
||||
call extend(conditions, map(copy(a:filters[k]), 's:_translateElement(k, v:val)'))
|
||||
else
|
||||
call add(conditions, s:_translateElement(k, a:filters[k]))
|
||||
endif
|
||||
endfor
|
||||
|
||||
if conditions == []
|
||||
let conditions = ['1']
|
||||
endif
|
||||
return len(conditions) == 1 ? conditions[0] : join(map(conditions, '"(" . v:val . ")"'), ' && ')
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_translateElement(key, term) abort " {{{2
|
||||
let fkey = a:key
|
||||
if fkey[0] ==# '!'
|
||||
let fkey = fkey[1:]
|
||||
let not = 1
|
||||
else
|
||||
let not = 0
|
||||
endif
|
||||
|
||||
if fkey ==? 'level'
|
||||
let op = not ? ' ==? ' : ' !=? '
|
||||
let ret = 'v:val["type"]' . op . string(a:term[0])
|
||||
elseif fkey ==? 'type'
|
||||
if a:term ==? 'style'
|
||||
let op = not ? ' ==? ' : ' !=? '
|
||||
let ret = 'get(v:val, "subtype", "")' . op . '"style"'
|
||||
else
|
||||
let op = not ? '!' : ''
|
||||
let ret = op . 'has_key(v:val, "subtype")'
|
||||
endif
|
||||
elseif fkey ==? 'regex'
|
||||
let op = not ? ' =~? ' : ' !~? '
|
||||
let ret = 'v:val["text"]' . op . string(a:term)
|
||||
elseif fkey ==? 'file' || fkey[:4] ==? 'file:'
|
||||
let op = not ? ' =~# ' : ' !~# '
|
||||
let ret = 'bufname(str2nr(v:val["bufnr"]))'
|
||||
let mod = fkey[4:]
|
||||
if mod !=# ''
|
||||
let ret = 'fnamemodify(' . ret . ', ' . string(mod) . ')'
|
||||
endif
|
||||
let ret .= op . string(a:term)
|
||||
else
|
||||
call syntastic#log#warn('quiet_messages: ignoring invalid key ' . strtrans(string(fkey)))
|
||||
let ret = '1'
|
||||
endif
|
||||
return ret
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_rmrf(what) abort " {{{2
|
||||
if !exists('s:rmdir')
|
||||
let s:rmdir = syntastic#util#shescape(get(g:, 'netrw_localrmdir', 'rmdir'))
|
||||
endif
|
||||
|
||||
if getftype(a:what) ==# 'dir'
|
||||
if filewritable(a:what) != 2
|
||||
return
|
||||
endif
|
||||
|
||||
for f in split(globpath(a:what, '*', 1), "\n")
|
||||
call s:_rmrf(f)
|
||||
endfor
|
||||
silent! call syntastic#util#system(s:rmdir . ' ' . syntastic#util#shescape(a:what))
|
||||
else
|
||||
silent! call delete(a:what)
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,956 @@
|
||||
*syntastic.txt* Syntax checking on the fly has never been so pimp.
|
||||
*syntastic*
|
||||
|
||||
|
||||
It's a bird! It's a plane! ZOMG It's ... ~
|
||||
|
||||
_____ __ __ _ ~
|
||||
/ ___/__ ______ / /_____ ______/ /_(_)____ ~
|
||||
\__ \/ / / / __ \/ __/ __ `/ ___/ __/ / ___/ ~
|
||||
___/ / /_/ / / / / /_/ /_/ (__ ) /_/ / /__ ~
|
||||
/____/\__, /_/ /_/\__/\__,_/____/\__/_/\___/ ~
|
||||
/____/ ~
|
||||
|
||||
|
||||
|
||||
Reference Manual~
|
||||
|
||||
|
||||
==============================================================================
|
||||
CONTENTS *syntastic-contents*
|
||||
|
||||
1.Intro........................................|syntastic-intro|
|
||||
1.1.Quick start............................|syntastic-quickstart|
|
||||
1.2.Recommended settings...................|syntastic-recommended|
|
||||
2.Functionality provided.......................|syntastic-functionality|
|
||||
2.1.The statusline flag....................|syntastic-statusline-flag|
|
||||
2.2.Error signs............................|syntastic-error-signs|
|
||||
2.3.Error window...........................|syntastic-error-window|
|
||||
2.4.Error highlighting.....................|syntastic-highlighting|
|
||||
2.5.Aggregating errors.....................|syntastic-aggregating-errors|
|
||||
2.6.Filtering errors.......................|syntastic-filtering-errors|
|
||||
3.Commands.....................................|syntastic-commands|
|
||||
4.Global Options...............................|syntastic-global-options|
|
||||
5.Checker Options..............................|syntastic-checker-options|
|
||||
5.1.Choosing which checkers to use.........|syntastic-filetype-checkers|
|
||||
5.2.Choosing the executable................|syntastic-config-exec|
|
||||
5.3.Configuring specific checkers..........|syntastic-config-makeprg|
|
||||
5.4.Sorting errors.........................|syntastic-config-sort|
|
||||
6.Notes........................................|syntastic-notes|
|
||||
6.1.Handling of composite filetypes........|syntastic-composite|
|
||||
6.2.Editing files over network.............|syntastic-netrw|
|
||||
6.3.The 'shellslash' option................|syntastic-shellslash|
|
||||
7.Compatibility with other software............|syntastic-compatibility|
|
||||
7.1.The csh and tcsh shells................|syntastic-csh|
|
||||
7.2.Eclim..................................|syntastic-eclim|
|
||||
7.3.The fish shell.........................|syntastic-fish|
|
||||
7.4.The fizsh shell........................|syntastic-fizsh|
|
||||
7.5.powerline..............................|syntastic-powerline|
|
||||
7.6.The PowerShell shell...................|syntastic-powershell|
|
||||
7.7.python-mode............................|syntastic-pymode|
|
||||
7.8.vim-auto-save..........................|syntastic-vim-auto-save|
|
||||
7.9.vim-go.................................|syntastic-vim-go|
|
||||
7.10.vim-virtualenv........................|syntastic-vim-virtualenv|
|
||||
7.11.YouCompleteMe.........................|syntastic-ycm|
|
||||
8.About........................................|syntastic-about|
|
||||
9.License......................................|syntastic-license|
|
||||
|
||||
|
||||
==============================================================================
|
||||
1. Intro *syntastic-intro*
|
||||
|
||||
Syntastic is a syntax checking plugin that runs files through external syntax
|
||||
checkers. This can be done on demand, or automatically as files are saved and
|
||||
opened. If syntax errors are detected, the user is notified and is happy
|
||||
because they didn't have to compile their code or execute their script to find
|
||||
them.
|
||||
|
||||
Syntastic comes in two parts: the syntax checker plugins, and the core. The
|
||||
syntax checker plugins are defined on a per-filetype basis where each one wraps
|
||||
up an external syntax checking program. The core script delegates off to these
|
||||
plugins and uses their output to provide the syntastic functionality.
|
||||
|
||||
Take a look at the wiki for a list of supported filetypes and checkers:
|
||||
|
||||
https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
|
||||
|
||||
Note: This doc only deals with using syntastic. To learn how to write syntax
|
||||
checker integrations, see the guide on the GitHub wiki:
|
||||
|
||||
https://github.com/scrooloose/syntastic/wiki/Syntax-Checker-Guide
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
1.1. Quick start *syntastic-quickstart*
|
||||
|
||||
Syntastic comes preconfigured with a default list of enabled checkers per
|
||||
filetype. This list is kept reasonably short to prevent slowing down Vim or
|
||||
trying to use conflicting checkers.
|
||||
|
||||
You can see the list of checkers available for the current filetype with the
|
||||
|:SyntasticInfo| command.
|
||||
|
||||
You probably want to override the configured list of checkers for the
|
||||
filetypes you use, and also change the arguments passed to specific checkers
|
||||
to suit your needs. See |syntastic-checker-options| below for details.
|
||||
|
||||
Use |:SyntasticCheck| to manually check right now. Use |:Errors| to open the
|
||||
|location-list| window, and |:lclose| to close it. You can clear the error
|
||||
list with |:SyntasticReset|, and you can use |:SyntasticToggleMode| to switch
|
||||
between active (checking on writing the buffer) and passive (manual) checking.
|
||||
|
||||
You don't have to switch focus to the |location-list| window to jump to the
|
||||
different errors. Vim provides several built-in commands for this, for
|
||||
example |:lnext| and |:lprevious|. You may want to add shortcut mappings for
|
||||
these commands, or perhaps install a plugin such as Tim Pope's 'unimpaired'
|
||||
(see https://github.com/tpope/vim-unimpaired) that provides such mappings.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
1.2. Recommended settings *syntastic-recommended*
|
||||
|
||||
Syntastic has a large number of options that can be configured, and the
|
||||
defaults are not particularly well suitable for new users. It is recommended
|
||||
that you start by adding the following lines to your vimrc, and return to them
|
||||
later as needed: >
|
||||
set statusline+=%#warningmsg#
|
||||
set statusline+=%{SyntasticStatuslineFlag()}
|
||||
set statusline+=%*
|
||||
|
||||
let g:syntastic_always_populate_loc_list = 1
|
||||
let g:syntastic_auto_loc_list = 1
|
||||
let g:syntastic_check_on_open = 1
|
||||
let g:syntastic_check_on_wq = 0
|
||||
<
|
||||
==============================================================================
|
||||
2. Functionality provided *syntastic-functionality*
|
||||
|
||||
Syntax checking can be done automatically or on demand (see
|
||||
|'syntastic_mode_map'| and |:SyntasticToggleMode| for configuring this).
|
||||
|
||||
When syntax checking is done, the features below can be used to notify the
|
||||
user of errors. See |syntastic-global-options| for how to configure and
|
||||
activate/deactivate these features.
|
||||
|
||||
* A statusline flag
|
||||
* Signs beside lines with errors
|
||||
* The |location-list| can be populated with the errors for the associated
|
||||
buffer
|
||||
* Erroneous parts of lines can be highlighted (this functionality is only
|
||||
provided by some syntax checkers)
|
||||
* Balloons (if the |+balloon_eval| feature is compiled in) can be used to
|
||||
display error messages for erroneous lines when hovering the mouse over
|
||||
them
|
||||
* Error messages from multiple checkers can be aggregated in a single list
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
2.1. The statusline flag *syntastic-statusline-flag*
|
||||
|
||||
To use the statusline flag, this must appear in your |'statusline'| setting >
|
||||
%{SyntasticStatuslineFlag()}
|
||||
<
|
||||
Something like this could be more useful: >
|
||||
set statusline+=%#warningmsg#
|
||||
set statusline+=%{SyntasticStatuslineFlag()}
|
||||
set statusline+=%*
|
||||
<
|
||||
When syntax errors are detected a flag will be shown. The content of the flag
|
||||
is derived from the |syntastic_stl_format| option.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
2.2. Error signs *syntastic-error-signs*
|
||||
|
||||
Syntastic uses the |:sign| commands to mark lines with errors and warnings in
|
||||
the sign column. To enable this feature, use the |'syntastic_enable_signs'|
|
||||
option.
|
||||
|
||||
Signs are colored using the Error and Todo syntax highlight groups by default.
|
||||
If you wish to customize the colors for the signs, you can use the following
|
||||
groups:
|
||||
SyntasticErrorSign - For syntax errors, links to 'error' by default
|
||||
SyntasticWarningSign - For syntax warnings, links to 'todo' by default
|
||||
SyntasticStyleErrorSign - For style errors, links to 'SyntasticErrorSign'
|
||||
by default
|
||||
SyntasticStyleWarningSign - For style warnings, links to
|
||||
'SyntasticWarningSign' by default
|
||||
|
||||
Example: >
|
||||
highlight SyntasticErrorSign guifg=white guibg=red
|
||||
<
|
||||
To set up highlighting for the line where a sign resides, you can use the
|
||||
following highlight groups:
|
||||
SyntasticErrorLine
|
||||
SyntasticWarningLine
|
||||
SyntasticStyleErrorLine - Links to 'SyntasticErrorLine' by default
|
||||
SyntasticStyleWarningLine - Links to 'SyntasticWarningLine' by default
|
||||
|
||||
Example: >
|
||||
highlight SyntasticErrorLine guibg=#2f0000
|
||||
<
|
||||
------------------------------------------------------------------------------
|
||||
2.3. The error window *syntastic-error-window*
|
||||
|
||||
You can use the |:Errors| command to display the errors for the current buffer
|
||||
in the |location-list|.
|
||||
|
||||
Note that when you use |:Errors| the current location list is overwritten with
|
||||
Syntastic's own location list. The location list is also overwritten when
|
||||
|syntastic_auto_jump| is non-zero and the cursor has to jump to an issue.
|
||||
|
||||
By default syntastic doesn't fill the |location-list| with the errors found by
|
||||
the checkers, in order to reduce clashes with other plugins. Consequently, if
|
||||
you run |:lopen| or |:lwindow| rather than |:Errors| to open the error window you
|
||||
wouldn't see syntastic's list of errors. If you insist on using |:lopen| or
|
||||
|:lwindow| you should either run |:SyntasticSetLoclist| after running the checks,
|
||||
or set |syntastic_always_populate_loc_list| which tells syntastic to update the
|
||||
|location-list| automatically.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
2.4. Error highlighting *syntastic-highlighting*
|
||||
|
||||
Some checkers provide enough information for syntastic to be able to highlight
|
||||
errors. By default the SpellBad syntax highlight group is used to color errors,
|
||||
and the SpellCap group is used for warnings. If you wish to customize the
|
||||
colors for highlighting you can use the following groups:
|
||||
SyntasticError - Links to 'SpellBad' by default
|
||||
SyntasticWarning - Links to 'SpellCap' by default
|
||||
SyntasticStyleError - Links to SyntasticError by default
|
||||
SyntasticStyleWarning - Links to SyntasticWarning by default
|
||||
|
||||
Example: >
|
||||
highlight SyntasticError guibg=#2f0000
|
||||
<
|
||||
------------------------------------------------------------------------------
|
||||
2.5. Aggregating errors *syntastic-aggregating-errors*
|
||||
|
||||
By default, namely if |'syntastic_aggregate_errors'| is unset, syntastic runs
|
||||
in turn the checkers corresponding to the filetype of the current file (see
|
||||
|syntastic-filetype-checkers|), and stops as soon as a checker reports any
|
||||
errors. It then notifies you of the errors using the notification mechanisms
|
||||
above. In this mode error lists are always produced by a single checker, and,
|
||||
if you open the error window, the name of the checker that generated the errors
|
||||
is shown on the statusline of the error window.
|
||||
|
||||
If |'syntastic_aggregate_errors'| is set, syntastic runs all checkers that
|
||||
apply (still cf. |syntastic-filetype-checkers|), then aggregates errors found
|
||||
by all checkers in a single list, and notifies you. In this mode each error
|
||||
message is labeled with the name of the checker that generated it, but you can
|
||||
disable 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, and sorting within each group is decided by the variables
|
||||
|'syntastic_<filetype>_<checker>_sort'|.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
2.6 Filtering errors *syntastic-filtering-errors*
|
||||
|
||||
You can selectively disable some of the errors found by checkers either
|
||||
using |'syntastic_quiet_messages'|, or by specifying a list of patterns in
|
||||
|'syntastic_ignore_files'|.
|
||||
|
||||
See also: |'syntastic_<filetype>_<checker>_quiet_messages'|.
|
||||
|
||||
==============================================================================
|
||||
3. Commands *syntastic-commands*
|
||||
|
||||
:Errors *:Errors*
|
||||
|
||||
When errors have been detected, use this command to pop up the |location-list|
|
||||
and display the error messages.
|
||||
|
||||
Please note that the |:Errors| command overwrites the current location list with
|
||||
syntastic's own location list.
|
||||
|
||||
:SyntasticToggleMode *:SyntasticToggleMode*
|
||||
|
||||
Toggles syntastic between active and passive mode. See |'syntastic_mode_map'|
|
||||
for more info.
|
||||
|
||||
:SyntasticCheck *:SyntasticCheck*
|
||||
|
||||
Manually cause a syntax check to be done. By default the checkers in the
|
||||
|'g:syntastic_<filetype>_checkers'| or |'b:syntastic_checkers'| lists are run,
|
||||
cf. |syntastic-filetype-checkers|. If |syntastic_aggregate_errors| is unset
|
||||
(which is the default), checking stops the first time a checker reports any
|
||||
errors; if |syntastic_aggregate_errors| is set, all checkers that apply are run
|
||||
in turn, and all errors found are aggregated in a single list.
|
||||
|
||||
The command may be followed by a (space separated) list of checkers. In this
|
||||
case |'g:syntastic_<filetype>_checkers'| and |'b:syntastic_checkers'| are
|
||||
ignored, and the checkers named by the command's arguments are run instead, in
|
||||
the order specified. The rules of |syntastic_aggregate_errors| still apply.
|
||||
|
||||
Example: >
|
||||
:SyntasticCheck flake8 pylint
|
||||
<
|
||||
:SyntasticInfo *:SyntasticInfo*
|
||||
|
||||
The command takes an optional argument, and outputs information about the
|
||||
checkers available for the filetype named by said argument, or for the current
|
||||
filetype if no argument was provided.
|
||||
|
||||
:SyntasticReset *:SyntasticReset*
|
||||
|
||||
Resets the list of errors and turns off all error notifiers.
|
||||
|
||||
:SyntasticSetLoclist *:SyntasticSetLoclist*
|
||||
|
||||
If |'syntastic_always_populate_loc_list'| is not set, the |location-list| is
|
||||
not filled in automatically with the list of errors detected by the checkers.
|
||||
This is useful if you run syntastic along with other plugins that use location
|
||||
lists. The |:SyntasticSetLoclist| command allows you to stick the errors into
|
||||
the location list explicitly.
|
||||
|
||||
==============================================================================
|
||||
4. Global Options *syntastic-global-options*
|
||||
|
||||
|
||||
*'syntastic_check_on_open'*
|
||||
Default: 0
|
||||
If enabled, syntastic will do syntax checks when buffers are first loaded as
|
||||
well as on saving >
|
||||
let g:syntastic_check_on_open = 1
|
||||
<
|
||||
*'syntastic_check_on_wq'*
|
||||
Default: 1
|
||||
Normally syntastic runs syntax checks whenever buffers are written to disk.
|
||||
If you want to skip these checks when you issue |:wq|, |:x|, and |:ZZ|, set this
|
||||
variable to 0. >
|
||||
let g:syntastic_check_on_wq = 0
|
||||
<
|
||||
*'syntastic_aggregate_errors'*
|
||||
Default: 0
|
||||
When enabled, syntastic runs all checkers that apply to the current filetype,
|
||||
then aggregates errors found by all checkers and displays them. When disabled,
|
||||
syntastic runs each checker in turn, and stops to display the results the first
|
||||
time a checker finds any errors. >
|
||||
let g:syntastic_aggregate_errors = 1
|
||||
<
|
||||
*'syntastic_id_checkers'*
|
||||
Default: 1
|
||||
When results from multiple checkers are aggregated in a single error list
|
||||
(that is either when |syntastic_aggregate_errors| is enabled, or when checking
|
||||
a file with a composite filetype), it might not be immediately obvious which
|
||||
checker has produced a given error message. This variable instructs syntastic
|
||||
to label error messages with the names of the checkers that created them. >
|
||||
let g:syntastic_id_checkers = 0
|
||||
<
|
||||
*'syntastic_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
|
||||
If enabled, syntastic will echo current error to the command window. If
|
||||
multiple errors are found on the same line, |syntastic_cursor_columns| is used
|
||||
to decide which one is shown. >
|
||||
let g:syntastic_echo_current_error = 1
|
||||
<
|
||||
*'syntastic_cursor_columns'*
|
||||
Default: 1
|
||||
This option controls which errors are echoed to the command window if
|
||||
|syntastic_echo_current_error| is set and multiple errors are found on the same
|
||||
line. When the option is enabled, the first error corresponding to the current
|
||||
column is show. Otherwise, the first error on the current line is echoed,
|
||||
regardless of the cursor position on the current line.
|
||||
|
||||
When dealing with very large lists of errors, disabling this option can speed
|
||||
up navigation significantly: >
|
||||
let g:syntastic_cursor_column = 0
|
||||
<
|
||||
*'syntastic_enable_signs'*
|
||||
Default: 1
|
||||
Use this option to tell syntastic whether to use the |:sign| interface to mark
|
||||
syntax errors: >
|
||||
let g:syntastic_enable_signs = 1
|
||||
<
|
||||
*'syntastic_error_symbol'* *'syntastic_style_error_symbol'*
|
||||
*'syntastic_warning_symbol'* *'syntastic_style_warning_symbol'*
|
||||
Use this option to control what the syntastic |:sign| text contains. Several
|
||||
error symbols can be customized:
|
||||
syntastic_error_symbol - For syntax errors, defaults to '>>'
|
||||
syntastic_style_error_symbol - For style errors, defaults to 'S>'
|
||||
syntastic_warning_symbol - For syntax warnings, defaults to '>>'
|
||||
syntastic_style_warning_symbol - For style warnings, defaults to 'S>'
|
||||
|
||||
Example: >
|
||||
let g:syntastic_error_symbol = "✗"
|
||||
let g:syntastic_warning_symbol = "⚠"
|
||||
<
|
||||
*'syntastic_enable_balloons'*
|
||||
Default: 1
|
||||
Use this option to tell syntastic whether to display error messages in balloons
|
||||
when the mouse is hovered over erroneous lines: >
|
||||
let g:syntastic_enable_balloons = 1
|
||||
<
|
||||
Note that Vim must be compiled with |+balloon_eval|.
|
||||
|
||||
*'syntastic_enable_highlighting'*
|
||||
Default: 1
|
||||
Use this option to tell syntastic whether to use syntax highlighting to mark
|
||||
errors (where possible). Highlighting can be turned off with the following >
|
||||
let g:syntastic_enable_highlighting = 0
|
||||
<
|
||||
*'syntastic_always_populate_loc_list'*
|
||||
Default: 0
|
||||
Enable this option to tell syntastic to always stick any detected errors into
|
||||
the |location-list|: >
|
||||
let g:syntastic_always_populate_loc_list = 1
|
||||
<
|
||||
*'syntastic_auto_jump'*
|
||||
Default: 0
|
||||
Enable this option if you want the cursor to jump to the first detected issue
|
||||
when saving or opening a file.
|
||||
|
||||
When set to 0 the cursor won't jump automatically. >
|
||||
let g:syntastic_auto_jump = 0
|
||||
<
|
||||
When set to 1 the cursor will always jump to the first issue detected,
|
||||
regardless of type. >
|
||||
let g:syntastic_auto_jump = 1
|
||||
<
|
||||
When set to 2 the cursor will jump to the first issue detected, but only if
|
||||
this issue is an error. >
|
||||
let g:syntastic_auto_jump = 2
|
||||
<
|
||||
When set to 3 the cursor will jump to the first error detected, if any. If
|
||||
all issues detected are warnings, the cursor won't jump. >
|
||||
let g:syntastic_auto_jump = 3
|
||||
<
|
||||
*'syntastic_auto_loc_list'*
|
||||
Default: 2
|
||||
Use this option to tell syntastic to automatically open and/or close the
|
||||
|location-list| (see |syntastic-error-window|).
|
||||
|
||||
When set to 0 the error window will not be opened or closed automatically. >
|
||||
let g:syntastic_auto_loc_list = 0
|
||||
<
|
||||
When set to 1 the error window will be automatically opened when errors are
|
||||
detected, and closed when none are detected. >
|
||||
let g:syntastic_auto_loc_list = 1
|
||||
<
|
||||
When set to 2 the error window will be automatically closed when no errors are
|
||||
detected, but not opened automatically. >
|
||||
let g:syntastic_auto_loc_list = 2
|
||||
<
|
||||
*'syntastic_loc_list_height'*
|
||||
Default: 10
|
||||
Use this option to specify the height of the location lists that syntastic
|
||||
opens. >
|
||||
let g:syntastic_loc_list_height = 5
|
||||
<
|
||||
*'syntastic_ignore_files'*
|
||||
Default: []
|
||||
Use this option to specify files that syntastic should never check. It's a
|
||||
list of |regular-expression| patterns. The full paths of files (see |::p|) are
|
||||
matched against these patterns, and the matches are case sensitive. Use |\c|
|
||||
to specify case insensitive patterns. Example: >
|
||||
let g:syntastic_ignore_files = ['\m^/usr/include/', '\m\c\.h$']
|
||||
<
|
||||
*'syntastic_filetype_map'*
|
||||
Default: {}
|
||||
Use this option to map non-standard filetypes to standard ones. Corresponding
|
||||
checkers are mapped accordingly, which allows syntastic to check files with
|
||||
non-standard filetypes: >
|
||||
let g:syntastic_filetype_map = {
|
||||
\ "latex": "tex",
|
||||
\ "gentoo-metadata": "xml" }
|
||||
<
|
||||
Composite filetypes can also be mapped to simple types, which disables the
|
||||
default behaviour of running both checkers against the input file: >
|
||||
let g:syntastic_filetype_map = { "handlebars.html": "handlebars" }
|
||||
<
|
||||
*'syntastic_mode_map'*
|
||||
Default: { "mode": "active",
|
||||
"active_filetypes": [],
|
||||
"passive_filetypes": [] }
|
||||
Use this option to fine tune when automatic syntax checking is done (or not
|
||||
done).
|
||||
|
||||
The option should be set to something like: >
|
||||
|
||||
let g:syntastic_mode_map = {
|
||||
\ "mode": "active",
|
||||
\ "active_filetypes": ["ruby", "php"],
|
||||
\ "passive_filetypes": ["puppet"] }
|
||||
<
|
||||
"mode" can be mapped to one of two values - "active" or "passive". When set
|
||||
to "active", syntastic does automatic checking whenever a buffer is saved or
|
||||
initially opened. When set to "passive" syntastic only checks when the user
|
||||
calls |:SyntasticCheck|.
|
||||
|
||||
The exceptions to these rules are defined with "active_filetypes" and
|
||||
"passive_filetypes". In passive mode, automatic checks are still done for
|
||||
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.
|
||||
|
||||
If local variable |'b:syntastic_mode'| is defined its value takes precedence
|
||||
over all calculations involving |'syntastic_mode_map'| for the corresponding
|
||||
buffer.
|
||||
|
||||
At runtime, the |:SyntasticToggleMode| command can be used to switch between
|
||||
active and passive modes.
|
||||
|
||||
*'b:syntastic_mode'*
|
||||
Default: unset
|
||||
Only the local form |'b:syntastic_mode'| is used. When set to either "active"
|
||||
or "passive", it takes precedence over |'syntastic_mode_map'| when deciding
|
||||
whether the corresponding buffer should be checked automatically.
|
||||
|
||||
*'syntastic_quiet_messages'*
|
||||
Default: {}
|
||||
Use this option to filter out some of the messages produced by checkers. The
|
||||
option should be set to something like: >
|
||||
let g:syntastic_quiet_messages = {
|
||||
\ "!level": "errors",
|
||||
\ "type": "style",
|
||||
\ "regex": '\m\[C03\d\d\]',
|
||||
\ "file:p": ['\m^/usr/include/', '\m\c\.h$'] }
|
||||
<
|
||||
Each element turns off messages matching the patterns specified by the
|
||||
corresponding value. Values are lists, but if a list consist of a single
|
||||
element you may omit the brackets (e.g. you may write "style" instead of
|
||||
["style"]). Elements with values [] or '' are ignored (this is useful for
|
||||
overriding filters, cf. |filter-overrides|).
|
||||
|
||||
"level" - takes one of two values, "warnings" or "errors"
|
||||
"type" - can be either "syntax" or "style"
|
||||
"regex" - is matched against the messages' text as a case insensitive
|
||||
|regular-expression|
|
||||
"file" - is matched against the filenames the messages refer to, as a
|
||||
case sensitive |regular-expression|.
|
||||
|
||||
If a key is prefixed by an exclamation mark "!", the corresponding filter is
|
||||
negated (i.e. the above example silences all messages that are NOT errors).
|
||||
|
||||
The "file" key may be followed by one or more filename modifiers (see
|
||||
|filename-modifiers|). The modifiers are applied to the filenames the messages
|
||||
refer to before matching against the value (i.e. in the above example the full
|
||||
path of the issues are matched against '\m^/usr/include/' and '\m\c\.h$').
|
||||
|
||||
If |'syntastic_id_checkers'| is set, filters are applied before error messages
|
||||
are labeled with the names of the checkers that created them.
|
||||
|
||||
There are also checker-specific variants of this option, providing finer
|
||||
control. They are named |'syntastic_<filetype>_<checker>_quiet_messages'|.
|
||||
|
||||
For a particular checker, if both a |'syntastic_quiet_messages'| filter and
|
||||
a checker-specific filter are present, they are both applied (to the list of
|
||||
errors produced by the said checker). In case of conflicting values for the
|
||||
same keys, the values of the checker-specific filters take precedence.
|
||||
|
||||
*filter-overrides*
|
||||
Since filter elements with values [] or '' are ignored, you can disable global
|
||||
filters for particular checkers, by setting the values of the corresponding
|
||||
elements in |'syntastic_<filetype>_<checker>_quiet_messages'| to [] or ''. For
|
||||
example, the following setting will silence all warnings, except for the
|
||||
ones produced by "pylint": >
|
||||
let g:syntastic_quiet_messages = { "level": "warnings" }
|
||||
let g:syntastic_python_pylint_quiet_messages = { "level" : [] }
|
||||
<
|
||||
*'syntastic_stl_format'*
|
||||
Default: [Syntax: line:%F (%t)]
|
||||
Use this option to control what the syntastic statusline text contains. Several
|
||||
magic flags are available to insert information:
|
||||
%e - number of errors
|
||||
%w - number of warnings
|
||||
%t - total number of warnings and errors
|
||||
%fe - line number of first error
|
||||
%fw - line number of first warning
|
||||
%F - line number of first warning or error
|
||||
|
||||
Several additional flags are available to hide text under certain conditions:
|
||||
%E{...} - hide the text in the brackets unless there are errors
|
||||
%W{...} - hide the text in the brackets unless there are warnings
|
||||
%B{...} - hide the text in the brackets unless there are both warnings AND
|
||||
errors
|
||||
These flags can't be nested.
|
||||
|
||||
Example: >
|
||||
let g:syntastic_stl_format = '[%E{Err: %fe #%e}%B{, }%W{Warn: %fw #%w}]'
|
||||
<
|
||||
If this format is used and the current buffer has 5 errors and 1 warning
|
||||
starting on lines 20 and 10 respectively then this would appear on the
|
||||
statusline: >
|
||||
[Err: 20 #5, Warn: 10 #1]
|
||||
<
|
||||
If the buffer had 2 warnings, starting on line 5 then this would appear: >
|
||||
[Warn: 5 #2]
|
||||
<
|
||||
*'b:syntastic_skip_checks'*
|
||||
Default: unset
|
||||
Only the local form |'b:syntastic_skip_checks'| is used. When set to a true
|
||||
value, no checks are run against the corresponding buffer. Example: >
|
||||
let b:syntastic_skip_checks = 1
|
||||
<
|
||||
*'syntastic_full_redraws'*
|
||||
Default: 0 in GUI Vim and MacVim, 1 otherwise
|
||||
Controls whether syntastic calls |:redraw| or |:redraw!| for screen redraws.
|
||||
Changing it can in principle make screen redraws smoother, but it can also
|
||||
cause screen to flicker, or cause ghost characters. Leaving it to the default
|
||||
should be safe.
|
||||
|
||||
*'syntastic_exit_checks'*
|
||||
Default: 0 when running under "cmd.exe" on Windows, 1 otherwise
|
||||
Syntastic attempts to catch abnormal termination conditions from checkers by
|
||||
looking at their exit codes. The "cmd.exe" shell on Windows make these checks
|
||||
meaningless, by returning 1 to Vim when the checkers exit with non-zero codes.
|
||||
The above variable can be used to disable exit code checks in syntastic.
|
||||
|
||||
*'syntastic_shell'*
|
||||
Default: Vim's 'shell'
|
||||
|
||||
This is the (full path to) the shell syntastic will use to run the checkers.
|
||||
On UNIX and Mac OS-X this shell must accept Bourne-compatible syntax for
|
||||
file "stdout" and "stderr" redirections ">file" and "2>file". Examples of
|
||||
compatible shells are "zsh", "bash", "ksh", and of course the original Bourne
|
||||
"sh".
|
||||
|
||||
This shell is independent of Vim's 'shell', and it isn't used for interactive
|
||||
operations. It must take care to initialize all environment variables needed
|
||||
by the checkers you're using. Example: >
|
||||
let g:syntastic_shell = "/bin/sh"
|
||||
<
|
||||
*'syntastic_debug'*
|
||||
Default: 0
|
||||
Set this to the sum of one or more of the following flags to enable
|
||||
debugging:
|
||||
|
||||
1 - trace general workflow
|
||||
2 - dump location lists
|
||||
4 - trace notifiers
|
||||
8 - trace autocommands
|
||||
16 - dump options
|
||||
32 - trace running of specific checkers
|
||||
|
||||
Example: >
|
||||
let g:syntastic_debug = 1
|
||||
<
|
||||
Syntastic will then add debugging messages to Vim's |message-history|. You can
|
||||
examine these messages with |:mes|.
|
||||
|
||||
*'syntastic_debug_file'*
|
||||
Default: unset
|
||||
When set, debugging messages are written to the file named by its value, in
|
||||
addition to being added to Vim's |message-history|: >
|
||||
let g:syntastic_debug_file = '~/syntastic.log'
|
||||
<
|
||||
*'syntastic_extra_filetypes'*
|
||||
Default: []
|
||||
List of filetypes handled by checkers external to syntastic. If you have a Vim
|
||||
plugin that adds a checker for syntastic, and if the said checker deals with a
|
||||
filetype that is unknown to syntastic, you might consider adding that filetype
|
||||
to this list: >
|
||||
let g:syntastic_extra_filetypes = [ "make", "gitcommit" ]
|
||||
<
|
||||
This will allow |:SyntasticInfo| to do proper tab completion for the new
|
||||
filetypes.
|
||||
|
||||
==============================================================================
|
||||
5. Checker Options *syntastic-checker-options*
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.1 Choosing which checkers to use *syntastic-filetype-checkers*
|
||||
|
||||
*'g:syntastic_<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"]
|
||||
<
|
||||
*'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
|
||||
<
|
||||
If neither |'g:syntastic_<filetype>_checkers'| nor |'b:syntastic_checkers'|
|
||||
is set, a default list of checker is used. Beware however that this list
|
||||
deliberately kept minimal, for performance reasons.
|
||||
|
||||
Take a look at the wiki to find out what checkers and filetypes are supported
|
||||
by syntastic:
|
||||
|
||||
https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
|
||||
|
||||
Use |:SyntasticInfo| to see which checkers are available for a given filetype.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.2 Choosing the executable *syntastic-config-exec*
|
||||
|
||||
*'syntastic_<filetype>_<checker>_exec'*
|
||||
The executable run by a checker is normally defined automatically, when the
|
||||
checker is registered. You can however override it, by setting the variable
|
||||
'g:syntastic_<filetype>_<checker>_exec': >
|
||||
let g:syntastic_ruby_mri_exec = '~/bin/ruby2'
|
||||
<
|
||||
This variable has a local version, 'b:syntastic_<filetype>_<checker>_exec',
|
||||
which takes precedence over the global one in the corresponding buffer.
|
||||
|
||||
*'b:syntastic_<checker>_exec'*
|
||||
And there is also a local variable named 'b:syntastic_<checker>_exec', which
|
||||
takes precedence over both 'b:syntastic_<filetype>_<checker>_exec' and
|
||||
'g:syntastic_<filetype>_<checker>_exec' in the buffers where it is defined.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.3 Configuring specific checkers *syntastic-config-makeprg*
|
||||
|
||||
Most checkers use the 'makeprgBuild()' function and provide many options by
|
||||
default - in fact you can customise every part of the command that gets called.
|
||||
|
||||
*'syntastic_<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": "2>/dev/null" })
|
||||
<
|
||||
The result is a 'makeprg' of the form: >
|
||||
<exe> <args> <fname> <post_args> <tail>
|
||||
<
|
||||
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 an empty string, e.g.: >
|
||||
let g:syntastic_javascript_jslint_args = ""
|
||||
<
|
||||
*'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 to change the way the checker is run. For example this setup
|
||||
allows you to run PC-Lint under Wine emulation on Linux: >
|
||||
let g:syntastic_c_pc_lint_exec = "wine"
|
||||
let g:syntastic_c_pc_lint_exe = "wine c:/path/to/lint-nt.exe"
|
||||
<
|
||||
To override the args and the tail: >
|
||||
let g:syntastic_c_pc_lint_args = "-w5 -Iz:/usr/include/linux"
|
||||
let g:syntastic_c_pc_lint_tail = "2>/dev/null"
|
||||
<
|
||||
The general form of the override options is: >
|
||||
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
|
||||
options that can be set, these are usually documented in the wiki:
|
||||
|
||||
https://github.com/scrooloose/syntastic/wiki/Syntax-Checkers
|
||||
|
||||
*'syntastic_<filetype>_<checker>_quiet_messages'*
|
||||
In the same vein, 'g:syntastic_<filetype>_<checker-name>_quiet_messages' can
|
||||
be used to restrict message filters to messages produced by specific checkers.
|
||||
Example: >
|
||||
let g:syntastic_python_pylama_quiet_messages = {
|
||||
\ "type": "style",
|
||||
\ "regex": '\m\[C03\d\d\]' }
|
||||
<
|
||||
See |syntastic_quiet_messages| for the syntax.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
5.4 Sorting errors *syntastic-config-sort*
|
||||
|
||||
*'syntastic_<filetype>_<checker>_sort'*
|
||||
Syntastic may decide to group the errors produced by some checkers by file,
|
||||
then sort them by line number, then by type, then by column number. If you'd
|
||||
prefer to see the errors in the order in which they are output by the external
|
||||
checker you can set the variable |'g:syntastic_<filetype>_<checker>_sort'| to 0.
|
||||
|
||||
Alternatively, if syntastic doesn't reorder the errors produced by a checker
|
||||
but you'd like it to sort them, you can set the same variable to 1.
|
||||
|
||||
There is also a local version |'b:syntastic_<filetype>_<checker>_sort'| of
|
||||
this variable, that takes precedence over it in the buffers where it is
|
||||
defined.
|
||||
|
||||
For aggregated lists (see |syntastic-aggregating-errors|) these variables are
|
||||
ignored if |syntastic_sort_aggregated_errors| is set (which is the default).
|
||||
|
||||
==============================================================================
|
||||
6. Notes *syntastic-notes*
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
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
|
||||
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" }
|
||||
<
|
||||
------------------------------------------------------------------------------
|
||||
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 The 'shellslash' option *syntastic-shellslash*
|
||||
|
||||
The 'shellslash' option is relevant only on Windows systems. This option
|
||||
determines (among other things) the rules for quoting command lines, and there
|
||||
is no easy way for syntastic to make sure its state is appropriate for your
|
||||
shell. It should be turned off if your 'shell' (or |g:syntastic_shell|) is
|
||||
"cmd.exe", and on for shells that expect an UNIX-like syntax, such as Cygwin's
|
||||
"sh". Most checkers will stop working if 'shellslash' is set to the wrong
|
||||
value.
|
||||
|
||||
==============================================================================
|
||||
7. Compatibility with other software *syntastic-compatibility*
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
7.1 The csh and tcsh shells *syntastic-csh*
|
||||
|
||||
The "csh" and "tcsh" shells are mostly compatible with syntastic. However,
|
||||
some checkers assume Bourne shell syntax for redirecting "stderr". For this
|
||||
reason, you should point |g:syntastic_shell| to a Bourne-compatible shell,
|
||||
such as "zsh", "bash", "ksh", or even the original Bourne "sh": >
|
||||
let g:syntastic_shell = "/bin/sh"
|
||||
<
|
||||
------------------------------------------------------------------------------
|
||||
7.2. Eclim *syntastic-eclim*
|
||||
|
||||
Syntastic can be used together with "Eclim" (see http://eclim.org/). However,
|
||||
by default Eclim disables syntastic's checks for the filetypes it supports, in
|
||||
order to run its own validation. If you'd prefer to use Eclim but still run
|
||||
syntastic's checks, set |g:EclimFileTypeValidate| to 0: >
|
||||
let g:EclimFileTypeValidate = 0
|
||||
<
|
||||
It is also possible to re-enable syntastic checks only for some filetypes, and
|
||||
run Eclim's validation for others. Please consult Eclim's documentation for
|
||||
details.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
7.3 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 can however set |g:syntastic_shell|
|
||||
to a more traditional shell, such as "zsh", "bash", "ksh", or even the
|
||||
original Bourne "sh": >
|
||||
let g:syntastic_shell = "/bin/sh"
|
||||
<
|
||||
------------------------------------------------------------------------------
|
||||
7.4. 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
|
||||
'shellredir' like this: >
|
||||
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: >
|
||||
let g:syntastic_shell = "/bin/sh"
|
||||
<
|
||||
------------------------------------------------------------------------------
|
||||
7.5. powerline *syntastic-powerline*
|
||||
|
||||
The "powerline" Vim plugin (https://github.com/powerline/powerline) comes
|
||||
packaged with a syntastic segment. To customize this segment create a file
|
||||
~/.config/powerline/themes/vim/default.json, with a content like this: >
|
||||
{
|
||||
"segment_data" : {
|
||||
"powerline.segments.vim.plugin.syntastic.syntastic" : {
|
||||
"args" : {
|
||||
"err_format" : "Err: {first_line} #{num} ",
|
||||
"warn_format" : "Warn: {first_line} #{num} "
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
<
|
||||
------------------------------------------------------------------------------
|
||||
7.6. The PowerShell shell *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
|
||||
<
|
||||
------------------------------------------------------------------------------
|
||||
7.7 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.: >
|
||||
let g:pymode_lint_write = 0
|
||||
<
|
||||
------------------------------------------------------------------------------
|
||||
7.8. vim-auto-save *syntastic-vim-auto-save*
|
||||
|
||||
Syntastic can be used together with the "vim-auto-save" Vim plugin (see
|
||||
https://github.com/907th/vim-auto-save). However, syntastic checks in active
|
||||
mode only work with "vim-auto-save" version 0.1.7 or later.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
7.9. vim-go *syntastic-vim-go*
|
||||
|
||||
The "vim-go" Vim plugin (https://github.com/fatih/vim-go) uses |quickfix|
|
||||
lists, and thus doesn't conflict with syntastic (which uses |location-list|
|
||||
lists). However, both "vim-go" and syntastic run syntax checks by default
|
||||
when you save buffers to disk, and this can have confusing results. To
|
||||
avoid both plugins opening error windows, you can either set passive
|
||||
mode for go in syntastic (see |syntastic_mode_map|), or prevent "vim-go"
|
||||
from showing a quickfix window when |g:go_fmt_command| fails, by setting
|
||||
|g:go_fmt_fail_silently| to 1. E.g.: >
|
||||
let g:go_fmt_fail_silently = 1
|
||||
<
|
||||
------------------------------------------------------------------------------
|
||||
7.10. 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.11 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
|
||||
<
|
||||
==============================================================================
|
||||
8. About *syntastic-about*
|
||||
|
||||
The core maintainers of syntastic are:
|
||||
Martin Grenfell (GitHub: scrooloose)
|
||||
Gregor Uhlenheuer (GitHub: kongo2002)
|
||||
LCD 047 (GitHub: lcd047)
|
||||
|
||||
Find the latest version of syntastic at:
|
||||
|
||||
http://github.com/scrooloose/syntastic
|
||||
|
||||
==============================================================================
|
||||
9. License *syntastic-license*
|
||||
|
||||
Syntastic is released under the WTFPL.
|
||||
See http://sam.zoy.org/wtfpl/COPYING.
|
||||
|
||||
vim:tw=78:sw=4:ft=help:norl:
|
||||
@ -0,0 +1,672 @@
|
||||
"============================================================================
|
||||
"File: syntastic.vim
|
||||
"Description: Vim plugin for on the fly syntax checking.
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_plugin = 1
|
||||
|
||||
if has('reltime')
|
||||
let g:_SYNTASTIC_START = reltime()
|
||||
lockvar! g:_SYNTASTIC_START
|
||||
endif
|
||||
|
||||
let g:_SYNTASTIC_VERSION = '3.6.0-81'
|
||||
lockvar g:_SYNTASTIC_VERSION
|
||||
|
||||
" Sanity checks {{{1
|
||||
|
||||
for s:feature in [
|
||||
\ 'autocmd',
|
||||
\ 'eval',
|
||||
\ 'file_in_path',
|
||||
\ 'modify_fname',
|
||||
\ 'quickfix',
|
||||
\ 'reltime',
|
||||
\ 'user_commands'
|
||||
\ ]
|
||||
if !has(s:feature)
|
||||
call syntastic#log#error('need Vim compiled with feature ' . s:feature)
|
||||
finish
|
||||
endif
|
||||
endfor
|
||||
|
||||
let s:_running_windows = syntastic#util#isRunningWindows()
|
||||
lockvar s:_running_windows
|
||||
|
||||
if !exists('g:syntastic_shell')
|
||||
let g:syntastic_shell = &shell
|
||||
endif
|
||||
|
||||
if s:_running_windows
|
||||
let g:_SYNTASTIC_UNAME = 'Windows'
|
||||
elseif executable('uname')
|
||||
try
|
||||
let g:_SYNTASTIC_UNAME = split(syntastic#util#system('uname'), "\n")[0]
|
||||
catch /\m^Vim\%((\a\+)\)\=:E484/
|
||||
call syntastic#log#error("your shell " . syntastic#util#var('shell') . " can't handle traditional UNIX syntax for redirections")
|
||||
finish
|
||||
catch /\m^Vim\%((\a\+)\)\=:E684/
|
||||
let g:_SYNTASTIC_UNAME = 'Unknown'
|
||||
endtry
|
||||
else
|
||||
let g:_SYNTASTIC_UNAME = 'Unknown'
|
||||
endif
|
||||
lockvar g:_SYNTASTIC_UNAME
|
||||
|
||||
" }}}1
|
||||
|
||||
" Defaults {{{1
|
||||
|
||||
let g:_SYNTASTIC_DEFAULTS = {
|
||||
\ 'aggregate_errors': 0,
|
||||
\ 'always_populate_loc_list': 0,
|
||||
\ 'auto_jump': 0,
|
||||
\ 'auto_loc_list': 2,
|
||||
\ 'check_on_open': 0,
|
||||
\ 'check_on_wq': 1,
|
||||
\ 'cursor_columns': 1,
|
||||
\ 'debug': 0,
|
||||
\ 'echo_current_error': 1,
|
||||
\ 'enable_balloons': 1,
|
||||
\ 'enable_highlighting': 1,
|
||||
\ 'enable_signs': 1,
|
||||
\ 'error_symbol': '>>',
|
||||
\ 'exit_checks': !(s:_running_windows && syntastic#util#var('shell', &shell) =~? '\m\<cmd\.exe$'),
|
||||
\ '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': 0,
|
||||
\ 'shell': &shell,
|
||||
\ '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)
|
||||
let g:syntastic_{s:key} = copy(g:_SYNTASTIC_DEFAULTS[s:key])
|
||||
endif
|
||||
endfor
|
||||
|
||||
if exists('g:syntastic_quiet_warnings')
|
||||
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([])
|
||||
let s:quiet_warnings = [s:quiet_warnings]
|
||||
endif
|
||||
call add(s:quiet_warnings, 'warnings')
|
||||
let g:syntastic_quiet_messages['type'] = s:quiet_warnings
|
||||
endif
|
||||
endif
|
||||
|
||||
" }}}1
|
||||
|
||||
" Debug {{{1
|
||||
|
||||
let s:_DEBUG_DUMP_OPTIONS = [
|
||||
\ 'shell',
|
||||
\ 'shellcmdflag',
|
||||
\ 'shellpipe',
|
||||
\ 'shellquote',
|
||||
\ 'shellredir',
|
||||
\ 'shellslash',
|
||||
\ 'shelltemp',
|
||||
\ 'shellxquote'
|
||||
\ ]
|
||||
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:_SYNTASTIC_DEBUG_TRACE = 1
|
||||
lockvar g:_SYNTASTIC_DEBUG_TRACE
|
||||
let g:_SYNTASTIC_DEBUG_LOCLIST = 2
|
||||
lockvar g:_SYNTASTIC_DEBUG_LOCLIST
|
||||
let g:_SYNTASTIC_DEBUG_NOTIFICATIONS = 4
|
||||
lockvar g:_SYNTASTIC_DEBUG_NOTIFICATIONS
|
||||
let g:_SYNTASTIC_DEBUG_AUTOCOMMANDS = 8
|
||||
lockvar g:_SYNTASTIC_DEBUG_AUTOCOMMANDS
|
||||
let g:_SYNTASTIC_DEBUG_VARIABLES = 16
|
||||
lockvar g:_SYNTASTIC_DEBUG_VARIABLES
|
||||
let g:_SYNTASTIC_DEBUG_CHECKERS = 32
|
||||
lockvar g:_SYNTASTIC_DEBUG_CHECKERS
|
||||
|
||||
" }}}1
|
||||
|
||||
runtime! plugin/syntastic/*.vim
|
||||
|
||||
let s:registry = g:SyntasticRegistry.Instance()
|
||||
let s:notifiers = g:SyntasticNotifiers.Instance()
|
||||
let s:modemap = g:SyntasticModeMap.Instance()
|
||||
|
||||
" Commands {{{1
|
||||
|
||||
" @vimlint(EVL103, 1, a:cursorPos)
|
||||
" @vimlint(EVL103, 1, a:cmdLine)
|
||||
" @vimlint(EVL103, 1, a:argLead)
|
||||
function! s:CompleteCheckerName(argLead, cmdLine, cursorPos) abort " {{{2
|
||||
let checker_names = []
|
||||
for ft in s:_resolve_filetypes([])
|
||||
call extend(checker_names, s:registry.getNamesOfAvailableCheckers(ft))
|
||||
endfor
|
||||
return join(checker_names, "\n")
|
||||
endfunction " }}}2
|
||||
" @vimlint(EVL103, 0, a:cursorPos)
|
||||
" @vimlint(EVL103, 0, a:cmdLine)
|
||||
" @vimlint(EVL103, 0, a:argLead)
|
||||
|
||||
|
||||
" @vimlint(EVL103, 1, a:cursorPos)
|
||||
" @vimlint(EVL103, 1, a:cmdLine)
|
||||
" @vimlint(EVL103, 1, a:argLead)
|
||||
function! s:CompleteFiletypes(argLead, cmdLine, cursorPos) abort " {{{2
|
||||
return join(s:registry.getKnownFiletypes(), "\n")
|
||||
endfunction " }}}2
|
||||
" @vimlint(EVL103, 0, a:cursorPos)
|
||||
" @vimlint(EVL103, 0, a:cmdLine)
|
||||
" @vimlint(EVL103, 0, a:argLead)
|
||||
|
||||
command! -nargs=* -complete=custom,s:CompleteCheckerName SyntasticCheck call SyntasticCheck(<f-args>)
|
||||
command! -nargs=? -complete=custom,s:CompleteFiletypes SyntasticInfo call SyntasticInfo(<f-args>)
|
||||
command! Errors call SyntasticErrors()
|
||||
command! SyntasticReset call SyntasticReset()
|
||||
command! SyntasticToggleMode call SyntasticToggleMode()
|
||||
command! SyntasticSetLoclist call SyntasticSetLoclist()
|
||||
|
||||
" }}}1
|
||||
|
||||
" Public API {{{1
|
||||
|
||||
function! SyntasticCheck(...) abort " {{{2
|
||||
call s:UpdateErrors(0, a:000)
|
||||
call syntastic#util#redraw(g:syntastic_full_redraws)
|
||||
endfunction " }}}2
|
||||
|
||||
function! SyntasticInfo(...) abort " {{{2
|
||||
call s:modemap.modeInfo(a:000)
|
||||
call s:registry.echoInfoFor(s:_resolve_filetypes(a:000))
|
||||
call s:_explain_skip(a:000)
|
||||
endfunction " }}}2
|
||||
|
||||
function! SyntasticErrors() abort " {{{2
|
||||
call g:SyntasticLoclist.current().show()
|
||||
endfunction " }}}2
|
||||
|
||||
function! SyntasticReset() abort " {{{2
|
||||
call s:ClearCache()
|
||||
call s:notifiers.refresh(g:SyntasticLoclist.New([]))
|
||||
endfunction " }}}2
|
||||
|
||||
function! SyntasticToggleMode() abort " {{{2
|
||||
call s:modemap.toggleMode()
|
||||
call s:ClearCache()
|
||||
call s:notifiers.refresh(g:SyntasticLoclist.New([]))
|
||||
call s:modemap.echoMode()
|
||||
endfunction " }}}2
|
||||
|
||||
function! SyntasticSetLoclist() abort " {{{2
|
||||
call g:SyntasticLoclist.current().setloclist()
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Autocommands {{{1
|
||||
|
||||
augroup syntastic
|
||||
autocmd BufReadPost * call s:BufReadPostHook()
|
||||
autocmd BufWritePost * call s:BufWritePostHook()
|
||||
autocmd BufEnter * call s:BufEnterHook()
|
||||
augroup END
|
||||
|
||||
if v:version > 703 || (v:version == 703 && has('patch544'))
|
||||
" QuitPre was added in Vim 7.3.544
|
||||
augroup syntastic
|
||||
autocmd QuitPre * call s:QuitPreHook()
|
||||
augroup END
|
||||
endif
|
||||
|
||||
function! s:BufReadPostHook() abort " {{{2
|
||||
if g:syntastic_check_on_open
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
|
||||
\ 'autocmd: BufReadPost, buffer ' . bufnr('') . ' = ' . string(bufname(str2nr(bufnr('')))))
|
||||
call s:UpdateErrors(1, [])
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:BufWritePostHook() abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
|
||||
\ 'autocmd: BufWritePost, buffer ' . bufnr('') . ' = ' . string(bufname(str2nr(bufnr('')))))
|
||||
call s:UpdateErrors(1, [])
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:BufEnterHook() abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
|
||||
\ '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(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 get(w:, 'syntastic_loclist_set', 0) && !empty(loclist) && empty(filter( buffers, 'syntastic#util#bufIsActive(v:val)' ))
|
||||
call SyntasticLoclistHide()
|
||||
endif
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:QuitPreHook() abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_AUTOCOMMANDS,
|
||||
\ 'autocmd: QuitPre, buffer ' . bufnr('') . ' = ' . string(bufname(str2nr(bufnr('')))))
|
||||
let b:syntastic_skip_checks = get(b:, 'syntastic_skip_checks', 0) || !syntastic#util#var('check_on_wq')
|
||||
if get(w:, 'syntastic_loclist_set', 0)
|
||||
call SyntasticLoclistHide()
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Main {{{1
|
||||
|
||||
"refresh and redraw all the error info for this buf when saving or reading
|
||||
function! s:UpdateErrors(auto_invoked, checker_names) abort " {{{2
|
||||
call syntastic#log#debugShowVariables(g:_SYNTASTIC_DEBUG_TRACE, 'version')
|
||||
call syntastic#log#debugShowOptions(g:_SYNTASTIC_DEBUG_TRACE, s:_DEBUG_DUMP_OPTIONS)
|
||||
call syntastic#log#debugDump(g:_SYNTASTIC_DEBUG_VARIABLES)
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'UpdateErrors' . (a:auto_invoked ? ' (auto)' : '') .
|
||||
\ ': ' . (len(a:checker_names) ? join(a:checker_names) : 'default checkers'))
|
||||
if s:_skip_file()
|
||||
return
|
||||
endif
|
||||
|
||||
call s:modemap.synch()
|
||||
let run_checks = !a:auto_invoked || s:modemap.doAutoChecking()
|
||||
if run_checks
|
||||
call s:CacheErrors(a:checker_names)
|
||||
unlockvar! b:syntastic_changedtick
|
||||
let b:syntastic_changedtick = b:changedtick
|
||||
lockvar! b:syntastic_changedtick
|
||||
endif
|
||||
|
||||
let loclist = g:SyntasticLoclist.current()
|
||||
|
||||
if exists('*SyntasticCheckHook')
|
||||
call SyntasticCheckHook(loclist.getRaw())
|
||||
endif
|
||||
|
||||
" populate loclist and jump {{{3
|
||||
let do_jump = syntastic#util#var('auto_jump') + 0
|
||||
if do_jump == 2
|
||||
let do_jump = loclist.getFirstError(1)
|
||||
elseif do_jump == 3
|
||||
let do_jump = loclist.getFirstError()
|
||||
elseif 0 > do_jump || do_jump > 3
|
||||
let do_jump = 0
|
||||
endif
|
||||
|
||||
let w:syntastic_loclist_set = 0
|
||||
if syntastic#util#var('always_populate_loc_list') || do_jump
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: setloclist (new)')
|
||||
call setloclist(0, loclist.getRaw())
|
||||
let w:syntastic_loclist_set = 1
|
||||
if run_checks && do_jump && !loclist.isEmpty()
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: jump')
|
||||
execute 'silent! lrewind ' . do_jump
|
||||
|
||||
" XXX: Vim doesn't call autocmd commands in a predictible
|
||||
" order, which can lead to missing filetype when jumping
|
||||
" to a new file; the following is a workaround for the
|
||||
" resulting brain damage
|
||||
if &filetype ==# ''
|
||||
silent! filetype detect
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
" }}}3
|
||||
|
||||
call s:notifiers.refresh(loclist)
|
||||
endfunction " }}}2
|
||||
|
||||
"clear the loc list for the buffer
|
||||
function! s:ClearCache() abort " {{{2
|
||||
call s:notifiers.reset(g:SyntasticLoclist.current())
|
||||
call b:syntastic_loclist.destroy()
|
||||
endfunction " }}}2
|
||||
|
||||
"detect and cache all syntax errors in this buffer
|
||||
function! s:CacheErrors(checker_names) abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: ' .
|
||||
\ (len(a:checker_names) ? join(a:checker_names) : 'default checkers'))
|
||||
call s:ClearCache()
|
||||
let newLoclist = g:SyntasticLoclist.New([])
|
||||
|
||||
if !s:_skip_file()
|
||||
" debug logging {{{3
|
||||
call syntastic#log#debugShowVariables(g:_SYNTASTIC_DEBUG_TRACE, 'aggregate_errors')
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, '$PATH = ' . string($PATH))
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getcwd() = ' . string(getcwd()))
|
||||
" }}}3
|
||||
|
||||
let filetypes = s:_resolve_filetypes([])
|
||||
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
|
||||
call extend(clist, s:registry.getCheckers(type, a:checker_names))
|
||||
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:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: Checker ' . cname . ' is not available')
|
||||
let unavailable_checkers += 1
|
||||
continue
|
||||
endif
|
||||
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: Invoking checker: ' . cname)
|
||||
|
||||
let loclist = checker.getLocList()
|
||||
|
||||
if !loclist.isEmpty()
|
||||
if decorate_errors
|
||||
call loclist.decorate(cname)
|
||||
endif
|
||||
call add(names, cname)
|
||||
if checker.wantSort() && !sort_aggregated_errors
|
||||
call loclist.sort()
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'sorted:', loclist)
|
||||
endif
|
||||
|
||||
let newLoclist = newLoclist.extend(loclist)
|
||||
|
||||
if !aggregate_errors
|
||||
break
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
|
||||
" set names {{{3
|
||||
if !empty(names)
|
||||
if len(syntastic#util#unique(map( copy(names), 'substitute(v:val, "\\m/.*", "", "")' ))) == 1
|
||||
let type = substitute(names[0], '\m/.*', '', '')
|
||||
let name = join(map( names, 'substitute(v:val, "\\m.\\{-}/", "", "")' ), ', ')
|
||||
call newLoclist.setName( name . ' ('. type . ')' )
|
||||
else
|
||||
" checkers from mixed types
|
||||
call newLoclist.setName(join(names, ', '))
|
||||
endif
|
||||
endif
|
||||
" }}}3
|
||||
|
||||
" issue warning about no active checkers {{{3
|
||||
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')
|
||||
else
|
||||
call syntastic#log#warn('checkers ' . join(a:checker_names, ', ') . ' are not available')
|
||||
endif
|
||||
else
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'CacheErrors: no checkers available for ' . &filetype)
|
||||
endif
|
||||
endif
|
||||
" }}}3
|
||||
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'aggregated:', newLoclist)
|
||||
if sort_aggregated_errors
|
||||
call newLoclist.sort()
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'sorted:', newLoclist)
|
||||
endif
|
||||
endif
|
||||
|
||||
call newLoclist.deploy()
|
||||
endfunction " }}}2
|
||||
|
||||
"Emulates the :lmake command. Sets up the make environment according to the
|
||||
"options given, runs make, resets the environment, returns the location list
|
||||
"
|
||||
"a:options can contain the following keys:
|
||||
" 'makeprg'
|
||||
" 'errorformat'
|
||||
"
|
||||
"The corresponding options are set for the duration of the function call. They
|
||||
"are set with :let, so dont escape spaces.
|
||||
"
|
||||
"a:options may also contain:
|
||||
" 'defaults' - a dict containing default values for the returned errors
|
||||
" 'subtype' - all errors will be assigned the given subtype
|
||||
" '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) abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'SyntasticMake: called with options:', a:options)
|
||||
|
||||
" save options and locale env variables {{{3
|
||||
let old_local_errorformat = &l:errorformat
|
||||
let old_errorformat = &errorformat
|
||||
let old_cwd = getcwd()
|
||||
" }}}3
|
||||
|
||||
if has_key(a:options, 'errorformat')
|
||||
let &errorformat = a:options['errorformat']
|
||||
endif
|
||||
|
||||
if has_key(a:options, 'cwd')
|
||||
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_]\+$'
|
||||
execute 'let env_save[' . string(key) . '] = $' . key
|
||||
execute 'let $' . key . ' = ' . string(a:options['env'][key])
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
" }}}3
|
||||
|
||||
let err_lines = split(syntastic#util#system(a:options['makeprg']), "\n", 1)
|
||||
|
||||
" restore environment variables {{{3
|
||||
if len(env_save)
|
||||
for key in keys(env_save)
|
||||
execute 'let $' . key . ' = ' . string(env_save[key])
|
||||
endfor
|
||||
endif
|
||||
" }}}3
|
||||
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'checker output:', err_lines)
|
||||
|
||||
" Does it still make sense to go on?
|
||||
let bailout =
|
||||
\ syntastic#util#var('exit_checks') &&
|
||||
\ has_key(a:options, 'returns') &&
|
||||
\ index(a:options['returns'], v:shell_error) == -1
|
||||
|
||||
if !bailout
|
||||
if has_key(a:options, 'Preprocess')
|
||||
let err_lines = call(a:options['Preprocess'], [err_lines])
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'preprocess (external):', err_lines)
|
||||
elseif has_key(a:options, 'preprocess')
|
||||
let err_lines = call('syntastic#preprocess#' . a:options['preprocess'], [err_lines])
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'preprocess:', err_lines)
|
||||
endif
|
||||
lgetexpr err_lines
|
||||
|
||||
let errors = deepcopy(getloclist(0))
|
||||
|
||||
if has_key(a:options, 'cwd')
|
||||
execute 'lcd ' . fnameescape(old_cwd)
|
||||
endif
|
||||
|
||||
try
|
||||
silent lolder
|
||||
catch /\m^Vim\%((\a\+)\)\=:E380/
|
||||
" E380: At bottom of quickfix stack
|
||||
call setloclist(0, [], 'r')
|
||||
catch /\m^Vim\%((\a\+)\)\=:E776/
|
||||
" E776: No location list
|
||||
" do nothing
|
||||
endtry
|
||||
else
|
||||
let errors = []
|
||||
endif
|
||||
|
||||
" restore options {{{3
|
||||
let &errorformat = old_errorformat
|
||||
let &l:errorformat = old_local_errorformat
|
||||
" }}}3
|
||||
|
||||
if !s:_running_windows && (s:_os_name() =~? 'FreeBSD' || s:_os_name() =~? 'OpenBSD')
|
||||
call syntastic#util#redraw(g:syntastic_full_redraws)
|
||||
endif
|
||||
|
||||
if bailout
|
||||
throw 'Syntastic: checker error'
|
||||
endif
|
||||
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'raw loclist:', errors)
|
||||
|
||||
if has_key(a:options, 'defaults')
|
||||
call s:_add_to_errors(errors, a:options['defaults'])
|
||||
endif
|
||||
|
||||
" Add subtype info if present.
|
||||
if has_key(a:options, 'subtype')
|
||||
call s:_add_to_errors(errors, { 'subtype': a:options['subtype'] })
|
||||
endif
|
||||
|
||||
if has_key(a:options, 'Postprocess') && !empty(a:options['Postprocess'])
|
||||
for rule in a:options['Postprocess']
|
||||
let errors = call(rule, [errors])
|
||||
endfor
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'postprocess (external):', errors)
|
||||
elseif has_key(a:options, 'postprocess') && !empty(a:options['postprocess'])
|
||||
for rule in a:options['postprocess']
|
||||
let errors = call('syntastic#postprocess#' . rule, [errors])
|
||||
endfor
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'postprocess:', errors)
|
||||
endif
|
||||
|
||||
return errors
|
||||
endfunction " }}}2
|
||||
" @vimlint(EVL102, 0, l:env_save)
|
||||
|
||||
"return a string representing the state of buffer according to
|
||||
"g:syntastic_stl_format
|
||||
"
|
||||
"return '' if no errors are cached for the buffer
|
||||
function! SyntasticStatuslineFlag() abort " {{{2
|
||||
return g:SyntasticLoclist.current().getStatuslineFlag()
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Utilities {{{1
|
||||
|
||||
function! s:_resolve_filetypes(filetypes) abort " {{{2
|
||||
let type = len(a:filetypes) ? a:filetypes[0] : &filetype
|
||||
return split( get(g:syntastic_filetype_map, type, type), '\m\.' )
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_ignore_file(filename) abort " {{{2
|
||||
let fname = fnamemodify(a:filename, ':p')
|
||||
for pattern in g:syntastic_ignore_files
|
||||
if fname =~# pattern
|
||||
return 1
|
||||
endif
|
||||
endfor
|
||||
return 0
|
||||
endfunction " }}}2
|
||||
|
||||
" Skip running in special buffers
|
||||
function! s:_skip_file() abort " {{{2
|
||||
let fname = expand('%', 1)
|
||||
let skip = get(b:, 'syntastic_skip_checks', 0) || (&buftype !=# '') ||
|
||||
\ !filereadable(fname) || getwinvar(0, '&diff') || s:_ignore_file(fname) ||
|
||||
\ fnamemodify(fname, ':e') =~? g:syntastic_ignore_extensions
|
||||
if skip
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, '_skip_file: skipping checks')
|
||||
endif
|
||||
return skip
|
||||
endfunction " }}}2
|
||||
|
||||
" Explain why checks will be skipped for the current file
|
||||
function! s:_explain_skip(filetypes) abort " {{{2
|
||||
if empty(a:filetypes) && s:_skip_file()
|
||||
let why = []
|
||||
let fname = expand('%', 1)
|
||||
|
||||
if get(b:, 'syntastic_skip_checks', 0)
|
||||
call add(why, 'b:syntastic_skip_checks set')
|
||||
endif
|
||||
if &buftype !=# ''
|
||||
call add(why, 'buftype = ' . string(&buftype))
|
||||
endif
|
||||
if !filereadable(fname)
|
||||
call add(why, 'file not readable / not local')
|
||||
endif
|
||||
if getwinvar(0, '&diff')
|
||||
call add(why, 'diff mode')
|
||||
endif
|
||||
if s:_ignore_file(fname)
|
||||
call add(why, 'filename matching g:syntastic_ignore_files')
|
||||
endif
|
||||
if fnamemodify(fname, ':e') =~? g:syntastic_ignore_extensions
|
||||
call add(why, 'extension matching g:syntastic_ignore_extensions')
|
||||
endif
|
||||
|
||||
echomsg 'The current file will not be checked (' . join(why, ', ') . ')'
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" Take a list of errors and add default values to them from a:options
|
||||
function! s:_add_to_errors(errors, options) abort " {{{2
|
||||
for err in a:errors
|
||||
for key in keys(a:options)
|
||||
if !has_key(err, key) || empty(err[key])
|
||||
let err[key] = a:options[key]
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
|
||||
return a:errors
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_os_name() abort " {{{2
|
||||
return g:_SYNTASTIC_UNAME
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,38 @@
|
||||
if exists('g:loaded_syntastic_notifier_autoloclist') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_notifier_autoloclist = 1
|
||||
|
||||
let g:SyntasticAutoloclistNotifier = {}
|
||||
|
||||
" Public methods {{{1
|
||||
"
|
||||
function! g:SyntasticAutoloclistNotifier.New() abort " {{{2
|
||||
let newObj = copy(self)
|
||||
return newObj
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticAutoloclistNotifier.refresh(loclist) abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'autoloclist: refresh')
|
||||
call g:SyntasticAutoloclistNotifier.AutoToggle(a:loclist)
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticAutoloclistNotifier.AutoToggle(loclist) abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'autoloclist: toggle')
|
||||
if !a:loclist.isEmpty()
|
||||
if syntastic#util#var('auto_loc_list') == 1
|
||||
call a:loclist.show()
|
||||
endif
|
||||
else
|
||||
if syntastic#util#var('auto_loc_list') > 0
|
||||
|
||||
"TODO: this will close the loc list window if one was opened by
|
||||
"something other than syntastic
|
||||
lclose
|
||||
endif
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,59 @@
|
||||
if exists('g:loaded_syntastic_notifier_balloons') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_notifier_balloons = 1
|
||||
|
||||
if !has('balloon_eval')
|
||||
let g:syntastic_enable_balloons = 0
|
||||
endif
|
||||
|
||||
let g:SyntasticBalloonsNotifier = {}
|
||||
|
||||
" Public methods {{{1
|
||||
|
||||
function! g:SyntasticBalloonsNotifier.New() abort " {{{2
|
||||
let newObj = copy(self)
|
||||
return newObj
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticBalloonsNotifier.enabled() abort " {{{2
|
||||
return has('balloon_eval') && syntastic#util#var('enable_balloons')
|
||||
endfunction " }}}2
|
||||
|
||||
" Update the error balloons
|
||||
function! g:SyntasticBalloonsNotifier.refresh(loclist) abort " {{{2
|
||||
unlet! b:syntastic_private_balloons
|
||||
if self.enabled() && !a:loclist.isEmpty()
|
||||
let b:syntastic_private_balloons = a:loclist.balloons()
|
||||
if !empty(b:syntastic_private_balloons)
|
||||
set ballooneval balloonexpr=SyntasticBalloonsExprNotifier()
|
||||
endif
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" Reset the error balloons
|
||||
" @vimlint(EVL103, 1, a:loclist)
|
||||
function! g:SyntasticBalloonsNotifier.reset(loclist) abort " {{{2
|
||||
let b:syntastic_private_balloons = {}
|
||||
if has('balloon_eval')
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'balloons: reset')
|
||||
unlet! b:syntastic_private_balloons
|
||||
set noballooneval
|
||||
endif
|
||||
endfunction " }}}2
|
||||
" @vimlint(EVL103, 0, a:loclist)
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private functions {{{1
|
||||
|
||||
function! SyntasticBalloonsExprNotifier() abort " {{{2
|
||||
if !exists('b:syntastic_private_balloons')
|
||||
return ''
|
||||
endif
|
||||
return get(b:syntastic_private_balloons, v:beval_lnum, '')
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,228 @@
|
||||
if exists('g:loaded_syntastic_checker') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_checker = 1
|
||||
|
||||
let g:SyntasticChecker = {}
|
||||
|
||||
" Public methods {{{1
|
||||
|
||||
function! g:SyntasticChecker.New(args) abort " {{{2
|
||||
let newObj = copy(self)
|
||||
|
||||
let newObj._filetype = a:args['filetype']
|
||||
let newObj._name = a:args['name']
|
||||
let newObj._exec = get(a:args, 'exec', newObj._name)
|
||||
|
||||
if has_key(a:args, 'redirect')
|
||||
let [filetype, name] = split(a:args['redirect'], '/')
|
||||
let prefix = 'SyntaxCheckers_' . filetype . '_' . name . '_'
|
||||
|
||||
if exists('g:syntastic_' . filetype . '_' . name . '_sort') && !exists('g:syntastic_' . newObj._filetype . '_' . newObj._name . '_sort')
|
||||
let g:syntastic_{newObj._filetype}_{newObj._name}_sort = g:syntastic_{filetype}_{name}_sort
|
||||
endif
|
||||
else
|
||||
let prefix = 'SyntaxCheckers_' . newObj._filetype . '_' . newObj._name . '_'
|
||||
endif
|
||||
|
||||
let newObj._locListFunc = function(prefix . 'GetLocList')
|
||||
|
||||
if exists('*' . prefix . 'IsAvailable')
|
||||
let newObj._isAvailableFunc = function(prefix . 'IsAvailable')
|
||||
else
|
||||
let newObj._isAvailableFunc = function('s:_isAvailableDefault')
|
||||
endif
|
||||
|
||||
if exists('*' . prefix . 'GetHighlightRegex')
|
||||
let newObj._highlightRegexFunc = function(prefix . 'GetHighlightRegex')
|
||||
endif
|
||||
|
||||
return newObj
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.getFiletype() abort " {{{2
|
||||
return self._filetype
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.getName() abort " {{{2
|
||||
return self._name
|
||||
endfunction " }}}2
|
||||
|
||||
" Synchronise _exec with user's setting. Force re-validation if needed.
|
||||
"
|
||||
" XXX: This function must be called at least once before calling either
|
||||
" getExec() or getExecEscaped(). Normally isAvailable() does that for you
|
||||
" automatically, but you should keep still this in mind if you change the
|
||||
" current checker workflow.
|
||||
function! g:SyntasticChecker.syncExec() dict " {{{2
|
||||
let user_exec =
|
||||
\ expand( exists('b:syntastic_' . self._name . '_exec') ? b:syntastic_{self._name}_exec :
|
||||
\ syntastic#util#var(self._filetype . '_' . self._name . '_exec'), 1 )
|
||||
|
||||
if user_exec !=# '' && user_exec !=# self._exec
|
||||
let self._exec = user_exec
|
||||
if has_key(self, '_available')
|
||||
" we have a new _exec on the block, it has to be validated
|
||||
call remove(self, '_available')
|
||||
endif
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.getExec() abort " {{{2
|
||||
return self._exec
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.getExecEscaped() abort " {{{2
|
||||
return syntastic#util#shescape(self._exec)
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.getLocListRaw() abort " {{{2
|
||||
let name = self._filetype . '/' . self._name
|
||||
try
|
||||
let list = self._locListFunc()
|
||||
if self._exec !=# ''
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_TRACE, 'getLocList: checker ' . name . ' returned ' . v:shell_error)
|
||||
endif
|
||||
catch /\m\C^Syntastic: checker error$/
|
||||
let list = []
|
||||
if self._exec !=# ''
|
||||
call syntastic#log#error('checker ' . name . ' returned abnormal status ' . v:shell_error)
|
||||
else
|
||||
call syntastic#log#error('checker ' . name . ' aborted')
|
||||
endif
|
||||
endtry
|
||||
call self._populateHighlightRegexes(list)
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, name . ' raw:', list)
|
||||
call self._quietMessages(list)
|
||||
return list
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.getLocList() abort " {{{2
|
||||
return g:SyntasticLoclist.New(self.getLocListRaw())
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.getVersion(...) abort " {{{2
|
||||
if !exists('self._version')
|
||||
let command = a:0 ? a:1 : self.getExecEscaped() . ' --version'
|
||||
let version_output = syntastic#util#system(command)
|
||||
call self.log('getVersion: ' . string(command) . ': ' .
|
||||
\ string(split(version_output, "\n", 1)) .
|
||||
\ (v:shell_error ? ' (exit code ' . v:shell_error . ')' : '') )
|
||||
call self.setVersion(syntastic#util#parseVersion(version_output))
|
||||
endif
|
||||
return get(self, '_version', [])
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.setVersion(version) abort " {{{2
|
||||
if len(a:version)
|
||||
let self._version = copy(a:version)
|
||||
call self.log(self.getExec() . ' version =', a:version)
|
||||
else
|
||||
call syntastic#log#error("checker " . self._filetype . "/" . self._name . ": can't parse version string (abnormal termination?)")
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.log(msg, ...) abort " {{{2
|
||||
let leader = self._filetype . '/' . self._name . ': '
|
||||
if a:0 > 0
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, leader . a:msg, a:1)
|
||||
else
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_CHECKERS, leader . a:msg)
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.makeprgBuild(opts) abort " {{{2
|
||||
let basename = self._filetype . '_' . self._name . '_'
|
||||
|
||||
let parts = []
|
||||
call extend(parts, self._getOpt(a:opts, basename, 'exe', self.getExecEscaped()))
|
||||
call extend(parts, self._getOpt(a:opts, basename, 'args', ''))
|
||||
call extend(parts, self._getOpt(a:opts, basename, 'fname', syntastic#util#shexpand('%')))
|
||||
call extend(parts, self._getOpt(a:opts, basename, 'post_args', ''))
|
||||
call extend(parts, self._getOpt(a:opts, basename, 'tail', ''))
|
||||
|
||||
return join(parts)
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.isAvailable() abort " {{{2
|
||||
call self.syncExec()
|
||||
if !has_key(self, '_available')
|
||||
let self._available = self._isAvailableFunc()
|
||||
endif
|
||||
return self._available
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker.wantSort() abort " {{{2
|
||||
return syntastic#util#var(self._filetype . '_' . self._name . '_sort', 0)
|
||||
endfunction " }}}2
|
||||
|
||||
" This method is no longer used by syntastic. It's here only to maintain
|
||||
" backwards compatibility with external checkers which might depend on it.
|
||||
function! g:SyntasticChecker.setWantSort(val) abort " {{{2
|
||||
if !exists('g:syntastic_' . self._filetype . '_' . self._name . '_sort')
|
||||
let g:syntastic_{self._filetype}_{self._name}_sort = a:val
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private methods {{{1
|
||||
|
||||
function! g:SyntasticChecker._quietMessages(errors) abort " {{{2
|
||||
" wildcard quiet_messages
|
||||
let quiet_filters = copy(syntastic#util#var('quiet_messages', {}))
|
||||
if type(quiet_filters) != type({})
|
||||
call syntastic#log#warn('ignoring invalid syntastic_quiet_messages')
|
||||
unlet quiet_filters
|
||||
let quiet_filters = {}
|
||||
endif
|
||||
|
||||
" per checker quiet_messages
|
||||
let name = self._filetype . '_' . self._name
|
||||
try
|
||||
call extend( quiet_filters, copy(syntastic#util#var(name . '_quiet_messages', {})), 'force' )
|
||||
catch /\m^Vim\%((\a\+)\)\=:E712/
|
||||
call syntastic#log#warn('ignoring invalid syntastic_' . name . '_quiet_messages')
|
||||
endtry
|
||||
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'quiet_messages filter:', quiet_filters)
|
||||
|
||||
if !empty(quiet_filters)
|
||||
call syntastic#util#dictFilter(a:errors, quiet_filters)
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_LOCLIST, 'filtered by quiet_messages:', a:errors)
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker._populateHighlightRegexes(errors) abort " {{{2
|
||||
if has_key(self, '_highlightRegexFunc')
|
||||
for e in a:errors
|
||||
if e['valid']
|
||||
let term = self._highlightRegexFunc(e)
|
||||
if term !=# ''
|
||||
let e['hl'] = term
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticChecker._getOpt(opts, basename, name, default) abort " {{{2
|
||||
let ret = []
|
||||
call extend( ret, syntastic#util#argsescape(get(a:opts, a:name . '_before', '')) )
|
||||
call extend( ret, syntastic#util#argsescape(syntastic#util#var( a:basename . a:name, get(a:opts, a:name, a:default) )) )
|
||||
call extend( ret, syntastic#util#argsescape(get(a:opts, a:name . '_after', '')) )
|
||||
|
||||
return ret
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private functions {{{1
|
||||
|
||||
function! s:_isAvailableDefault() dict " {{{2
|
||||
return executable(self.getExec())
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,138 @@
|
||||
if exists('g:loaded_syntastic_notifier_cursor') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_notifier_cursor = 1
|
||||
|
||||
let g:SyntasticCursorNotifier = {}
|
||||
|
||||
" Public methods {{{1
|
||||
|
||||
function! g:SyntasticCursorNotifier.New() abort " {{{2
|
||||
let newObj = copy(self)
|
||||
return newObj
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticCursorNotifier.enabled() abort " {{{2
|
||||
return syntastic#util#var('echo_current_error')
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticCursorNotifier.refresh(loclist) abort " {{{2
|
||||
if self.enabled() && !a:loclist.isEmpty()
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'cursor: refresh')
|
||||
let b:syntastic_private_messages = copy(a:loclist.messages(bufnr('')))
|
||||
let b:syntastic_private_line = -1
|
||||
let b:syntastic_cursor_columns = a:loclist.getCursorColumns()
|
||||
autocmd! syntastic CursorMoved
|
||||
autocmd syntastic CursorMoved * call SyntasticRefreshCursor()
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" @vimlint(EVL103, 1, a:loclist)
|
||||
function! g:SyntasticCursorNotifier.reset(loclist) abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'cursor: reset')
|
||||
autocmd! syntastic CursorMoved
|
||||
unlet! b:syntastic_private_messages
|
||||
let b:syntastic_private_line = -1
|
||||
endfunction " }}}2
|
||||
" @vimlint(EVL103, 0, a:loclist)
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private functions {{{1
|
||||
|
||||
function! SyntasticRefreshCursor() abort " {{{2
|
||||
if !exists('b:syntastic_private_messages') || empty(b:syntastic_private_messages)
|
||||
" file not checked
|
||||
return
|
||||
endif
|
||||
|
||||
if !exists('b:syntastic_private_line')
|
||||
let b:syntastic_private_line = -1
|
||||
endif
|
||||
let l = line('.')
|
||||
let current_messages = get(b:syntastic_private_messages, l, {})
|
||||
|
||||
if !exists('b:syntastic_cursor_columns')
|
||||
let b:syntastic_cursor_columns = g:syntastic_cursor_columns
|
||||
endif
|
||||
|
||||
if b:syntastic_cursor_columns
|
||||
let c = virtcol('.')
|
||||
if !exists('b:syntastic_private_idx')
|
||||
let b:syntastic_private_idx = -1
|
||||
endif
|
||||
|
||||
if s:_is_same_index(l, b:syntastic_private_line, c, b:syntastic_private_idx, current_messages)
|
||||
return
|
||||
else
|
||||
let b:syntastic_private_line = l
|
||||
endif
|
||||
|
||||
if !empty(current_messages)
|
||||
let b:syntastic_private_idx = s:_find_index(c, current_messages)
|
||||
call syntastic#util#wideMsg(current_messages[b:syntastic_private_idx].text)
|
||||
else
|
||||
let b:syntastic_private_idx = -1
|
||||
echo
|
||||
endif
|
||||
else
|
||||
if l == b:syntastic_private_line
|
||||
return
|
||||
endif
|
||||
let b:syntastic_private_line = l
|
||||
|
||||
if !empty(current_messages)
|
||||
call syntastic#util#wideMsg(current_messages[0].text)
|
||||
else
|
||||
echo
|
||||
endif
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Utilities {{{1
|
||||
|
||||
function! s:_is_same_index(line, old_line, column, idx, messages) abort " {{{2
|
||||
if a:old_line >= 0 && a:line == a:old_line && a:idx >= 0
|
||||
if len(a:messages) <= 1
|
||||
return 1
|
||||
endif
|
||||
|
||||
if a:messages[a:idx].scol <= a:column || a:idx == 0
|
||||
if a:idx == len(a:messages) - 1 || a:column < a:messages[a:idx + 1].scol
|
||||
return 1
|
||||
else
|
||||
return 0
|
||||
endif
|
||||
else
|
||||
return 0
|
||||
endif
|
||||
else
|
||||
return 0
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_find_index(column, messages) abort " {{{2
|
||||
let max = len(a:messages) - 1
|
||||
if max == 0
|
||||
return 0
|
||||
endif
|
||||
let min = 0
|
||||
|
||||
" modified binary search: assign index 0 to columns to the left of the first error
|
||||
while min < max - 1
|
||||
let mid = (min + max) / 2
|
||||
if a:column < a:messages[mid].scol
|
||||
let max = mid
|
||||
else
|
||||
let min = mid
|
||||
endif
|
||||
endwhile
|
||||
|
||||
return a:column < a:messages[max].scol ? min : max
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,104 @@
|
||||
if exists('g:loaded_syntastic_notifier_highlighting') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
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 = {}
|
||||
|
||||
let s:setup_done = 0
|
||||
|
||||
" Public methods {{{1
|
||||
|
||||
function! g:SyntasticHighlightingNotifier.New() abort " {{{2
|
||||
let newObj = copy(self)
|
||||
|
||||
if !s:setup_done
|
||||
call self._setup()
|
||||
let s:setup_done = 1
|
||||
lockvar s:setup_done
|
||||
endif
|
||||
|
||||
return newObj
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticHighlightingNotifier.enabled() abort " {{{2
|
||||
return s:has_highlighting && syntastic#util#var('enable_highlighting')
|
||||
endfunction " }}}2
|
||||
|
||||
" Sets error highlights in the current window
|
||||
function! g:SyntasticHighlightingNotifier.refresh(loclist) abort " {{{2
|
||||
if self.enabled()
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'highlighting: refresh')
|
||||
call self._reset()
|
||||
let buf = bufnr('')
|
||||
let issues = filter(a:loclist.copyRaw(), 'v:val["bufnr"] == buf')
|
||||
for item in issues
|
||||
let group = 'Syntastic' . get(item, 'subtype', '') . ( item['type'] ==? 'E' ? 'Error' : 'Warning' )
|
||||
|
||||
" The function `Syntastic_{filetype}_{checker}_GetHighlightRegex` is
|
||||
" used to override default highlighting.
|
||||
if has_key(item, 'hl')
|
||||
call matchadd(group, '\%' . item['lnum'] . 'l' . item['hl'])
|
||||
elseif get(item, 'col', 0)
|
||||
if get(item, 'vcol', 0)
|
||||
let lastcol = virtcol([item['lnum'], '$'])
|
||||
let coltype = 'v'
|
||||
else
|
||||
let lastcol = col([item['lnum'], '$'])
|
||||
let coltype = 'c'
|
||||
endif
|
||||
let lcol = min([lastcol, item['col']])
|
||||
|
||||
call matchadd(group, '\%' . item['lnum'] . 'l\%' . lcol . coltype)
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" Remove all error highlights from the window
|
||||
" @vimlint(EVL103, 1, a:loclist)
|
||||
function! g:SyntasticHighlightingNotifier.reset(loclist) abort " {{{2
|
||||
if s:has_highlighting
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'highlighting: reset')
|
||||
call self._reset()
|
||||
endif
|
||||
endfunction " }}}2
|
||||
" @vimlint(EVL103, 0, a:loclist)
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private methods {{{1
|
||||
|
||||
" One time setup: define our own highlighting
|
||||
function! g:SyntasticHighlightingNotifier._setup() abort " {{{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() abort " {{{2
|
||||
for match in getmatches()
|
||||
if stridx(match['group'], 'Syntastic') == 0
|
||||
call matchdelete(match['id'])
|
||||
endif
|
||||
endfor
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,434 @@
|
||||
if exists('g:loaded_syntastic_loclist') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_loclist = 1
|
||||
|
||||
let g:SyntasticLoclist = {}
|
||||
|
||||
" Public methods {{{1
|
||||
|
||||
function! g:SyntasticLoclist.New(rawLoclist) abort " {{{2
|
||||
let newObj = copy(self)
|
||||
|
||||
let llist = filter(copy(a:rawLoclist), 'v:val["valid"] == 1')
|
||||
|
||||
for e in llist
|
||||
if get(e, 'type', '') ==# ''
|
||||
let e['type'] = 'E'
|
||||
endif
|
||||
endfor
|
||||
|
||||
let newObj._rawLoclist = llist
|
||||
let newObj._name = ''
|
||||
let newObj._owner = bufnr('')
|
||||
let newObj._sorted = 0
|
||||
let newObj._columns = g:syntastic_cursor_columns
|
||||
|
||||
return newObj
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.current() abort " {{{2
|
||||
if !exists('b:syntastic_loclist') || empty(b:syntastic_loclist)
|
||||
let b:syntastic_loclist = g:SyntasticLoclist.New([])
|
||||
endif
|
||||
return b:syntastic_loclist
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.extend(other) abort " {{{2
|
||||
let list = self.copyRaw()
|
||||
call extend(list, a:other.copyRaw())
|
||||
return g:SyntasticLoclist.New(list)
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.sort() abort " {{{2
|
||||
if !self._sorted
|
||||
for e in self._rawLoclist
|
||||
call s:_set_screen_column(e)
|
||||
endfor
|
||||
|
||||
call sort(self._rawLoclist, self._columns ? 's:_compare_error_items_by_columns' : 's:_compare_error_items_by_lines')
|
||||
|
||||
let self._sorted = 1
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.isEmpty() abort " {{{2
|
||||
return empty(self._rawLoclist)
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.isNewerThan(stamp) abort " {{{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() abort " {{{2
|
||||
return copy(self._rawLoclist)
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.getRaw() abort " {{{2
|
||||
return self._rawLoclist
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.getBuffers() abort " {{{2
|
||||
return syntastic#util#unique(map(copy(self._rawLoclist), 'str2nr(v:val["bufnr"])') + [self._owner])
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.getCursorColumns() abort " {{{2
|
||||
return self._columns
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.getStatuslineFlag() abort " {{{2
|
||||
if !exists('self._stl_format')
|
||||
let self._stl_format = ''
|
||||
endif
|
||||
if !exists('self._stl_flag')
|
||||
let self._stl_flag = ''
|
||||
endif
|
||||
|
||||
if g:syntastic_stl_format !=# self._stl_format
|
||||
let self._stl_format = g:syntastic_stl_format
|
||||
|
||||
if !empty(self._rawLoclist)
|
||||
let errors = self.errors()
|
||||
let warnings = self.warnings()
|
||||
|
||||
let num_errors = len(errors)
|
||||
let num_warnings = len(warnings)
|
||||
let num_issues = len(self._rawLoclist)
|
||||
|
||||
let output = self._stl_format
|
||||
|
||||
"hide stuff wrapped in %E(...) unless there are errors
|
||||
let output = substitute(output, '\m\C%E{\([^}]*\)}', num_errors ? '\1' : '' , 'g')
|
||||
|
||||
"hide stuff wrapped in %W(...) unless there are warnings
|
||||
let output = substitute(output, '\m\C%W{\([^}]*\)}', num_warnings ? '\1' : '' , 'g')
|
||||
|
||||
"hide stuff wrapped in %B(...) unless there are both errors and warnings
|
||||
let output = substitute(output, '\m\C%B{\([^}]*\)}', (num_warnings && num_errors) ? '\1' : '' , 'g')
|
||||
|
||||
"sub in the total errors/warnings/both
|
||||
let output = substitute(output, '\m\C%w', num_warnings, 'g')
|
||||
let output = substitute(output, '\m\C%e', num_errors, 'g')
|
||||
let output = substitute(output, '\m\C%t', num_issues, 'g')
|
||||
|
||||
"first error/warning line num
|
||||
let output = substitute(output, '\m\C%F', num_issues ? self._rawLoclist[0]['lnum'] : '', 'g')
|
||||
|
||||
"first error line num
|
||||
let output = substitute(output, '\m\C%fe', num_errors ? errors[0]['lnum'] : '', 'g')
|
||||
|
||||
"first warning line num
|
||||
let output = substitute(output, '\m\C%fw', num_warnings ? warnings[0]['lnum'] : '', 'g')
|
||||
|
||||
let self._stl_flag = output
|
||||
else
|
||||
let self._stl_flag = ''
|
||||
endif
|
||||
endif
|
||||
|
||||
return self._stl_flag
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.getFirstError(...) abort " {{{2
|
||||
let max_issues = len(self._rawLoclist)
|
||||
if a:0 && a:1 < max_issues
|
||||
let max_issues = a:1
|
||||
endif
|
||||
|
||||
for idx in range(max_issues)
|
||||
if get(self._rawLoclist[idx], 'type', '') ==? 'E'
|
||||
return idx + 1
|
||||
endif
|
||||
endfor
|
||||
|
||||
return 0
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.getName() abort " {{{2
|
||||
return len(self._name)
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.setName(name) abort " {{{2
|
||||
let self._name = a:name
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.getOwner() abort " {{{2
|
||||
return self._owner
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.setOwner(buffer) abort " {{{2
|
||||
let self._owner = type(a:buffer) == type(0) ? a:buffer : str2nr(a:buffer)
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.deploy() abort " {{{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() abort " {{{2
|
||||
for buf in self.getBuffers()
|
||||
call setbufvar(buf, 'syntastic_loclist', {})
|
||||
endfor
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.decorate(tag) abort " {{{2
|
||||
for e in self._rawLoclist
|
||||
let e['text'] .= ' [' . a:tag . ']'
|
||||
endfor
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.balloons() abort " {{{2
|
||||
if !exists('self._cachedBalloons')
|
||||
let sep = has('balloon_multiline') ? "\n" : ' | '
|
||||
|
||||
let self._cachedBalloons = {}
|
||||
for e in self._rawLoclist
|
||||
let buf = e['bufnr']
|
||||
|
||||
if !has_key(self._cachedBalloons, buf)
|
||||
let self._cachedBalloons[buf] = {}
|
||||
endif
|
||||
|
||||
if has_key(self._cachedBalloons[buf], e['lnum'])
|
||||
let self._cachedBalloons[buf][e['lnum']] .= sep . e['text']
|
||||
else
|
||||
let self._cachedBalloons[buf][e['lnum']] = e['text']
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
|
||||
return get(self._cachedBalloons, bufnr(''), {})
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.errors() abort " {{{2
|
||||
if !exists('self._cachedErrors')
|
||||
let self._cachedErrors = self.filter({'type': 'E'})
|
||||
endif
|
||||
return self._cachedErrors
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.warnings() abort " {{{2
|
||||
if !exists('self._cachedWarnings')
|
||||
let self._cachedWarnings = self.filter({'type': 'W'})
|
||||
endif
|
||||
return self._cachedWarnings
|
||||
endfunction " }}}2
|
||||
|
||||
" Legacy function. Syntastic no longer calls it, but we keep it
|
||||
" around because other plugins (f.i. powerline) depend on it.
|
||||
function! g:SyntasticLoclist.hasErrorsOrWarningsToDisplay() abort " {{{2
|
||||
return !self.isEmpty()
|
||||
endfunction " }}}2
|
||||
|
||||
" cache used by EchoCurrentError()
|
||||
function! g:SyntasticLoclist.messages(buf) abort " {{{2
|
||||
if !exists('self._cachedMessages')
|
||||
let self._cachedMessages = {}
|
||||
|
||||
let errors = self.errors() + self.warnings()
|
||||
for e in errors
|
||||
let b = e['bufnr']
|
||||
let l = e['lnum']
|
||||
|
||||
if !has_key(self._cachedMessages, b)
|
||||
let self._cachedMessages[b] = {}
|
||||
endif
|
||||
|
||||
if !has_key(self._cachedMessages[b], l)
|
||||
let self._cachedMessages[b][l] = [e]
|
||||
elseif self._columns
|
||||
call add(self._cachedMessages[b][l], e)
|
||||
endif
|
||||
endfor
|
||||
|
||||
if self._columns
|
||||
if !self._sorted
|
||||
for b in keys(self._cachedMessages)
|
||||
for l in keys(self._cachedMessages[b])
|
||||
if len(self._cachedMessages[b][l]) > 1
|
||||
for e in self._cachedMessages[b][l]
|
||||
call s:_set_screen_column(e)
|
||||
endfor
|
||||
call sort(self._cachedMessages[b][l], 's:_compare_error_items_by_columns')
|
||||
endif
|
||||
endfor
|
||||
endfor
|
||||
endif
|
||||
|
||||
for b in keys(self._cachedMessages)
|
||||
for l in keys(self._cachedMessages[b])
|
||||
call s:_remove_shadowed_items(self._cachedMessages[b][l])
|
||||
endfor
|
||||
endfor
|
||||
endif
|
||||
endif
|
||||
|
||||
return get(self._cachedMessages, a:buf, {})
|
||||
endfunction " }}}2
|
||||
|
||||
"Filter the list and return new native loclist
|
||||
"e.g.
|
||||
" .filter({'bufnr': 10, 'type': 'e'})
|
||||
"
|
||||
"would return all errors for buffer 10.
|
||||
"
|
||||
"Note that all comparisons are done with ==?
|
||||
function! g:SyntasticLoclist.filter(filters) abort " {{{2
|
||||
let conditions = values(map(copy(a:filters), 's:_translate(v:key, v:val)'))
|
||||
let filter = len(conditions) == 1 ?
|
||||
\ conditions[0] : join(map(conditions, '"(" . v:val . ")"'), ' && ')
|
||||
return filter(copy(self._rawLoclist), filter)
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticLoclist.setloclist() abort " {{{2
|
||||
if !exists('w:syntastic_loclist_set')
|
||||
let w:syntastic_loclist_set = 0
|
||||
endif
|
||||
let replace = g:syntastic_reuse_loc_lists && w:syntastic_loclist_set
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: setloclist ' . (replace ? '(replace)' : '(new)'))
|
||||
call setloclist(0, self.getRaw(), replace ? 'r' : ' ')
|
||||
let w:syntastic_loclist_set = 1
|
||||
endfunction " }}}2
|
||||
|
||||
"display the cached errors for this buf in the location list
|
||||
function! g:SyntasticLoclist.show() abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: show')
|
||||
call self.setloclist()
|
||||
|
||||
if !self.isEmpty()
|
||||
let num = winnr()
|
||||
execute 'lopen ' . syntastic#util#var('loc_list_height')
|
||||
if num != winnr()
|
||||
execute num . 'wincmd w'
|
||||
endif
|
||||
|
||||
" try to find the loclist window and set w:quickfix_title
|
||||
let errors = getloclist(0)
|
||||
for buf in tabpagebuflist()
|
||||
if buflisted(buf) && bufloaded(buf) && getbufvar(buf, '&buftype') ==# 'quickfix'
|
||||
let win = bufwinnr(buf)
|
||||
let title = getwinvar(win, 'quickfix_title')
|
||||
|
||||
" TODO: try to make sure we actually own this window; sadly,
|
||||
" errors == getloclist(0) is the only somewhat safe way to
|
||||
" achieve that
|
||||
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
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Public functions {{{1
|
||||
|
||||
function! SyntasticLoclistHide() abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'loclist: hide')
|
||||
silent! lclose
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Utilities {{{1
|
||||
|
||||
function! s:_translate(key, val) abort " {{{2
|
||||
return 'get(v:val, ' . string(a:key) . ', "") ==? ' . string(a:val)
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_set_screen_column(item) abort " {{{2
|
||||
if !has_key(a:item, 'scol')
|
||||
let col = get(a:item, 'col', 0)
|
||||
if col != 0 && get(a:item, 'vcol', 0) == 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'] = syntastic#util#screenWidth(strpart(line, 0, col), getbufvar(buf, '&tabstop'))
|
||||
else
|
||||
let a:item['scol'] = col
|
||||
endif
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_remove_shadowed_items(errors) abort " {{{2
|
||||
" keep only the first message at a given column
|
||||
let i = 0
|
||||
while i < len(a:errors) - 1
|
||||
let j = i + 1
|
||||
let dupes = 0
|
||||
while j < len(a:errors) && a:errors[j].scol == a:errors[i].scol
|
||||
let dupes = 1
|
||||
let j += 1
|
||||
endwhile
|
||||
if dupes
|
||||
call remove(a:errors, i + 1, j - 1)
|
||||
endif
|
||||
let i += 1
|
||||
endwhile
|
||||
|
||||
" merge messages with the same text
|
||||
let i = 0
|
||||
while i < len(a:errors) - 1
|
||||
let j = i + 1
|
||||
let dupes = 0
|
||||
while j < len(a:errors) && a:errors[j].text == a:errors[i].text
|
||||
let dupes = 1
|
||||
let j += 1
|
||||
endwhile
|
||||
if dupes
|
||||
call remove(a:errors, i + 1, j - 1)
|
||||
endif
|
||||
let i += 1
|
||||
endwhile
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_compare_error_items_by_columns(a, b) abort " {{{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['scol'] != a:b['scol']
|
||||
" sort by screen column
|
||||
return a:a['scol'] - a:b['scol']
|
||||
elseif a:a['type'] !=? a:b['type']
|
||||
" errors take precedence over warnings
|
||||
return a:a['type'] ==? 'E' ? -1 : 1
|
||||
else
|
||||
return 0
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_compare_error_items_by_lines(a, b) abort " {{{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
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,117 @@
|
||||
if exists('g:loaded_syntastic_modemap') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_modemap = 1
|
||||
|
||||
let g:SyntasticModeMap = {}
|
||||
|
||||
" Public methods {{{1
|
||||
|
||||
function! g:SyntasticModeMap.Instance() abort " {{{2
|
||||
if !exists('s:SyntasticModeMapInstance')
|
||||
let s:SyntasticModeMapInstance = copy(self)
|
||||
call s:SyntasticModeMapInstance.synch()
|
||||
endif
|
||||
|
||||
return s:SyntasticModeMapInstance
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticModeMap.synch() abort " {{{2
|
||||
if exists('g:syntastic_mode_map')
|
||||
let self._mode = get(g:syntastic_mode_map, 'mode', 'active')
|
||||
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 = []
|
||||
let self._passiveFiletypes = []
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticModeMap.allowsAutoChecking(filetype) abort " {{{2
|
||||
let fts = split(a:filetype, '\m\.')
|
||||
|
||||
if self.isPassive()
|
||||
return self._isOneFiletypeActive(fts)
|
||||
else
|
||||
return self._noFiletypesArePassive(fts)
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticModeMap.doAutoChecking() abort " {{{2
|
||||
let local_mode = get(b:, 'syntastic_mode', '')
|
||||
if local_mode ==# 'active' || local_mode ==# 'passive'
|
||||
return local_mode ==# 'active'
|
||||
endif
|
||||
|
||||
return self.allowsAutoChecking(&filetype)
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticModeMap.isPassive() abort " {{{2
|
||||
return self._mode ==# 'passive'
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticModeMap.toggleMode() abort " {{{2
|
||||
call self.synch()
|
||||
|
||||
if self._mode ==# 'active'
|
||||
let self._mode = 'passive'
|
||||
else
|
||||
let self._mode = 'active'
|
||||
endif
|
||||
|
||||
"XXX Changing a global variable. Tsk, tsk...
|
||||
if !exists('g:syntastic_mode_map')
|
||||
let g:syntastic_mode_map = {}
|
||||
endif
|
||||
let g:syntastic_mode_map['mode'] = self._mode
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticModeMap.echoMode() abort " {{{2
|
||||
echo 'Syntastic: ' . self._mode . ' mode enabled'
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticModeMap.modeInfo(filetypes) abort " {{{2
|
||||
echomsg 'Syntastic version: ' . g:_SYNTASTIC_VERSION . ' (Vim ' . v:version . ', ' . g:_SYNTASTIC_UNAME . ')'
|
||||
let type = len(a:filetypes) ? a:filetypes[0] : &filetype
|
||||
echomsg 'Info for filetype: ' . type
|
||||
|
||||
call self.synch()
|
||||
echomsg 'Global 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')
|
||||
|
||||
if !len(a:filetypes)
|
||||
if exists('b:syntastic_mode') && (b:syntastic_mode ==# 'active' || b:syntastic_mode ==# 'passive')
|
||||
echomsg 'Local mode: ' . b:syntastic_mode
|
||||
endif
|
||||
|
||||
echomsg 'The current file will ' . (self.doAutoChecking() ? '' : 'not ') . 'be checked automatically'
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private methods {{{1
|
||||
|
||||
function! g:SyntasticModeMap._isOneFiletypeActive(filetypes) abort " {{{2
|
||||
return !empty(filter(copy(a:filetypes), 'index(self._activeFiletypes, v:val) != -1'))
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticModeMap._noFiletypesArePassive(filetypes) abort " {{{2
|
||||
return empty(filter(copy(a:filetypes), 'index(self._passiveFiletypes, v:val) != -1'))
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,86 @@
|
||||
if exists('g:loaded_syntastic_notifiers') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
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
|
||||
|
||||
function! g:SyntasticNotifiers.Instance() abort " {{{2
|
||||
if !exists('s:SyntasticNotifiersInstance')
|
||||
let s:SyntasticNotifiersInstance = copy(self)
|
||||
call s:SyntasticNotifiersInstance._initNotifiers()
|
||||
endif
|
||||
|
||||
return s:SyntasticNotifiersInstance
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticNotifiers.refresh(loclist) abort " {{{2
|
||||
if !a:loclist.isEmpty() && !a:loclist.isNewerThan([])
|
||||
" loclist not fully constructed yet
|
||||
return
|
||||
endif
|
||||
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, '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_private_' . type . '_stamp')
|
||||
let b:syntastic_private_{type}_stamp = []
|
||||
endif
|
||||
if a:loclist.isNewerThan(b:syntastic_private_{type}_stamp) || a:loclist.isEmpty()
|
||||
call self._notifier[type].refresh(a:loclist)
|
||||
let b:syntastic_private_{type}_stamp = syntastic#util#stamp()
|
||||
endif
|
||||
else
|
||||
call self._notifier[type].refresh(a:loclist)
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticNotifiers.reset(loclist) abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'notifiers: reset')
|
||||
for type in self._enabled_types
|
||||
let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '')
|
||||
|
||||
" reset notifiers regardless if they are enabled or not, since
|
||||
" the user might have disabled them since the last refresh();
|
||||
" notifiers MUST be prepared to deal with reset() when disabled
|
||||
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_private_{type}_stamp = []
|
||||
endif
|
||||
endfor
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private methods {{{1
|
||||
|
||||
function! g:SyntasticNotifiers._initNotifiers() abort " {{{2
|
||||
let self._notifier = {}
|
||||
for type in s:_NOTIFIER_TYPES
|
||||
let class = substitute(type, '\m.*', 'Syntastic\u&Notifier', '')
|
||||
let self._notifier[type] = g:{class}.New()
|
||||
endfor
|
||||
|
||||
let self._enabled_types = copy(s:_NOTIFIER_TYPES)
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,333 @@
|
||||
if exists('g:loaded_syntastic_registry') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_registry = 1
|
||||
|
||||
" Initialisation {{{1
|
||||
|
||||
let s:_DEFAULT_CHECKERS = {
|
||||
\ 'actionscript': ['mxmlc'],
|
||||
\ 'ada': ['gcc'],
|
||||
\ 'apiblueprint': ['snowcrash'],
|
||||
\ 'applescript': ['osacompile'],
|
||||
\ 'asciidoc': ['asciidoc'],
|
||||
\ 'asm': ['gcc'],
|
||||
\ 'bro': ['bro'],
|
||||
\ 'bemhtml': ['bemhtmllint'],
|
||||
\ 'c': ['gcc'],
|
||||
\ 'cabal': ['cabal'],
|
||||
\ 'chef': ['foodcritic'],
|
||||
\ 'co': ['coco'],
|
||||
\ 'cobol': ['cobc'],
|
||||
\ 'coffee': ['coffee', 'coffeelint'],
|
||||
\ 'coq': ['coqtop'],
|
||||
\ 'cpp': ['gcc'],
|
||||
\ 'cs': ['mcs'],
|
||||
\ 'css': ['csslint'],
|
||||
\ 'cucumber': ['cucumber'],
|
||||
\ 'cuda': ['nvcc'],
|
||||
\ 'd': ['dmd'],
|
||||
\ 'dart': ['dartanalyzer'],
|
||||
\ 'docbk': ['xmllint'],
|
||||
\ 'dustjs': ['swiffer'],
|
||||
\ 'elixir': [],
|
||||
\ 'erlang': ['escript'],
|
||||
\ 'eruby': ['ruby'],
|
||||
\ 'fortran': ['gfortran'],
|
||||
\ 'glsl': ['cgc'],
|
||||
\ 'go': ['go'],
|
||||
\ 'haml': ['haml'],
|
||||
\ 'handlebars': ['handlebars'],
|
||||
\ 'haskell': ['ghc_mod', 'hdevtools', 'hlint'],
|
||||
\ 'haxe': ['haxe'],
|
||||
\ 'hss': ['hss'],
|
||||
\ 'html': ['tidy'],
|
||||
\ 'java': ['javac'],
|
||||
\ 'javascript': ['jshint', 'jslint'],
|
||||
\ 'json': ['jsonlint', 'jsonval'],
|
||||
\ 'less': ['lessc'],
|
||||
\ 'lex': ['flex'],
|
||||
\ 'limbo': ['limbo'],
|
||||
\ 'lisp': ['clisp'],
|
||||
\ 'llvm': ['llvm'],
|
||||
\ 'lua': ['luac'],
|
||||
\ 'markdown': ['mdl'],
|
||||
\ 'matlab': ['mlint'],
|
||||
\ 'mercury': ['mmc'],
|
||||
\ 'nasm': ['nasm'],
|
||||
\ 'nroff': ['mandoc'],
|
||||
\ 'objc': ['gcc'],
|
||||
\ 'objcpp': ['gcc'],
|
||||
\ 'ocaml': ['camlp4o'],
|
||||
\ 'perl': ['perlcritic'],
|
||||
\ 'php': ['php', 'phpcs', 'phpmd'],
|
||||
\ 'po': ['msgfmt'],
|
||||
\ 'pod': ['podchecker'],
|
||||
\ 'puppet': ['puppet', 'puppetlint'],
|
||||
\ 'python': ['python', 'flake8', 'pylint'],
|
||||
\ 'r': [],
|
||||
\ 'racket': ['racket'],
|
||||
\ 'rnc': ['rnv'],
|
||||
\ 'rst': ['rst2pseudoxml'],
|
||||
\ 'ruby': ['mri'],
|
||||
\ 'sass': ['sass'],
|
||||
\ 'scala': ['fsc', 'scalac'],
|
||||
\ 'scss': ['sass', 'scss_lint'],
|
||||
\ 'sh': ['sh', 'shellcheck'],
|
||||
\ 'slim': ['slimrb'],
|
||||
\ 'sml': ['smlnj'],
|
||||
\ 'spec': ['rpmlint'],
|
||||
\ 'tcl': ['nagelfar'],
|
||||
\ 'tex': ['lacheck', 'chktex'],
|
||||
\ 'texinfo': ['makeinfo'],
|
||||
\ 'text': [],
|
||||
\ 'twig': ['twiglint'],
|
||||
\ 'typescript': ['tsc'],
|
||||
\ 'vala': ['valac'],
|
||||
\ 'verilog': ['verilator'],
|
||||
\ 'vhdl': ['ghdl'],
|
||||
\ 'vim': ['vimlint'],
|
||||
\ 'xhtml': ['tidy'],
|
||||
\ 'xml': ['xmllint'],
|
||||
\ 'xslt': ['xmllint'],
|
||||
\ 'yacc': ['bison'],
|
||||
\ 'yaml': ['jsyaml'],
|
||||
\ 'z80': ['z80syntaxchecker'],
|
||||
\ 'zpt': ['zptlint'],
|
||||
\ 'zsh': ['zsh'],
|
||||
\ }
|
||||
lockvar! s:_DEFAULT_CHECKERS
|
||||
|
||||
let s:_DEFAULT_FILETYPE_MAP = {
|
||||
\ 'gentoo-metadata': 'xml',
|
||||
\ 'groff': 'nroff',
|
||||
\ 'lhaskell': 'haskell',
|
||||
\ 'litcoffee': 'coffee',
|
||||
\ 'mail': 'text',
|
||||
\ 'mkd': 'markdown',
|
||||
\ 'pe-puppet': 'puppet',
|
||||
\ 'sgml': 'docbk',
|
||||
\ 'sgmllnx': 'docbk',
|
||||
\ }
|
||||
lockvar! s:_DEFAULT_FILETYPE_MAP
|
||||
|
||||
let s:_ECLIM_TYPES = [
|
||||
\ 'c',
|
||||
\ 'cpp',
|
||||
\ 'html',
|
||||
\ 'java',
|
||||
\ 'php',
|
||||
\ 'python',
|
||||
\ 'ruby',
|
||||
\ ]
|
||||
lockvar! s:_ECLIM_TYPES
|
||||
|
||||
let s:_YCM_TYPES = [
|
||||
\ 'c',
|
||||
\ 'cpp',
|
||||
\ 'objc',
|
||||
\ 'objcpp',
|
||||
\ ]
|
||||
lockvar! s:_YCM_TYPES
|
||||
|
||||
let g:SyntasticRegistry = {}
|
||||
|
||||
" }}}1
|
||||
|
||||
" Public methods {{{1
|
||||
|
||||
" 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() abort " {{{2
|
||||
if !exists('s:SyntasticRegistryInstance')
|
||||
let s:SyntasticRegistryInstance = copy(self)
|
||||
let s:SyntasticRegistryInstance._checkerMap = {}
|
||||
endif
|
||||
|
||||
return s:SyntasticRegistryInstance
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticRegistry.CreateAndRegisterChecker(args) abort " {{{2
|
||||
let checker = g:SyntasticChecker.New(a:args)
|
||||
let registry = g:SyntasticRegistry.Instance()
|
||||
call registry._registerChecker(checker)
|
||||
endfunction " }}}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) abort " {{{2
|
||||
let ft = s:_normalise_filetype(a:ftalias)
|
||||
call self._loadCheckersFor(ft)
|
||||
|
||||
let checkers_map = self._checkerMap[ft]
|
||||
if empty(checkers_map)
|
||||
return []
|
||||
endif
|
||||
|
||||
call self._checkDeprecation(ft)
|
||||
|
||||
let names =
|
||||
\ !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:_DEFAULT_CHECKERS, ft, 0)
|
||||
|
||||
return type(names) == type([]) ?
|
||||
\ 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) abort " {{{2
|
||||
return filter(self.getCheckers(a:ftalias, a:hints_list), 'v:val.isAvailable()')
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticRegistry.getKnownFiletypes() abort " {{{2
|
||||
let types = keys(s:_DEFAULT_CHECKERS)
|
||||
|
||||
call extend(types, keys(s:_DEFAULT_FILETYPE_MAP))
|
||||
|
||||
if exists('g:syntastic_filetype_map')
|
||||
call extend(types, keys(g:syntastic_filetype_map))
|
||||
endif
|
||||
|
||||
if exists('g:syntastic_extra_filetypes') && type(g:syntastic_extra_filetypes) == type([])
|
||||
call extend(types, g:syntastic_extra_filetypes)
|
||||
endif
|
||||
|
||||
return syntastic#util#unique(types)
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticRegistry.getNamesOfAvailableCheckers(ftalias) abort " {{{2
|
||||
let ft = s:_normalise_filetype(a:ftalias)
|
||||
call self._loadCheckersFor(ft)
|
||||
return keys(filter( copy(self._checkerMap[ft]), 'v:val.isAvailable()' ))
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticRegistry.echoInfoFor(ftalias_list) abort " {{{2
|
||||
let ft_list = syntastic#util#unique(map( copy(a:ftalias_list), 's:_normalise_filetype(v:val)' ))
|
||||
if len(ft_list) != 1
|
||||
let available = []
|
||||
let active = []
|
||||
|
||||
for ft in ft_list
|
||||
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 = self.getNamesOfAvailableCheckers(ft)
|
||||
let active = map(self.getCheckersAvailable(ft, []), 'v:val.getName()')
|
||||
endif
|
||||
|
||||
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
|
||||
|
||||
" Eclim feels entitled to mess with syntastic's variables {{{3
|
||||
if exists(':EclimValidate') && get(g:, 'EclimFileTypeValidate', 1)
|
||||
let disabled = filter(copy(ft_list), 's:_disabled_by_eclim(v:val)')
|
||||
let cnt = len(disabled)
|
||||
if cnt
|
||||
let plural = cnt != 1 ? 's' : ''
|
||||
let cklist = join(disabled, ', ')
|
||||
echomsg 'Checkers for filetype' . plural . ' ' . cklist . ' possibly disabled by Eclim'
|
||||
endif
|
||||
endif
|
||||
" }}}3
|
||||
|
||||
" So does YouCompleteMe {{{3
|
||||
if exists('g:loaded_youcompleteme') && get(g:, 'ycm_show_diagnostics_ui', get(g:, 'ycm_register_as_syntastic_checker', 1))
|
||||
let disabled = filter(copy(ft_list), 's:_disabled_by_ycm(v:val)')
|
||||
let cnt = len(disabled)
|
||||
if cnt
|
||||
let plural = cnt != 1 ? 's' : ''
|
||||
let cklist = join(disabled, ', ')
|
||||
echomsg 'Checkers for filetype' . plural . ' ' . cklist . ' possibly disabled by YouCompleteMe'
|
||||
endif
|
||||
endif
|
||||
" }}}3
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private methods {{{1
|
||||
|
||||
function! g:SyntasticRegistry._registerChecker(checker) abort " {{{2
|
||||
let ft = a:checker.getFiletype()
|
||||
if !has_key(self._checkerMap, ft)
|
||||
let self._checkerMap[ft] = {}
|
||||
endif
|
||||
|
||||
let name = a:checker.getName()
|
||||
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) abort " {{{2
|
||||
return filter( map(copy(a:list), 'get(a:checkers_map, v:val, {})'), '!empty(v:val)' )
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticRegistry._loadCheckersFor(filetype) abort " {{{2
|
||||
if has_key(self._checkerMap, a:filetype)
|
||||
return
|
||||
endif
|
||||
|
||||
execute 'runtime! syntax_checkers/' . a:filetype . '/*.vim'
|
||||
|
||||
if !has_key(self._checkerMap, a:filetype)
|
||||
let self._checkerMap[a:filetype] = {}
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" Check for obsolete variable g:syntastic_<filetype>_checker
|
||||
function! g:SyntasticRegistry._checkDeprecation(filetype) abort " {{{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#oneTimeWarn('variable g:syntastic_' . a:filetype . '_checker is deprecated')
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Utilities {{{1
|
||||
|
||||
"resolve filetype aliases, and replace - with _ otherwise we cant name
|
||||
"syntax checker functions legally for filetypes like "gentoo-metadata"
|
||||
function! s:_normalise_filetype(ftalias) abort " {{{2
|
||||
let ft = get(s:_DEFAULT_FILETYPE_MAP, a:ftalias, a:ftalias)
|
||||
let ft = get(g:syntastic_filetype_map, ft, ft)
|
||||
let ft = substitute(ft, '\m-', '_', 'g')
|
||||
return ft
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_disabled_by_eclim(filetype) abort " {{{2
|
||||
if index(s:_ECLIM_TYPES, a:filetype) >= 0
|
||||
let lang = toupper(a:filetype[0]) . a:filetype[1:]
|
||||
let ft = a:filetype !=# 'cpp' ? lang : 'C'
|
||||
return get(g:, 'Eclim' . lang . 'Validate', 1) && !get(g:, 'Eclim' . ft . 'SyntasticEnabled', 0)
|
||||
endif
|
||||
|
||||
return 0
|
||||
endfunction " }}}2
|
||||
|
||||
function! s:_disabled_by_ycm(filetype) abort " {{{2
|
||||
return index(s:_YCM_TYPES, a:filetype) >= 0
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,138 @@
|
||||
if exists('g:loaded_syntastic_notifier_signs') || !exists('g:loaded_syntastic_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_notifier_signs = 1
|
||||
|
||||
" Initialisation {{{1
|
||||
|
||||
" start counting sign ids at 5000, start here to hopefully avoid conflicting
|
||||
" with any other code that places signs (not sure if this precaution is
|
||||
" actually needed)
|
||||
let s:first_sign_id = 5000
|
||||
let s:next_sign_id = s:first_sign_id
|
||||
|
||||
let g:SyntasticSignsNotifier = {}
|
||||
|
||||
let s:setup_done = 0
|
||||
|
||||
" }}}1
|
||||
|
||||
" Public methods {{{1
|
||||
|
||||
function! g:SyntasticSignsNotifier.New() abort " {{{2
|
||||
let newObj = copy(self)
|
||||
|
||||
if !s:setup_done
|
||||
call self._setup()
|
||||
let s:setup_done = 1
|
||||
lockvar s:setup_done
|
||||
endif
|
||||
|
||||
return newObj
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticSignsNotifier.enabled() abort " {{{2
|
||||
return has('signs') && syntastic#util#var('enable_signs')
|
||||
endfunction " }}}2
|
||||
|
||||
function! g:SyntasticSignsNotifier.refresh(loclist) abort " {{{2
|
||||
call syntastic#log#debug(g:_SYNTASTIC_DEBUG_NOTIFICATIONS, 'signs: refresh')
|
||||
let old_signs = copy(self._bufSignIds())
|
||||
if self.enabled()
|
||||
call self._signErrors(a:loclist)
|
||||
endif
|
||||
call self._removeSigns(old_signs)
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" Private methods {{{1
|
||||
|
||||
" One time setup: define our own sign types and highlighting
|
||||
function! g:SyntasticSignsNotifier._setup() abort " {{{2
|
||||
if has('signs')
|
||||
if !hlexists('SyntasticErrorSign')
|
||||
highlight link SyntasticErrorSign error
|
||||
endif
|
||||
if !hlexists('SyntasticWarningSign')
|
||||
highlight link SyntasticWarningSign todo
|
||||
endif
|
||||
if !hlexists('SyntasticStyleErrorSign')
|
||||
highlight link SyntasticStyleErrorSign SyntasticErrorSign
|
||||
endif
|
||||
if !hlexists('SyntasticStyleWarningSign')
|
||||
highlight link SyntasticStyleWarningSign SyntasticWarningSign
|
||||
endif
|
||||
if !hlexists('SyntasticStyleErrorLine')
|
||||
highlight link SyntasticStyleErrorLine SyntasticErrorLine
|
||||
endif
|
||||
if !hlexists('SyntasticStyleWarningLine')
|
||||
highlight link SyntasticStyleWarningLine SyntasticWarningLine
|
||||
endif
|
||||
|
||||
" define the signs used to display syntax and style errors/warns
|
||||
execute 'sign define SyntasticError text=' . g:syntastic_error_symbol .
|
||||
\ ' texthl=SyntasticErrorSign linehl=SyntasticErrorLine'
|
||||
execute 'sign define SyntasticWarning text=' . g:syntastic_warning_symbol .
|
||||
\ ' texthl=SyntasticWarningSign linehl=SyntasticWarningLine'
|
||||
execute 'sign define SyntasticStyleError text=' . g:syntastic_style_error_symbol .
|
||||
\ ' texthl=SyntasticStyleErrorSign linehl=SyntasticStyleErrorLine'
|
||||
execute 'sign define SyntasticStyleWarning text=' . g:syntastic_style_warning_symbol .
|
||||
\ ' texthl=SyntasticStyleWarningSign linehl=SyntasticStyleWarningLine'
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" Place signs by all syntax errors in the buffer
|
||||
function! g:SyntasticSignsNotifier._signErrors(loclist) abort " {{{2
|
||||
let loclist = a:loclist
|
||||
if !loclist.isEmpty()
|
||||
|
||||
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 i['lnum'] > 0 && !has_key(seen, i['lnum'])
|
||||
let seen[i['lnum']] = 1
|
||||
|
||||
let sign_severity = i['type'] ==? 'W' ? 'Warning' : 'Error'
|
||||
let sign_subtype = get(i, 'subtype', '')
|
||||
let sign_type = 'Syntastic' . sign_subtype . sign_severity
|
||||
|
||||
execute 'sign place ' . s:next_sign_id . ' line=' . i['lnum'] . ' name=' . sign_type . ' buffer=' . i['bufnr']
|
||||
call add(self._bufSignIds(), s:next_sign_id)
|
||||
let s:next_sign_id += 1
|
||||
endif
|
||||
endfor
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" Remove the signs with the given ids from this buffer
|
||||
function! g:SyntasticSignsNotifier._removeSigns(ids) abort " {{{2
|
||||
if has('signs')
|
||||
for s in reverse(copy(a:ids))
|
||||
execute 'sign unplace ' . s
|
||||
call remove(self._bufSignIds(), index(self._bufSignIds(), s))
|
||||
endfor
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" Get all the ids of the SyntaxError signs in the buffer
|
||||
function! g:SyntasticSignsNotifier._bufSignIds() abort " {{{2
|
||||
if !exists('b:syntastic_private_sign_ids')
|
||||
let b:syntastic_private_sign_ids = []
|
||||
endif
|
||||
return b:syntastic_private_sign_ids
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,67 @@
|
||||
"============================================================================
|
||||
"File: mxmlc.vim
|
||||
"Description: ActionScript syntax checker - using mxmlc
|
||||
"Maintainer: Andy Earnshaw <andyearnshaw@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_actionscript_mxmlc_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_actionscript_mxmlc_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_actionscript_mxmlc_GetHighlightRegex(item)
|
||||
let term = ''
|
||||
|
||||
if match(a:item['text'], '\mvariable ''') > -1
|
||||
let term = matchstr(a:item['text'], '\m''\zs[^'']\+\ze''')
|
||||
|
||||
elseif match(a:item['text'], 'expected a definition keyword') > -1
|
||||
let term = matchstr(a:item['text'], '\mnot \zs[^.]\+\ze\.')
|
||||
|
||||
elseif match(a:item['text'], '\mundefined \%(property\|method\)') > -1
|
||||
let term = matchstr(a:item['text'], '\mundefined \%(property\|method\) \zs[^. ]\+\ze')
|
||||
|
||||
elseif match(a:item['text'], 'could not be found') > -1
|
||||
let term = matchstr(a:item['text'], '\m \zs\S\+\ze could not be found')
|
||||
|
||||
elseif match(a:item['text'], 'Type was not found') > -1
|
||||
let term = matchstr(a:item['text'], '\m: \zs[^.]\+\zs\.')
|
||||
|
||||
endif
|
||||
|
||||
return term !=# '' ? '\V\<' . escape(term, '\') . '\>' : ''
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_actionscript_mxmlc_GetLocList() dict
|
||||
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,' .
|
||||
\ '%f(%l): col: %c %tarning: %m,' .
|
||||
\ '%f: %trror: %m,' .
|
||||
\ '%-G%.%#'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'actionscript',
|
||||
\ 'name': 'mxmlc'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,47 @@
|
||||
"============================================================================
|
||||
"File: ada.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Alfredo Di Napoli <alfredo.dinapoli@gmail.com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_ada_gcc_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_ada_gcc_checker = 1
|
||||
|
||||
if !exists('g:syntastic_ada_compiler_options')
|
||||
let g:syntastic_ada_compiler_options = ''
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_ada_gcc_IsAvailable() dict
|
||||
if !exists('g:syntastic_ada_compiler')
|
||||
let g:syntastic_ada_compiler = self.getExec()
|
||||
endif
|
||||
return executable(expand(g:syntastic_ada_compiler, 1))
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_ada_gcc_GetLocList() dict
|
||||
return syntastic#c#GetLocList('ada', 'gcc', {
|
||||
\ 'errorformat':
|
||||
\ '%-G%f:%s:,' .
|
||||
\ '%f:%l:%c: %m,' .
|
||||
\ '%f:%l: %m',
|
||||
\ 'main_flags': '-c -x ada -fsyntax-only',
|
||||
\ 'header_flags': '-x ada',
|
||||
\ 'header_names': '\.ads$' })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'ada',
|
||||
\ 'name': 'gcc' })
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,66 @@
|
||||
"============================================================================
|
||||
"File: snowcrash.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_apiblueprint_snowcrash_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_apiblueprint_snowcrash_checker = 1
|
||||
|
||||
if !exists('g:syntastic_apiblueprint_snowcrash_sort')
|
||||
let g:syntastic_apiblueprint_snowcrash_sort = 1
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_apiblueprint_snowcrash_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ 'post_args': '-u -l' })
|
||||
|
||||
let errorformat =
|
||||
\ '%trror: (%n) %m,' .
|
||||
\ '%tarning: (%n) %m,' .
|
||||
\ '%-G%.%#'
|
||||
|
||||
let loclist = SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': {'bufnr': bufnr('')},
|
||||
\ 'returns': [0, 2] })
|
||||
|
||||
for e in loclist
|
||||
let matches = matchlist(e['text'], '\v^(.+); line (\d+), column (\d+) - line (\d+), column (\d+)$')
|
||||
if len(matches) > 5
|
||||
let e['lnum'] = str2nr(matches[2])
|
||||
let e['col'] = str2nr(matches[3])
|
||||
let e['vcol'] = 0
|
||||
|
||||
if matches[2] == matches[4]
|
||||
let e['hl'] = '\%>' . (e['col'] - 1) . 'c\%<' . matches[5] . 'c'
|
||||
endif
|
||||
|
||||
let e['text'] = matches[1]
|
||||
else
|
||||
let e['valid'] = 0
|
||||
endif
|
||||
endfor
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'apiblueprint',
|
||||
\ 'name': 'snowcrash'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,49 @@
|
||||
"==============================================================================
|
||||
" FileName: applescript.vim
|
||||
" Desc: Syntax checking plugin for syntastic.vim
|
||||
" Author: Zhao Cai
|
||||
" Email: caizhaoff@gmail.com
|
||||
" Version: 0.2.1
|
||||
" Date Created: Thu 09 Sep 2011 10:30:09 AM EST
|
||||
" Last Modified: Fri 09 Dec 2011 01:10:24 PM EST
|
||||
"
|
||||
" History: 0.1.0 - working, but it will run the script everytime to check
|
||||
" syntax. Should use osacompile but strangely it does not give
|
||||
" errors.
|
||||
"
|
||||
" 0.2.0 - switch to osacompile, it gives less errors compared
|
||||
" with osascript.
|
||||
"
|
||||
" 0.2.1 - remove g:syntastic_applescript_tempfile. use
|
||||
" tempname() instead.
|
||||
"
|
||||
" License: This program is free software. It comes without any
|
||||
" warranty, to the extent permitted by applicable law. You can
|
||||
" redistribute it and/or modify it under the terms of the Do What The
|
||||
" Fuck You Want To Public License, Version 2, as published by Sam
|
||||
" Hocevar. See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_applescript_osacompile_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_applescript_osacompile_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_applescript_osacompile_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ 'args_after': '-o ' . tempname() . '.scpt' })
|
||||
let errorformat = '%f:%l:%m'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'applescript',
|
||||
\ 'name': 'osacompile' })
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,47 @@
|
||||
"============================================================================
|
||||
"File: asciidoc.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_asciidoc_asciidoc_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_asciidoc_asciidoc_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_asciidoc_asciidoc_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ 'args_after': syntastic#c#NullOutput() })
|
||||
|
||||
let errorformat =
|
||||
\ '%Easciidoc: %tRROR: %f: line %l: %m,' .
|
||||
\ '%Easciidoc: %tRROR: %f: %m,' .
|
||||
\ '%Easciidoc: FAILED: %f: line %l: %m,' .
|
||||
\ '%Easciidoc: FAILED: %f: %m,' .
|
||||
\ '%Wasciidoc: %tARNING: %f: line %l: %m,' .
|
||||
\ '%Wasciidoc: %tARNING: %f: %m,' .
|
||||
\ '%Wasciidoc: DEPRECATED: %f: line %l: %m,' .
|
||||
\ '%Wasciidoc: DEPRECATED: %f: %m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'returns': [0, 1] })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'asciidoc',
|
||||
\ 'name': 'asciidoc'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,58 @@
|
||||
"============================================================================
|
||||
"File: gcc.vim
|
||||
"Description: Syntax checking for at&t and intel assembly files with gcc
|
||||
"Maintainer: Josh Rahm <joshuarahm@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_asm_gcc_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_asm_gcc_checker = 1
|
||||
|
||||
if !exists('g:syntastic_asm_compiler_options')
|
||||
let g:syntastic_asm_compiler_options = ''
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_asm_gcc_IsAvailable() dict " {{{1
|
||||
if !exists('g:syntastic_asm_compiler')
|
||||
let g:syntastic_asm_compiler = self.getExec()
|
||||
endif
|
||||
return executable(expand(g:syntastic_asm_compiler, 1))
|
||||
endfunction " }}}1
|
||||
|
||||
function! SyntaxCheckers_asm_gcc_GetLocList() dict " {{{1
|
||||
return syntastic#c#GetLocList('asm', 'gcc', {
|
||||
\ 'errorformat':
|
||||
\ '%-G%f:%s:,' .
|
||||
\ '%f:%l:%c: %trror: %m,' .
|
||||
\ '%f:%l:%c: %tarning: %m,' .
|
||||
\ '%f:%l: %m',
|
||||
\ 'main_flags': '-x assembler -fsyntax-only -masm=' . s:GetDialect() })
|
||||
endfunction " }}}1
|
||||
|
||||
" Utilities {{{1
|
||||
|
||||
function! s:GetDialect() " {{{2
|
||||
return exists('g:syntastic_asm_dialect') ? g:syntastic_asm_dialect :
|
||||
\ expand('%:e', 1) ==? 'asm' ? 'intel' : 'att'
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'asm',
|
||||
\ 'name': 'gcc' })
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,35 @@
|
||||
"============================================================================
|
||||
"File: bemhtmllint.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Sergej Tatarincev <s.tatarincev at yandex.ua>
|
||||
"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_bemhtml_bemhtmllint_checker')
|
||||
finish
|
||||
endif
|
||||
|
||||
let g:loaded_syntastic_bemhtml_bemhtmllint_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function SyntaxCheckers_bemhtml_bemhtmllint_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({})
|
||||
let errorformat = '%f:%l:%c: %m'
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'bemhtml',
|
||||
\ 'name': 'bemhtmllint',
|
||||
\ 'exec': 'bemhtml-lint' })
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,60 @@
|
||||
"============================================================================
|
||||
"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_GetHighlightRegex(item)
|
||||
let term = matchstr(a:item['text'], '\m at or near "\zs[^"]\+\ze"')
|
||||
return term !=# '' ? '\V\<' . escape(term, '\') . '\>' : ''
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_bro_bro_IsAvailable() dict
|
||||
if !executable(self.getExec())
|
||||
return 0
|
||||
endif
|
||||
|
||||
if syntastic#util#system(self.getExecEscaped() . ' --help') !~# '--parse-only'
|
||||
call self.log('unknown option "--parse-only"')
|
||||
return 0
|
||||
endif
|
||||
|
||||
return 1
|
||||
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 =
|
||||
\ 'fatal %trror in %f\, line %l: %m,' .
|
||||
\ '%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 sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,57 @@
|
||||
"============================================================================
|
||||
"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_c_avrgcc_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_avrgcc_checker = 1
|
||||
|
||||
if !exists('g:syntastic_avrgcc_config_file')
|
||||
let g:syntastic_avrgcc_config_file = '.syntastic_avrgcc_config'
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_c_avrgcc_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({
|
||||
\ 'args_before': syntastic#c#ReadConfig(g:syntastic_avrgcc_config_file),
|
||||
\ 'args_after': '-x c -fsyntax-only' })
|
||||
|
||||
let errorformat =
|
||||
\ '%-G%f:%s:,' .
|
||||
\ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
|
||||
\ '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
|
||||
\ '%-GIn file included%.%#,' .
|
||||
\ '%-G %#from %f:%l\,,' .
|
||||
\ '%f:%l:%c: %trror: %m,' .
|
||||
\ '%f:%l:%c: %tarning: %m,' .
|
||||
\ '%f:%l:%c: %m,' .
|
||||
\ '%f:%l: %trror: %m,' .
|
||||
\ '%f:%l: %tarning: %m,'.
|
||||
\ '%f:%l: %m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'postprocess': ['compressWhitespace'] })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'c',
|
||||
\ 'name': 'avrgcc',
|
||||
\ 'exec': 'avr-gcc'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,60 @@
|
||||
"============================================================================
|
||||
"File: checkpatch.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim using checkpatch.pl
|
||||
"Maintainer: Daniel Walker <dwalker at fifo99 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_c_checkpatch_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_checkpatch_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_c_checkpatch_IsAvailable() dict
|
||||
call syntastic#log#deprecationWarn('c_checker_checkpatch_location', 'c_checkpatch_exec')
|
||||
|
||||
if !exists('g:syntastic_c_checkpatch_exec') && !executable(self.getExec())
|
||||
if executable('checkpatch')
|
||||
let g:syntastic_c_checkpatch_exec = 'checkpatch'
|
||||
elseif executable('./scripts/checkpatch.pl')
|
||||
let g:syntastic_c_checkpatch_exec = fnamemodify('./scripts/checkpatch.pl', ':p')
|
||||
elseif executable('./scripts/checkpatch')
|
||||
let g:syntastic_c_checkpatch_exec = fnamemodify('./scripts/checkpatch', ':p')
|
||||
endif
|
||||
endif
|
||||
|
||||
call self.log('exec =', self.getExec())
|
||||
|
||||
return executable(self.getExec())
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_c_checkpatch_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ 'args_after': '--no-summary --no-tree --terse --file' })
|
||||
|
||||
let errorformat =
|
||||
\ '%f:%l: %tARNING: %m,' .
|
||||
\ '%f:%l: %tRROR: %m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'returns': [0, 1],
|
||||
\ 'subtype': 'Style' })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'c',
|
||||
\ 'name': 'checkpatch',
|
||||
\ 'exec': 'checkpatch.pl'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,61 @@
|
||||
"============================================================================
|
||||
"File: clang_check.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Benjamin Bannier <bbannier 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_c_clang_check_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_clang_check_checker = 1
|
||||
|
||||
if !exists('g:syntastic_clang_check_config_file')
|
||||
let g:syntastic_clang_check_config_file = '.syntastic_clang_check_config'
|
||||
endif
|
||||
|
||||
if !exists('g:syntastic_c_clang_check_sort')
|
||||
let g:syntastic_c_clang_check_sort = 1
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_c_clang_check_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({
|
||||
\ 'post_args':
|
||||
\ '-- ' .
|
||||
\ syntastic#c#ReadConfig(g:syntastic_clang_check_config_file) . ' ' .
|
||||
\ '-fshow-column ' .
|
||||
\ '-fshow-source-location ' .
|
||||
\ '-fno-caret-diagnostics ' .
|
||||
\ '-fno-color-diagnostics ' .
|
||||
\ '-fdiagnostics-format=clang' })
|
||||
|
||||
let errorformat =
|
||||
\ '%E%f:%l:%c: fatal error: %m,' .
|
||||
\ '%E%f:%l:%c: error: %m,' .
|
||||
\ '%W%f:%l:%c: warning: %m,' .
|
||||
\ '%-G%\m%\%%(LLVM ERROR:%\|No compilation database found%\)%\@!%.%#,' .
|
||||
\ '%E%m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': {'bufnr': bufnr('')},
|
||||
\ 'returns': [0, 1] })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'c',
|
||||
\ 'name': 'clang_check',
|
||||
\ 'exec': 'clang-check'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,61 @@
|
||||
"============================================================================
|
||||
"File: clang_tidy.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Benjamin Bannier <bbannier 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_c_clang_tidy_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_clang_tidy_checker = 1
|
||||
|
||||
if !exists('g:syntastic_clang_tidy_config_file')
|
||||
let g:syntastic_clang_tidy_config_file = '.syntastic_clang_tidy_config'
|
||||
endif
|
||||
|
||||
if !exists('g:syntastic_c_clang_tidy_sort')
|
||||
let g:syntastic_c_clang_tidy_sort = 1
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_c_clang_tidy_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({
|
||||
\ 'post_args':
|
||||
\ '-- ' .
|
||||
\ syntastic#c#ReadConfig(g:syntastic_clang_tidy_config_file) . ' ' .
|
||||
\ '-fshow-column ' .
|
||||
\ '-fshow-source-location ' .
|
||||
\ '-fno-caret-diagnostics ' .
|
||||
\ '-fno-color-diagnostics ' .
|
||||
\ '-fdiagnostics-format=clang' })
|
||||
|
||||
let errorformat =
|
||||
\ '%E%f:%l:%c: fatal error: %m,' .
|
||||
\ '%E%f:%l:%c: error: %m,' .
|
||||
\ '%W%f:%l:%c: warning: %m,' .
|
||||
\ '%-G%\m%\%%(LLVM ERROR:%\|No compilation database found%\)%\@!%.%#,' .
|
||||
\ '%E%m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': {'bufnr': bufnr('')},
|
||||
\ 'returns': [0, 1] })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'c',
|
||||
\ 'name': 'clang_tidy',
|
||||
\ 'exec': 'clang-tidy'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,62 @@
|
||||
"============================================================================
|
||||
"File: cppcheck.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim using cppcheck.pl
|
||||
"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_c_cppcheck_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_cppcheck_checker = 1
|
||||
|
||||
if !exists('g:syntastic_cppcheck_config_file')
|
||||
let g:syntastic_cppcheck_config_file = '.syntastic_cppcheck_config'
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_c_cppcheck_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({
|
||||
\ 'args': syntastic#c#ReadConfig(g:syntastic_cppcheck_config_file),
|
||||
\ 'args_after': '-q --enable=style' })
|
||||
|
||||
let errorformat =
|
||||
\ '[%f:%l]: (%trror) %m,' .
|
||||
\ '[%f:%l]: (%tarning) %m,' .
|
||||
\ '[%f:%l]: (%ttyle) %m,' .
|
||||
\ '[%f:%l]: (%terformance) %m,' .
|
||||
\ '[%f:%l]: (%tortability) %m,' .
|
||||
\ '[%f:%l]: (%tnformation) %m,' .
|
||||
\ '[%f:%l]: (%tnconclusive) %m,' .
|
||||
\ '%-G%.%#'
|
||||
|
||||
let loclist = SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'preprocess': 'cppcheck',
|
||||
\ 'returns': [0] })
|
||||
|
||||
for e in loclist
|
||||
if e['type'] =~? '\m^[SPI]'
|
||||
let e['type'] = 'w'
|
||||
let e['subtype'] = 'Style'
|
||||
endif
|
||||
endfor
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'c',
|
||||
\ 'name': 'cppcheck'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,59 @@
|
||||
"============================================================================
|
||||
"File: c.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_c_gcc_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_gcc_checker = 1
|
||||
|
||||
if !exists('g:syntastic_c_compiler_options')
|
||||
let g:syntastic_c_compiler_options = '-std=gnu99'
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_c_gcc_IsAvailable() dict
|
||||
if !exists('g:syntastic_c_compiler')
|
||||
let g:syntastic_c_compiler = executable(self.getExec()) ? self.getExec() : 'clang'
|
||||
endif
|
||||
call self.log('g:syntastic_c_compiler =', g:syntastic_c_compiler)
|
||||
return executable(expand(g:syntastic_c_compiler, 1))
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_c_gcc_GetLocList() dict
|
||||
return syntastic#c#GetLocList('c', 'gcc', {
|
||||
\ 'errorformat':
|
||||
\ '%-G%f:%s:,' .
|
||||
\ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
|
||||
\ '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
|
||||
\ '%-GIn file included%.%#,' .
|
||||
\ '%-G %#from %f:%l\,,' .
|
||||
\ '%f:%l:%c: %trror: %m,' .
|
||||
\ '%f:%l:%c: %tarning: %m,' .
|
||||
\ '%f:%l:%c: %m,' .
|
||||
\ '%f:%l: %trror: %m,' .
|
||||
\ '%f:%l: %tarning: %m,'.
|
||||
\ '%f:%l: %m',
|
||||
\ 'main_flags': '-x c -fsyntax-only',
|
||||
\ 'header_flags': '-x c',
|
||||
\ 'header_names': '\m\.h$' })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'c',
|
||||
\ 'name': 'gcc' })
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,61 @@
|
||||
"============================================================================
|
||||
"File: make.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_c_make_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_make_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_c_make_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ 'args': '-sk', 'fname': '' })
|
||||
|
||||
let errorformat =
|
||||
\ '%-G%f:%s:,' .
|
||||
\ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' .
|
||||
\ '%-G%f:%l: %#error: %#for each function it appears%.%#,' .
|
||||
\ '%-GIn file included%.%#,' .
|
||||
\ '%-G %#from %f:%l\,,' .
|
||||
\ '%f:%l:%c: %trror: %m,' .
|
||||
\ '%f:%l:%c: %tarning: %m,' .
|
||||
\ '%f:%l:%c: %m,' .
|
||||
\ '%f:%l: %trror: %m,' .
|
||||
\ '%f:%l: %tarning: %m,'.
|
||||
\ '%f:%l: %m'
|
||||
|
||||
if exists('g:syntastic_c_errorformat')
|
||||
let errorformat = g:syntastic_c_errorformat
|
||||
endif
|
||||
|
||||
" process makeprg
|
||||
let errors = SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
|
||||
" filter the processed errors if desired
|
||||
if exists('g:syntastic_c_remove_include_errors') && g:syntastic_c_remove_include_errors != 0
|
||||
return filter(errors, 'has_key(v:val, "bufnr") && v:val["bufnr"] == ' . bufnr(''))
|
||||
else
|
||||
return errors
|
||||
endif
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'c',
|
||||
\ 'name': 'make'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,65 @@
|
||||
"============================================================================
|
||||
"File: oclint.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: "UnCO" Lin <undercooled aT lavabit 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_c_oclint_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_oclint_checker = 1
|
||||
|
||||
if !exists('g:syntastic_oclint_config_file')
|
||||
let g:syntastic_oclint_config_file = '.syntastic_oclint_config'
|
||||
endif
|
||||
|
||||
if !exists('g:syntastic_c_oclint_sort')
|
||||
let g:syntastic_c_oclint_sort = 1
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_c_oclint_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({
|
||||
\ 'post_args': '-- -c ' . syntastic#c#ReadConfig(g:syntastic_oclint_config_file) })
|
||||
|
||||
let errorformat =
|
||||
\ '%E%f:%l:%c: fatal error: %m,' .
|
||||
\ '%E%f:%l:%c: error: %m,' .
|
||||
\ '%W%f:%l:%c: warning: %m,' .
|
||||
\ '%E%f:%l:%c: %m,' .
|
||||
\ '%-G%.%#'
|
||||
|
||||
let loclist = SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'subtype': 'Style',
|
||||
\ 'postprocess': ['compressWhitespace'],
|
||||
\ 'returns': [0, 3, 5] })
|
||||
|
||||
for e in loclist
|
||||
if e['text'] =~# '\v P3( |$)'
|
||||
let e['type'] = 'W'
|
||||
endif
|
||||
|
||||
let e['text'] = substitute(e['text'], '\m\C P[1-3]$', '', '')
|
||||
let e['text'] = substitute(e['text'], '\m\C P[1-3] ', ': ', '')
|
||||
endfor
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'c',
|
||||
\ 'name': 'oclint'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,66 @@
|
||||
"============================================================================
|
||||
"File: pc_lint.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Steve Bragg <steve at empresseffects 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_c_pc_lint_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_pc_lint_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
if !exists('g:syntastic_pc_lint_config_file')
|
||||
let g:syntastic_pc_lint_config_file = 'options.lnt'
|
||||
endif
|
||||
|
||||
function! SyntaxCheckers_c_pc_lint_GetLocList() dict
|
||||
let config = findfile(g:syntastic_pc_lint_config_file, '.;')
|
||||
call self.log('config =', config)
|
||||
|
||||
" -hFs1 - show filename, add space after messages, try to make message 1 line
|
||||
" -width(0,0) - make sure there are no line breaks
|
||||
" -t - set tab size
|
||||
" -v - turn off verbosity
|
||||
let makeprg = self.makeprgBuild({
|
||||
\ 'args': (filereadable(config) ? syntastic#util#shescape(fnamemodify(config, ':p')) : ''),
|
||||
\ 'args_after': ['-hFs1', '-width(0,0)', '-t' . &tabstop, '-format=%f:%l:%C:%t:%n:%m'] })
|
||||
|
||||
let errorformat =
|
||||
\ '%E%f:%l:%v:Error:%n:%m,' .
|
||||
\ '%W%f:%l:%v:Warning:%n:%m,' .
|
||||
\ '%I%f:%l:%v:Info:%n:%m,' .
|
||||
\ '%-G%.%#'
|
||||
|
||||
let loclist = SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'postprocess': ['cygwinRemoveCR'] })
|
||||
|
||||
for e in loclist
|
||||
if e['type'] ==? 'I'
|
||||
let e['type'] = 'W'
|
||||
let e['subtype'] = 'Style'
|
||||
endif
|
||||
endfor
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'c',
|
||||
\ 'name': 'pc_lint',
|
||||
\ 'exec': 'lint-nt'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,48 @@
|
||||
"============================================================================
|
||||
"File: sparse.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim using sparse.pl
|
||||
"Maintainer: Daniel Walker <dwalker at fifo99 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_c_sparse_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_sparse_checker = 1
|
||||
|
||||
if !exists('g:syntastic_sparse_config_file')
|
||||
let g:syntastic_sparse_config_file = '.syntastic_sparse_config'
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_c_sparse_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({
|
||||
\ 'args': syntastic#c#ReadConfig(g:syntastic_sparse_config_file),
|
||||
\ 'args_after': '-ftabstop=' . &ts })
|
||||
|
||||
let errorformat =
|
||||
\ '%f:%l:%v: %trror: %m,' .
|
||||
\ '%f:%l:%v: %tarning: %m,'
|
||||
|
||||
let loclist = SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': {'bufnr': bufnr('')},
|
||||
\ 'returns': [0, 1] })
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'c',
|
||||
\ 'name': 'sparse'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,55 @@
|
||||
"============================================================================
|
||||
"File: splint.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_c_splint_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_c_splint_checker = 1
|
||||
|
||||
if !exists('g:syntastic_splint_config_file')
|
||||
let g:syntastic_splint_config_file = '.syntastic_splint_config'
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_c_splint_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({
|
||||
\ 'args': syntastic#c#ReadConfig(g:syntastic_splint_config_file),
|
||||
\ 'args_after': '-showfunc -hints +quiet' })
|
||||
|
||||
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 %.%#'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'subtype': 'Style',
|
||||
\ 'postprocess': ['compressWhitespace'],
|
||||
\ 'defaults': {'type': 'W'} })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'c',
|
||||
\ 'name': 'splint'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -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', 1),
|
||||
\ '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 sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,39 @@
|
||||
"============================================================================
|
||||
"File: foodcritic.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Doug Ireton <dougireton@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_chef_foodcritic_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_chef_foodcritic_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_chef_foodcritic_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({})
|
||||
|
||||
" FC023: Prefer conditional attributes: ./recipes/config.rb:49
|
||||
let errorformat = 'FC%n: %m: %f:%l'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'chef',
|
||||
\ 'name': 'foodcritic'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,47 @@
|
||||
"============================================================================
|
||||
"File: co.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Andrew Kelley <superjoe30@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_co_coco_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_co_coco_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_co_coco_GetLocList() dict
|
||||
let tmpdir = syntastic#util#tmpdir()
|
||||
let makeprg = self.makeprgBuild({ 'args_after': '-c -o ' . tmpdir })
|
||||
|
||||
let errorformat =
|
||||
\ '%EFailed at: %f,' .
|
||||
\ '%ZSyntax%trror: %m on line %l,'.
|
||||
\ '%EFailed at: %f,'.
|
||||
\ '%Z%trror: Parse error on line %l: %m'
|
||||
|
||||
let loclist = SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
|
||||
call syntastic#util#rmrf(tmpdir)
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'co',
|
||||
\ 'name': 'coco'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,47 @@
|
||||
"============================================================================
|
||||
"File: cobc.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_cobol_cobc_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_cobol_cobc_checker = 1
|
||||
|
||||
if !exists('g:syntastic_cobol_compiler_options')
|
||||
let g:syntastic_cobol_compiler_options = ''
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_cobol_cobc_IsAvailable() dict
|
||||
if !exists('g:syntastic_cobol_compiler')
|
||||
let g:syntastic_cobol_compiler = self.getExec()
|
||||
endif
|
||||
call self.log('g:syntastic_cobol_compiler =', g:syntastic_cobol_compiler)
|
||||
return executable(expand(g:syntastic_cobol_compiler, 1))
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_cobol_cobc_GetLocList() dict
|
||||
return syntastic#c#GetLocList('cobol', 'cobc', {
|
||||
\ 'errorformat': '%f:%l: %trror: %m',
|
||||
\ 'main_flags': '-fsyntax-only' })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'cobol',
|
||||
\ 'name': 'cobc' })
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,58 @@
|
||||
"============================================================================
|
||||
"File: coffee.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Lincoln Stoll <l@lds.li>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
"
|
||||
" Note: this script requires CoffeeScript version 1.6.2 or newer.
|
||||
"
|
||||
|
||||
if exists('g:loaded_syntastic_coffee_coffee_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_coffee_coffee_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_coffee_coffee_IsAvailable() dict
|
||||
if !executable(self.getExec())
|
||||
return 0
|
||||
endif
|
||||
let ver = self.getVersion(self.getExecEscaped() . ' --version 2>' . syntastic#util#DevNull())
|
||||
return syntastic#util#versionIsAtLeast(ver, [1, 6, 2])
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_coffee_coffee_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ 'args_after': '-cp' })
|
||||
|
||||
let errorformat =
|
||||
\ '%E%f:%l:%c: %trror: %m,' .
|
||||
\ 'Syntax%trror: In %f\, %m on line %l,' .
|
||||
\ '%EError: In %f\, Parse error on line %l: %m,' .
|
||||
\ '%EError: In %f\, %m on line %l,' .
|
||||
\ '%W%f(%l): lint warning: %m,' .
|
||||
\ '%W%f(%l): warning: %m,' .
|
||||
\ '%E%f(%l): SyntaxError: %m,' .
|
||||
\ '%-Z%p^,' .
|
||||
\ '%-G%.%#'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'coffee',
|
||||
\ 'name': 'coffee'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,47 @@
|
||||
"============================================================================
|
||||
"File: coffeelint.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Lincoln Stoll <l@lds.li>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_coffee_coffeelint_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_coffee_coffeelint_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_coffee_coffeelint_GetLocList() dict
|
||||
if !exists('s:coffeelint_new')
|
||||
let s:coffeelint_new = syntastic#util#versionIsAtLeast(self.getVersion(), [1, 4])
|
||||
endif
|
||||
let makeprg = self.makeprgBuild({ 'args_after': (s:coffeelint_new ? '--reporter csv' : '--csv') })
|
||||
|
||||
let errorformat =
|
||||
\ '%f\,%l\,%\d%#\,%trror\,%m,' .
|
||||
\ '%f\,%l\,%trror\,%m,' .
|
||||
\ '%f\,%l\,%\d%#\,%tarn\,%m,' .
|
||||
\ '%f\,%l\,%tarn\,%m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'subtype': 'Style',
|
||||
\ 'returns': [0, 1] })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'coffee',
|
||||
\ 'name': 'coffeelint'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,40 @@
|
||||
"============================================================================
|
||||
"File: coqtop.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Matvey Aksenov <matvey.aksenov 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_coq_coqtop_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_coq_coqtop_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_coq_coqtop_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ 'args_after': '-noglob -batch -load-vernac-source' })
|
||||
|
||||
let errorformat =
|
||||
\ '%AFile \"%f\"\, line %l\, characters %c\-%.%#\:,'.
|
||||
\ '%C%m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'coq',
|
||||
\ 'name': 'coqtop'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,25 @@
|
||||
"============================================================================
|
||||
"File: clang_check.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Benjamin Bannier <bbannier 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_cpp_clang_check_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_cpp_clang_check_checker = 1
|
||||
|
||||
runtime! syntax_checkers/c/*.vim
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'cpp',
|
||||
\ 'name': 'clang_check',
|
||||
\ 'exec': 'clang-check',
|
||||
\ 'redirect': 'c/clang_check'})
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,25 @@
|
||||
"============================================================================
|
||||
"File: clang_tidy.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Benjamin Bannier <bbannier 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_cpp_clang_tidy_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_cpp_clang_tidy_checker = 1
|
||||
|
||||
runtime! syntax_checkers/c/*.vim
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'cpp',
|
||||
\ 'name': 'clang_tidy',
|
||||
\ 'exec': 'clang-tidy',
|
||||
\ 'redirect': 'c/clang_tidy'})
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,24 @@
|
||||
"============================================================================
|
||||
"File: cppcheck.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim using cppcheck.pl
|
||||
"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_cpp_cppcheck_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_cpp_cppcheck_checker = 1
|
||||
|
||||
runtime! syntax_checkers/c/*.vim
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'cpp',
|
||||
\ 'name': 'cppcheck',
|
||||
\ 'redirect': 'c/cppcheck'})
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,52 @@
|
||||
"============================================================================
|
||||
"File: cpplint.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_cpp_cpplint_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_cpp_cpplint_checker = 1
|
||||
|
||||
if !exists('g:syntastic_cpp_cpplint_thres')
|
||||
let g:syntastic_cpp_cpplint_thres = 5
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_cpp_cpplint_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ 'args': '--verbose=3' })
|
||||
|
||||
let errorformat = '%A%f:%l: %m [%t],%-G%.%#'
|
||||
|
||||
let loclist = SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'subtype': 'Style',
|
||||
\ 'returns': [0, 1] })
|
||||
|
||||
" change error types according to the prescribed threshold
|
||||
for e in loclist
|
||||
let e['type'] = e['type'] < g:syntastic_cpp_cpplint_thres ? 'W' : 'E'
|
||||
endfor
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'cpp',
|
||||
\ 'name': 'cpplint',
|
||||
\ 'exec': 'cpplint.py'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,56 @@
|
||||
"============================================================================
|
||||
"File: cpp.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Gregor Uhlenheuer <kongo2002 at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_cpp_gcc_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_cpp_gcc_checker = 1
|
||||
|
||||
if !exists('g:syntastic_cpp_compiler_options')
|
||||
let g:syntastic_cpp_compiler_options = ''
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_cpp_gcc_IsAvailable() dict
|
||||
if !exists('g:syntastic_cpp_compiler')
|
||||
let g:syntastic_cpp_compiler = executable(self.getExec()) ? self.getExec() : 'clang++'
|
||||
endif
|
||||
call self.log('g:syntastic_cpp_compiler =', g:syntastic_cpp_compiler)
|
||||
return executable(expand(g:syntastic_cpp_compiler, 1))
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_cpp_gcc_GetLocList() dict
|
||||
return syntastic#c#GetLocList('cpp', 'gcc', {
|
||||
\ 'errorformat':
|
||||
\ '%-G%f:%s:,' .
|
||||
\ '%f:%l:%c: %trror: %m,' .
|
||||
\ '%f:%l:%c: %tarning: %m,' .
|
||||
\ '%f:%l:%c: %m,'.
|
||||
\ '%f:%l: %trror: %m,'.
|
||||
\ '%f:%l: %tarning: %m,'.
|
||||
\ '%f:%l: %m',
|
||||
\ 'main_flags': '-x c++ -fsyntax-only',
|
||||
\ 'header_flags': '-x c++',
|
||||
\ 'header_names': '\m\.\(h\|hpp\|hh\)$' })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'cpp',
|
||||
\ 'name': 'gcc',
|
||||
\ 'exec': 'g++' })
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,24 @@
|
||||
"============================================================================
|
||||
"File: oclint.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: "UnCO" Lin <undercooled aT lavabit 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_cpp_oclint_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_cpp_oclint_checker = 1
|
||||
|
||||
runtime! syntax_checkers/c/*.vim
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'cpp',
|
||||
\ 'name': 'oclint',
|
||||
\ 'redirect': 'c/oclint'})
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,26 @@
|
||||
"============================================================================
|
||||
"File: pc_lint.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Steve Bragg <steve at empresseffects 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_cpp_pc_lint_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_cpp_pc_lint_checker = 1
|
||||
|
||||
runtime! syntax_checkers/c/*.vim
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'cpp',
|
||||
\ 'name': 'pc_lint',
|
||||
\ 'exec': 'lint-nt',
|
||||
\ 'redirect': 'c/pc_lint'})
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,39 @@
|
||||
"============================================================================
|
||||
"File: cs.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Daniel Walker <dwalker@fifo99.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_cs_mcs_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_cs_mcs_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_cs_mcs_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ 'args_after': '--parse' })
|
||||
|
||||
let errorformat = '%f(%l\,%c): %trror %m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': {'bufnr': bufnr('')} })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'cs',
|
||||
\ 'name': 'mcs'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,47 @@
|
||||
"============================================================================
|
||||
"File: css.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim using `csslint` CLI tool (http://csslint.net).
|
||||
"Maintainer: Ory Band <oryband at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_css_csslint_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_css_csslint_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_css_csslint_GetLocList() dict
|
||||
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 =
|
||||
\ '%-G,' .
|
||||
\ '%-G%f: lint free!,' .
|
||||
\ '%f: line %l\, col %c\, %trror - %m,' .
|
||||
\ '%f: line %l\, col %c\, %tarning - %m,'.
|
||||
\ '%f: line %l\, col %c\, %m,'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': {'bufnr': bufnr('')} })
|
||||
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'css',
|
||||
\ 'name': 'csslint'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,25 @@
|
||||
"============================================================================
|
||||
"File: phpcs.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_css_phpcs_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_css_phpcs_checker = 1
|
||||
|
||||
runtime! syntax_checkers/php/*.vim
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'css',
|
||||
\ 'name': 'phpcs',
|
||||
\ 'redirect': 'php/phpcs'})
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,61 @@
|
||||
"============================================================================
|
||||
"File: prettycss.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_css_prettycss_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_css_prettycss_checker = 1
|
||||
|
||||
if !exists('g:syntastic_css_prettycss_sort')
|
||||
let g:syntastic_css_prettycss_sort = 1
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_css_prettycss_GetHighlightRegex(item)
|
||||
let term = matchstr(a:item['text'], '\m (\zs[^)]\+\ze)$')
|
||||
if term !=# ''
|
||||
let term = '\V' . escape(term, '\')
|
||||
endif
|
||||
return term
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_css_prettycss_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({})
|
||||
|
||||
" Print CSS Lint's error/warning messages from compact format. Ignores blank lines.
|
||||
let errorformat =
|
||||
\ '%EError: %m\, line %l\, char %c),' .
|
||||
\ '%WWarning: %m\, line %l\, char %c),' .
|
||||
\ '%-G%.%#'
|
||||
|
||||
let loclist = SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': {'bufnr': bufnr('')} })
|
||||
|
||||
for e in loclist
|
||||
let e['text'] .= ')'
|
||||
endfor
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'css',
|
||||
\ 'name': 'prettycss'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -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 sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,42 @@
|
||||
"============================================================================
|
||||
"File: cucumber.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_cucumber_cucumber_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_cucumber_cucumber_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_cucumber_cucumber_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ 'args_after': '--dry-run --quiet --strict --format pretty' })
|
||||
|
||||
let errorformat =
|
||||
\ '%f:%l:%c:%m,' .
|
||||
\ '%W %.%# (%m),' .
|
||||
\ '%-Z%f:%l:%.%#,'.
|
||||
\ '%-G%.%#'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'cucumber',
|
||||
\ 'name': 'cucumber'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,66 @@
|
||||
"============================================================================
|
||||
"File: cuda.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"
|
||||
"Author: Hannes Schulz <schulz at ais dot uni-bonn dot de>
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_cuda_nvcc_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_cuda_nvcc_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_cuda_nvcc_GetLocList() dict
|
||||
if exists('g:syntastic_cuda_arch')
|
||||
let arch_flag = '-arch=' . g:syntastic_cuda_arch
|
||||
else
|
||||
let arch_flag = ''
|
||||
endif
|
||||
let makeprg =
|
||||
\ self.getExecEscaped() . ' ' . arch_flag .
|
||||
\ ' --cuda -O0 -I . -Xcompiler -fsyntax-only ' .
|
||||
\ syntastic#util#shexpand('%') . ' ' . syntastic#c#NullOutput()
|
||||
|
||||
let errorformat =
|
||||
\ '%*[^"]"%f"%*\D%l: %m,'.
|
||||
\ '"%f"%*\D%l: %m,'.
|
||||
\ '%-G%f:%l: (Each undeclared identifier is reported only once,'.
|
||||
\ '%-G%f:%l: for each function it appears in.),'.
|
||||
\ '%f:%l:%c:%m,'.
|
||||
\ '%f(%l):%m,'.
|
||||
\ '%f:%l:%m,'.
|
||||
\ '"%f"\, line %l%*\D%c%*[^ ] %m,'.
|
||||
\ '%D%*\a[%*\d]: Entering directory `%f'','.
|
||||
\ '%X%*\a[%*\d]: Leaving directory `%f'','.
|
||||
\ '%D%*\a: Entering directory `%f'','.
|
||||
\ '%X%*\a: Leaving directory `%f'','.
|
||||
\ '%DMaking %*\a in %f,'.
|
||||
\ '%f|%l| %m'
|
||||
|
||||
if expand('%', 1) =~? '\m\%(.h\|.hpp\|.cuh\)$'
|
||||
if exists('g:syntastic_cuda_check_header')
|
||||
let makeprg =
|
||||
\ 'echo > .syntastic_dummy.cu ; ' .
|
||||
\ self.getExecEscaped() . ' ' . arch_flag .
|
||||
\ ' --cuda -O0 -I . .syntastic_dummy.cu -Xcompiler -fsyntax-only -include ' .
|
||||
\ syntastic#util#shexpand('%') . ' ' . syntastic#c#NullOutput()
|
||||
else
|
||||
return []
|
||||
endif
|
||||
endif
|
||||
|
||||
return SyntasticMake({ 'makeprg': makeprg, 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'cuda',
|
||||
\ 'name': 'nvcc'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,60 @@
|
||||
"============================================================================
|
||||
"File: d.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Alfredo Di Napoli <alfredo dot dinapoli at gmail dot com>
|
||||
"License: Based on the original work of Gregor Uhlenheuer and his
|
||||
" cpp.vim checker so credits are dued.
|
||||
" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
" EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
" OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
" NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
" HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
" FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
" OTHER DEALINGS IN THE SOFTWARE.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_d_dmd_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_d_dmd_checker = 1
|
||||
|
||||
if !exists('g:syntastic_d_compiler_options')
|
||||
let g:syntastic_d_compiler_options = ''
|
||||
endif
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_d_dmd_IsAvailable() dict
|
||||
if !exists('g:syntastic_d_compiler')
|
||||
let g:syntastic_d_compiler = self.getExec()
|
||||
endif
|
||||
call self.log('g:syntastic_d_compiler =', g:syntastic_d_compiler)
|
||||
return executable(expand(g:syntastic_d_compiler, 1))
|
||||
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,' .
|
||||
\ '%f:%l: %m',
|
||||
\ 'main_flags': '-c -of' . syntastic#util#DevNull(),
|
||||
\ 'header_names': '\m\.di$' })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'd',
|
||||
\ 'name': 'dmd' })
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,76 @@
|
||||
"============================================================================
|
||||
"File: dartanalyzer.vim
|
||||
"Description: Dart syntax checker - using dartanalyzer
|
||||
"Maintainer: Maksim Ryzhikov <rv.maksim 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_dart_dartanalyzer_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_dart_dartanalyzer_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_dart_dartanalyzer_GetHighlightRegex(error)
|
||||
if a:error['len']
|
||||
let lcol = a:error['col'] - 1
|
||||
let rcol = a:error['col'] + a:error['len']
|
||||
let ret = '\%>' . lcol . 'c\%<' . rcol . 'c'
|
||||
else
|
||||
let ret = ''
|
||||
endif
|
||||
|
||||
return ret
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_dart_dartanalyzer_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({ 'args_after': '--machine' })
|
||||
|
||||
" Machine readable format looks like:
|
||||
" SEVERITY|TYPE|ERROR_CODE|FILENAME|LINE_NUMBER|COLUMN|LENGTH|MESSAGE
|
||||
" SEVERITY: (WARNING|ERROR)
|
||||
" TYPE: (RESOLVER|STATIC_TYPE|...)
|
||||
" ERROR_CODE: (NO_SUCH_TYPE|...)
|
||||
" FILENAME: String
|
||||
" LINE_NUMBER: int
|
||||
" COLUMN: int
|
||||
" LENGTH: int
|
||||
" MESSAGE: String
|
||||
|
||||
" We use %n to grab the error length, for the syntax highlighter
|
||||
let commonformat = '|%.%#|%.%#|%f|%l|%c|%n|%m'
|
||||
|
||||
let errorformat =
|
||||
\ '%EERROR' . commonformat . ',' .
|
||||
\ '%WWARNING' . commonformat
|
||||
|
||||
let loclist = SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'returns': [0, 1, 2, 3] })
|
||||
|
||||
for e in loclist
|
||||
let e['text'] = substitute(e['text'], '\m\\\([\\|]\)', '\1', 'g')
|
||||
|
||||
" Undo the %n hack
|
||||
let e['len'] = e['nr']
|
||||
call remove(e, 'nr')
|
||||
endfor
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'dart',
|
||||
\ 'name': 'dartanalyzer' })
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,55 @@
|
||||
"============================================================================
|
||||
"File: igor.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_docbk_igor_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_docbk_igor_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_docbk_igor_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({})
|
||||
|
||||
let errorformat = '%f:%l:%m'
|
||||
|
||||
let loclist = SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'defaults': { 'type': 'W' },
|
||||
\ 'subtype': 'Style',
|
||||
\ 'returns': [0] })
|
||||
|
||||
let buf = bufnr('')
|
||||
for e in loclist
|
||||
" XXX: igor strips directories from filenames
|
||||
let e['bufnr'] = buf
|
||||
|
||||
let e['hl'] = '\V' . escape( substitute(e['text'], '\m[^:]*:', '', ''), '\' )
|
||||
let e['hl'] = substitute(e['hl'], '\V[', '\\zs', 'g')
|
||||
let e['hl'] = substitute(e['hl'], '\V]', '\\ze', 'g')
|
||||
|
||||
" let e['text'] = substitute(e['text'], '\m:.*$', '', '')
|
||||
endfor
|
||||
|
||||
return loclist
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'docbk',
|
||||
\ 'name': 'igor'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,25 @@
|
||||
"============================================================================
|
||||
"File: docbk.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_docbk_xmllint_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_docbk_xmllint_checker = 1
|
||||
|
||||
runtime! syntax_checkers/xml/*.vim
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'docbk',
|
||||
\ 'name': 'xmllint',
|
||||
\ 'redirect': 'xml/xmllint'})
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,38 @@
|
||||
"============================================================================
|
||||
"File: swiffer.vim
|
||||
"Description: Dust.js syntax checker - using swiffer
|
||||
"Maintainer: Steven Foote <smfoote 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_dustjs_swiffer_checker')
|
||||
finish
|
||||
endif
|
||||
|
||||
let g:loaded_syntastic_dustjs_swiffer_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_dustjs_swiffer_GetLocList() dict
|
||||
let makeprg = self.makeprgBuild({})
|
||||
|
||||
let errorformat = '%E%f - Line %l\, Column %c: %m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'dustjs',
|
||||
\ 'name': 'swiffer'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,61 @@
|
||||
"============================================================================
|
||||
"File: elixir.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Richard Ramsden <rramsden 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_elixir_elixir_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_elixir_elixir_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
" TODO: we should probably split this into separate checkers
|
||||
function! SyntaxCheckers_elixir_elixir_IsAvailable() dict
|
||||
call self.log(
|
||||
\ 'executable("elixir") = ' . executable('elixir') . ', ' .
|
||||
\ 'executable("mix") = ' . executable('mix'))
|
||||
return executable('elixir') && executable('mix')
|
||||
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'
|
||||
let mix_file = syntastic#util#findInParent('mix.exs', expand('%:p:h', 1))
|
||||
|
||||
if filereadable(mix_file)
|
||||
let compile_command = 'mix compile'
|
||||
let make_options['cwd'] = fnamemodify(mix_file, ':p:h')
|
||||
endif
|
||||
|
||||
let make_options['makeprg'] = self.makeprgBuild({ 'exe': compile_command })
|
||||
|
||||
let make_options['errorformat'] =
|
||||
\ '%E** %*[^\ ] %f:%l: %m,' .
|
||||
\ '%W%f:%l: warning: %m'
|
||||
|
||||
return SyntasticMake(make_options)
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'elixir',
|
||||
\ 'name': 'elixir'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,76 @@
|
||||
#!/usr/bin/env escript
|
||||
|
||||
main([File]) ->
|
||||
Dir = get_root(filename:dirname(File)),
|
||||
Defs = [strong_validation,
|
||||
warn_export_all,
|
||||
warn_export_vars,
|
||||
warn_shadow_vars,
|
||||
warn_obsolete_guard,
|
||||
warn_unused_import,
|
||||
report,
|
||||
{i, Dir ++ "/include"}],
|
||||
RebarFile = rebar_file(Dir),
|
||||
RebarOpts = rebar_opts(Dir ++ "/" ++ RebarFile),
|
||||
code:add_patha(filename:absname("ebin")),
|
||||
compile:file(File, Defs ++ RebarOpts);
|
||||
|
||||
main(_) ->
|
||||
io:format("Usage: ~s <file>~n", [escript:script_name()]),
|
||||
halt(1).
|
||||
|
||||
rebar_file(Dir) ->
|
||||
DirList = filename:split(Dir),
|
||||
case lists:last(DirList) of
|
||||
"test" ->
|
||||
"rebar.test.config";
|
||||
_ ->
|
||||
"rebar.config"
|
||||
end.
|
||||
|
||||
rebar_opts(RebarFile) ->
|
||||
Dir = get_root(filename:dirname(RebarFile)),
|
||||
case file:consult(RebarFile) of
|
||||
{ok, Terms} ->
|
||||
RebarLibDirs = proplists:get_value(lib_dirs, Terms, []),
|
||||
lists:foreach(
|
||||
fun(LibDir) ->
|
||||
code:add_pathsa(filelib:wildcard(LibDir ++ "/*/ebin"))
|
||||
end, RebarLibDirs),
|
||||
RebarDepsDir = proplists:get_value(deps_dir, Terms, "deps"),
|
||||
code:add_pathsa(filelib:wildcard(RebarDepsDir ++ "/*/ebin")),
|
||||
IncludeDeps = {i, filename:join(Dir, RebarDepsDir)},
|
||||
proplists:get_value(erl_opts, Terms, []) ++ [IncludeDeps];
|
||||
{error, _} when RebarFile == "rebar.config" ->
|
||||
fallback_opts();
|
||||
{error, _} ->
|
||||
rebar_opts("rebar.config")
|
||||
end.
|
||||
|
||||
fallback_opts() ->
|
||||
code:add_pathsa(filelib:wildcard("deps/*/ebin")),
|
||||
code:add_pathsa(nested_app_ebins()),
|
||||
[ { i, filename:absname("deps") }
|
||||
| [ { i, filename:absname(Path) } || Path <- filelib:wildcard("deps/*/apps")]
|
||||
].
|
||||
|
||||
nested_app_ebins() ->
|
||||
DetectedAppSrcFiles = filelib:wildcard("deps/*/apps/**/*.app.src"),
|
||||
[apps_dir_from_src(AppSrcFile)||AppSrcFile<-DetectedAppSrcFiles].
|
||||
|
||||
apps_dir_from_src(SrcFile) ->
|
||||
SrcDir = filename:dirname(SrcFile),
|
||||
filename:join(SrcDir, "../../ebin").
|
||||
|
||||
get_root(Dir) ->
|
||||
Path = filename:split(filename:absname(Dir)),
|
||||
filename:join(get_root(lists:reverse(Path), Path)).
|
||||
|
||||
get_root([], Path) ->
|
||||
Path;
|
||||
get_root(["src" | Tail], _Path) ->
|
||||
lists:reverse(Tail);
|
||||
get_root(["test" | Tail], _Path) ->
|
||||
lists:reverse(Tail);
|
||||
get_root([_ | Tail], Path) ->
|
||||
get_root(Tail, Path).
|
||||
@ -0,0 +1,61 @@
|
||||
"============================================================================
|
||||
"File: erlang.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Pawel Salata <rockplayer.pl at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_erlang_erlang_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_erlang_erlang_checker = 1
|
||||
|
||||
if !exists('g:syntastic_erlc_include_path')
|
||||
let g:syntastic_erlc_include_path = ''
|
||||
endif
|
||||
|
||||
let s:check_file = syntastic#util#shescape(expand('<sfile>:p:h', 1) . syntastic#util#Slash() . 'erlang_check_file.erl')
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_erlang_escript_GetLocList() dict
|
||||
if expand('%:e', 1) ==# 'hrl'
|
||||
return []
|
||||
endif
|
||||
|
||||
let shebang = syntastic#util#parseShebang()
|
||||
if shebang['exe'] ==# 'escript'
|
||||
let args = '-s'
|
||||
let post_args = ''
|
||||
else
|
||||
let args = s:check_file
|
||||
let post_args = g:syntastic_erlc_include_path
|
||||
endif
|
||||
let makeprg = self.makeprgBuild({
|
||||
\ 'args_after': args,
|
||||
\ 'fname': syntastic#util#shexpand('%:p'),
|
||||
\ 'post_args_after': post_args })
|
||||
|
||||
let errorformat =
|
||||
\ '%W%f:%l: warning: %m,'.
|
||||
\ '%E%f:%l: %m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'erlang',
|
||||
\ 'name': 'escript'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,42 @@
|
||||
"============================================================================
|
||||
"File: syntaxerl.vim
|
||||
"Description: Syntax checking plugin for syntastic.
|
||||
"Maintainer: locojay
|
||||
"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_erlang_syntaxerl_checker')
|
||||
finish
|
||||
endif
|
||||
|
||||
let g:loaded_syntastic_erlang_syntaxerl_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
|
||||
function! SyntaxCheckers_erlang_syntaxerl_GetLocList() dict
|
||||
|
||||
let makeprg = self.makeprgBuild({})
|
||||
|
||||
let errorformat =
|
||||
\ '%W%f:%l: warning: %m,'.
|
||||
\ '%E%f:%l: %m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'erlang',
|
||||
\ 'name': 'syntaxerl'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,82 @@
|
||||
"============================================================================
|
||||
"File: ruby.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_eruby_ruby_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_eruby_ruby_checker = 1
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_eruby_ruby_IsAvailable() dict
|
||||
if !exists('g:syntastic_eruby_ruby_exec') && exists('g:syntastic_ruby_exec')
|
||||
let g:syntastic_eruby_ruby_exec = g:syntastic_ruby_exec
|
||||
call self.log('g:syntastic_eruby_ruby_exec =', g:syntastic_eruby_ruby_exec)
|
||||
endif
|
||||
return executable(self.getExec())
|
||||
endfunction
|
||||
|
||||
function! SyntaxCheckers_eruby_ruby_GetLocList() dict
|
||||
if !exists('s:ruby_new')
|
||||
let s:ruby_new = syntastic#util#versionIsAtLeast(self.getVersion(), [1, 9])
|
||||
endif
|
||||
|
||||
let fname = "'" . escape(expand('%', 1), "\\'") . "'"
|
||||
|
||||
" TODO: encodings became useful in ruby 1.9 :)
|
||||
if s:ruby_new
|
||||
let enc = &fileencoding !=# '' ? &fileencoding : &encoding
|
||||
let encoding_spec = ', :encoding => "' . (enc ==? 'utf-8' ? 'UTF-8' : 'BINARY') . '"'
|
||||
else
|
||||
let encoding_spec = ''
|
||||
endif
|
||||
|
||||
"gsub fixes issue #7, rails has it's own eruby syntax
|
||||
let makeprg =
|
||||
\ self.getExecEscaped() . ' -rerb -e ' .
|
||||
\ syntastic#util#shescape('puts ERB.new(File.read(' .
|
||||
\ fname . encoding_spec .
|
||||
\ ').gsub(''<%='',''<%''), nil, ''-'').src') .
|
||||
\ ' | ' . self.getExecEscaped() . ' -w -c'
|
||||
|
||||
let errorformat = '%-G%\m%.%#warning: %\%%(possibly %\)%\?useless use of a literal in void context,'
|
||||
|
||||
" filter out lines starting with ...
|
||||
" long lines are truncated and wrapped in ... %p then returns the wrong
|
||||
" column offset
|
||||
let errorformat .= '%-G%\%.%\%.%\%.%.%#,'
|
||||
|
||||
let errorformat .=
|
||||
\ '%-GSyntax OK,'.
|
||||
\ '%E-:%l: syntax error\, %m,%Z%p^,'.
|
||||
\ '%W-:%l: warning: %m,'.
|
||||
\ '%Z%p^,'.
|
||||
\ '%-C%.%#'
|
||||
|
||||
let env = syntastic#util#isRunningWindows() ? {} : { 'RUBYOPT': '' }
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'env': env,
|
||||
\ 'defaults': { 'bufnr': bufnr(''), 'vcol': 1 } })
|
||||
endfunction
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'eruby',
|
||||
\ 'name': 'ruby'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,99 @@
|
||||
"============================================================================
|
||||
"File: fortran.vim
|
||||
"Description: Syntax checking plugin for syntastic.vim
|
||||
"Maintainer: Karl Yngve Lervåg <karl.yngve@lervag.net>
|
||||
"License: This program is free software. It comes without any warranty,
|
||||
" to the extent permitted by applicable law. You can redistribute
|
||||
" it and/or modify it under the terms of the Do What The Fuck You
|
||||
" Want To Public License, Version 2, as published by Sam Hocevar.
|
||||
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
||||
"
|
||||
"============================================================================
|
||||
|
||||
if exists('g:loaded_syntastic_fortran_gfortran_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_fortran_gfortran_checker = 1
|
||||
|
||||
if !exists('g:syntastic_fortran_compiler_options')
|
||||
let g:syntastic_fortran_compiler_options = ''
|
||||
endif
|
||||
|
||||
let s:type_map = {}
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_fortran_gfortran_IsAvailable() dict " {{{1
|
||||
if !exists('g:syntastic_fortran_compiler')
|
||||
let g:syntastic_fortran_compiler = self.getExec()
|
||||
endif
|
||||
call self.log('g:syntastic_fortran_compiler = ', g:syntastic_fortran_compiler)
|
||||
return executable(expand(g:syntastic_fortran_compiler, 1))
|
||||
endfunction " }}}1
|
||||
|
||||
" @vimlint(EVL104, 1, l:errorformat)
|
||||
function! SyntaxCheckers_fortran_gfortran_GetLocList() dict " {{{1
|
||||
call s:SetCompilerType(g:syntastic_fortran_compiler)
|
||||
if !has_key(s:type_map, g:syntastic_fortran_compiler)
|
||||
call syntastic#log#error("checker fortran/gfortran: can't parse version string (abnormal termination?)")
|
||||
return []
|
||||
endif
|
||||
|
||||
if s:type_map[g:syntastic_fortran_compiler] ==# 'gfortran'
|
||||
let errorformat =
|
||||
\ '%-C %#,'.
|
||||
\ '%-C %#%.%#,'.
|
||||
\ '%A%f:%l.%c:,'.
|
||||
\ '%Z%trror: %m,'.
|
||||
\ '%Z%tarning: %m,'.
|
||||
\ '%-G%.%#'
|
||||
if !exists('g:syntastic_fortran_gfortran_sort')
|
||||
let g:syntastic_fortran_gfortran_sort = 0
|
||||
endif
|
||||
elseif s:type_map[g:syntastic_fortran_compiler] ==# 'ifort'
|
||||
let errorformat =
|
||||
\ '%E%f(%l): error #%n: %m,'.
|
||||
\ '%W%f(%l): warning #%n: %m,'.
|
||||
\ '%W%f(%l): remark #%n: %m,'.
|
||||
\ '%-Z%p^,'.
|
||||
\ '%-G%.%#'
|
||||
if !exists('g:syntastic_fortran_gfortran_sort')
|
||||
let g:syntastic_fortran_gfortran_sort = 1
|
||||
endif
|
||||
endif
|
||||
|
||||
return syntastic#c#GetLocList('fortran', 'gfortran', {
|
||||
\ 'errorformat': errorformat,
|
||||
\ 'main_flags': '-fsyntax-only' })
|
||||
endfunction " }}}1
|
||||
" @vimlint(EVL104, 0, l:errorformat)
|
||||
|
||||
" Utilities {{{1
|
||||
|
||||
function! s:SetCompilerType(exe) " {{{2
|
||||
if !has_key(s:type_map, a:exe)
|
||||
try
|
||||
let ver = filter( split(syntastic#util#system(syntastic#util#shescape(a:exe) . ' --version'), '\n'),
|
||||
\ 'v:val =~# "\\v^%(GNU Fortran|ifort) "' )[0]
|
||||
if ver =~# '\m^GNU Fortran '
|
||||
let s:type_map[a:exe] = 'gfortran'
|
||||
elseif ver =~# '\m^ifort '
|
||||
let s:type_map[a:exe] = 'ifort'
|
||||
endif
|
||||
catch /\m^Vim\%((\a\+)\)\=:E684/
|
||||
" do nothing
|
||||
endtry
|
||||
endif
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\ 'filetype': 'fortran',
|
||||
\ 'name': 'gfortran' })
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
@ -0,0 +1,81 @@
|
||||
"============================================================================
|
||||
"File: glsl.vim
|
||||
"Description: Syntax checker for OpenGL Shading Language
|
||||
"Maintainer: Joshua Rahm <joshuarahm@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_glsl_cgc_checker')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_syntastic_glsl_cgc_checker = 1
|
||||
|
||||
let s:glsl_extensions = {
|
||||
\ 'glslf': 'gpu_fp',
|
||||
\ 'glslv': 'gpu_vp',
|
||||
\ 'frag': 'gpu_fp',
|
||||
\ 'vert': 'gpu_vp',
|
||||
\ 'fp': 'gpu_fp',
|
||||
\ 'vp': 'gpu_vp'
|
||||
\ }
|
||||
|
||||
let s:save_cpo = &cpo
|
||||
set cpo&vim
|
||||
|
||||
function! SyntaxCheckers_glsl_cgc_GetLocList() dict " {{{1
|
||||
let makeprg = self.makeprgBuild({
|
||||
\ 'args_before': '-oglsl -profile ' . s:GetProfile(),
|
||||
\ 'args': (exists('g:syntastic_glsl_options') ? ' ' . g:syntastic_glsl_options : '') })
|
||||
|
||||
let errorformat =
|
||||
\ '%E%f(%l) : error %m,' .
|
||||
\ '%W%f(%l) : warning %m'
|
||||
|
||||
return SyntasticMake({
|
||||
\ 'makeprg': makeprg,
|
||||
\ 'errorformat': errorformat })
|
||||
endfunction " }}}1
|
||||
|
||||
" Utilities {{{1
|
||||
|
||||
function! s:GetProfile() " {{{2
|
||||
let save_view = winsaveview()
|
||||
let old_foldenable = &foldenable
|
||||
let old_lazyredraw = &lazyredraw
|
||||
|
||||
let &lazyredraw = 1
|
||||
let &foldenable = 0
|
||||
call cursor(1, 1)
|
||||
|
||||
let magic = '\m\C^// profile:\s*'
|
||||
let line = search(magic, 'c')
|
||||
|
||||
call winrestview(save_view)
|
||||
let &foldenable = old_foldenable
|
||||
let &lazyredraw = old_lazyredraw
|
||||
|
||||
if line
|
||||
let profile = matchstr(getline(line), magic . '\zs.*')
|
||||
else
|
||||
let extensions = exists('g:syntastic_glsl_extensions') ? g:syntastic_glsl_extensions : s:glsl_extensions
|
||||
let profile = get(extensions, tolower(expand('%:e', 1)), 'gpu_vert')
|
||||
endif
|
||||
|
||||
return profile
|
||||
endfunction " }}}2
|
||||
|
||||
" }}}1
|
||||
|
||||
call g:SyntasticRegistry.CreateAndRegisterChecker({
|
||||
\'filetype': 'glsl',
|
||||
\'name': 'cgc'})
|
||||
|
||||
let &cpo = s:save_cpo
|
||||
unlet s:save_cpo
|
||||
|
||||
" vim: set sw=4 sts=4 et fdm=marker:
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue