Installed eclim + remved autocomplete plugins

vim/bundle/eclim/autoload/eclim.vim

@@ -0,0 +1,588 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   Plugin that integrates vim with the eclipse plugin eclim (ECLipse
+"   IMproved).
+"
+"   This plugin contains shared functions that can be used regardless of the
+"   current file type being edited.
+"
+" License:
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+  let s:echo_connection_errors = 1
+" }}}
+
+" Script Variables {{{
+  let s:command_ping = '-command ping'
+  let s:command_settings = '-command settings'
+  let s:command_settings_update = '-command settings_update -s "<settings>"'
+  let s:command_shutdown = "-command shutdown"
+  let s:command_jobs = '-command jobs'
+  let s:connect= '^connect: .*$'
+
+  let s:vim_settings = {}
+  let s:vim_settings_defaults = {}
+  let s:vim_settings_types = {}
+  let s:vim_settings_validators = {}
+" }}}
+
+function! eclim#Execute(command, ...) " {{{
+  " Optional args:
+  "   options {
+  "     One of the following to determine the eclimd instance to use, honored in
+  "     the order shown here:
+  "       instance: dictionary representing an eclimd instance.
+  "       project: project name
+  "       workspace: workspace path
+  "       dir: directory path to use as the current dir
+  "     exec: 1 to execute the command using execute instead of system.
+  "     raw: 1 to get the result without evaluating as json
+  "   }
+
+  if exists('g:EclimDisabled')
+    " if we are not in an autocmd or the autocmd is for an acwrite buffer,
+    " alert the user that eclimd is disabled.
+    if expand('<abuf>') == '' || &buftype == 'acwrite'
+      call eclim#util#EchoWarning(
+        \ "eclim is currently disabled. use :EclimEnable to enable it.")
+    endif
+    return
+  endif
+
+  if !eclim#EclimAvailable()
+    return
+  endif
+
+  let command = '-editor vim ' . a:command
+
+  " encode special characters
+  " http://www.w3schools.com/TAGS/ref_urlencode.asp
+  let command = substitute(command, '\*', '%2A', 'g')
+  let command = substitute(command, '\$', '%24', 'g')
+  let command = substitute(command, '<', '%3C', 'g')
+  let command = substitute(command, '>', '%3E', 'g')
+
+  " determine the eclimd instance to use
+  let options = a:0 ? a:1 : {}
+  let instance = get(options, 'instance', {})
+  if len(instance) == 0
+    let project = get(options, 'project', '')
+    if project != ''
+      let workspace = eclim#project#util#GetProjectWorkspace(project)
+      if type(workspace) == g:LIST_TYPE
+        let workspaces = workspace
+        unlet workspace
+        let response = eclim#util#PromptList(
+          \ 'Muliple workspaces found, please choose the target workspace',
+          \ workspaces, g:EclimHighlightInfo)
+
+        " user cancelled, error, etc.
+        if response < 0
+          return
+        endif
+
+        let workspace = workspaces[response]
+      endif
+    else
+      let workspace = ''
+    endif
+
+    if workspace == ''
+      let workspace = get(options, 'workspace', '')
+    endif
+
+    let dir = workspace != '' ? workspace : get(options, 'dir', '')
+    let chosen = eclim#client#nailgun#ChooseEclimdInstance(dir)
+    if type(chosen) != g:DICT_TYPE
+      return
+    endif
+    let instance = chosen
+  endif
+
+  let exec = get(options, 'exec', 0)
+  let [retcode, result] = eclim#client#nailgun#Execute(instance, command, exec)
+  let result = substitute(result, '\n$', '', '')
+
+  " not sure this is the best place to handle this, but when using the python
+  " client, the result has a trailing ctrl-m on windows.  also account for
+  " running under cygwin vim.
+  if has('win32') || has('win64') || has('win32unix')
+    let result = substitute(result, "\<c-m>$", '', '')
+  endif
+
+  " an echo during startup causes an annoying issue with vim.
+  "call eclim#util#Echo(' ')
+
+  " check for errors
+  let error = ''
+  if result =~ '^[^\n]*Exception:\?[^\n]*\n\s\+\<at\> ' ||
+   \ result =~ '^[^\n]*ResourceException(.\{-})\[[0-9]\+\]:[^\n]*\n\s\+\<at\> '
+    if g:EclimLogLevel != 'trace'
+      let error = substitute(result, '\(.\{-}\)\n.*', '\1', '')
+    else
+      let error = result
+    endif
+  elseif retcode
+    let error = result
+  endif
+
+  if retcode || error != ''
+    if s:echo_connection_errors
+      if error =~ s:connect
+        " if we are not in an autocmd or the autocmd is for an acwrite buffer,
+        " alert the user that eclimd is not running.
+        if expand('<abuf>') == '' || &buftype == 'acwrite'
+          call eclim#util#EchoWarning(
+            \ "unable to connect to eclimd (port: " . instance.port . ") - " . error)
+        endif
+      else
+        let error = error . "\n" .
+          \ 'while executing command (port: ' . instance.port . '): ' . command
+        " if we are not in an autocmd or in a autocmd for an acwrite buffer,
+        " echo the error, otherwise just log it.
+        if expand('<abuf>') == '' || &buftype == 'acwrite'
+          call eclim#util#EchoError(error)
+        else
+          call eclim#util#EchoDebug(error)
+        endif
+      endif
+    endif
+    return
+  endif
+
+  let raw = get(options, 'raw', 0)
+  return result != '' && !raw ? eval(result) : result
+endfunction " }}}
+
+function! eclim#Disable() " {{{
+  if !exists('g:EclimDisabled')
+    let g:EclimDisabled = 1
+  endif
+endfunction " }}}
+
+function! eclim#Enable() " {{{
+  if exists('g:EclimDisabled')
+    unlet g:EclimDisabled
+  endif
+endfunction " }}}
+
+function! eclim#EclimAvailable(...) " {{{
+  " Optional args:
+  "   echo: Whether or not to echo an error if eclim is not available
+  "         (default: 1)
+  let instances = eclim#UserHome() . '/.eclim/.eclimd_instances'
+  let available = filereadable(instances)
+  let echo = a:0 ? a:1 : 1
+  if echo && !available && expand('<abuf>') == ''
+    call eclim#util#EchoError(printf(
+      \ 'No eclimd instances found running (eclimd created file not found %s)',
+      \ eclim#UserHome() . '/.eclim/.eclimd_instances'))
+  endif
+  return available
+endfunction " }}}
+
+function! eclim#PingEclim(echo, ...) " {{{
+  " If echo is non 0, then the result is echoed to the user.
+  " Optional args:
+  "   workspace
+
+  let workspace = a:0 ? a:1 : ''
+  if a:echo
+    let result = eclim#Execute(s:command_ping, {'workspace': workspace})
+    if type(result) == g:DICT_TYPE
+      call eclim#util#Echo(
+        \ 'eclim   ' . result.eclim . "\n" .
+        \ 'eclipse ' . result.eclipse)
+    endif
+  else
+    let savedErr = s:echo_connection_errors
+    let savedLog = g:EclimLogLevel
+    let s:echo_connection_errors = 0
+    let g:EclimLogLevel = 'off'
+
+    let result = eclim#Execute(s:command_ping, {'workspace': workspace})
+
+    let s:echo_connection_errors = savedErr
+    let g:EclimLogLevel = savedLog
+
+    return type(result) == g:DICT_TYPE
+  endif
+endfunction " }}}
+
+function! eclim#ParseSettingErrors(errors) " {{{
+  let errors = []
+  for error in a:errors
+    let message = error.message
+    let setting = substitute(message, '^\(.\{-}\): .*', '\1', '')
+    let message = substitute(message, '^.\{-}: \(.*\)', '\1', '')
+    if error.line == 1 && setting != error.message
+      let line = search('^\s*' . setting . '\s*=', 'cnw')
+      let error.line = line > 0 ? line : 1
+    endif
+    call add(errors, {
+        \ 'bufnr': bufnr('%'),
+        \ 'lnum': error.line,
+        \ 'text': message,
+        \ 'type': error.warning == 1 ? 'w' : 'e',
+      \ })
+  endfor
+  return errors
+endfunction " }}}
+
+function! eclim#SaveSettings(command, project) " {{{
+  " don't check modified since undo seems to not set the modified flag
+  "if &modified
+    let tempfile = substitute(tempname(), '\', '/', 'g')
+
+    " get all lines, filtering out comments and blank lines
+    let lines = filter(getline(1, line('$')), 'v:val !~ "^\\s*\\(#\\|$\\)"')
+
+    " convert lines into a settings dict
+    let index = 0
+    let settings = {}
+    let pattern = '^\s*\([[:alnum:]_.-]\+\)\s*=\s*\(.*\)'
+    while index < len(lines)
+      if lines[index] =~ pattern
+        let name = substitute(lines[index], pattern, '\1', '')
+        let value = substitute(lines[index], pattern, '\2', '')
+        while value =~ '\\$'
+          let index += 1
+          let value = substitute(value, '\\$', '', '')
+          let value .= substitute(lines[index], '^\s*', '', '')
+        endwhile
+        let settings[name] = value
+      endif
+      let index += 1
+    endwhile
+    call writefile([string(settings)], tempfile)
+
+    if has('win32unix')
+      let tempfile = eclim#cygwin#WindowsPath(tempfile)
+    endif
+
+    let command = a:command
+    let command = substitute(command, '<project>', a:project, '')
+    let command = substitute(command, '<settings>', tempfile, '')
+
+    if exists('b:eclimd_instance')
+      let result = eclim#Execute(command, {'instance': b:eclimd_instance})
+    else
+      let result = eclim#Execute(command)
+    endif
+
+    if type(result) == g:LIST_TYPE
+      call eclim#util#EchoError
+        \ ("Operation contained errors.  See location list for details.")
+      let errors = eclim#ParseSettingErrors(result)
+      call eclim#util#SetLocationList(errors)
+    else
+      call eclim#util#ClearLocationList()
+      call eclim#util#Echo(result)
+    endif
+
+    setlocal nomodified
+  "endif
+endfunction " }}}
+
+function! eclim#Settings(workspace) " {{{
+  let instance = eclim#client#nailgun#ChooseEclimdInstance(a:workspace)
+  if type(instance) != g:DICT_TYPE
+    return
+  endif
+
+  let settings = eclim#Execute(s:command_settings, {'instance': instance})
+  if type(settings) != g:LIST_TYPE
+    return
+  endif
+
+  let content = ['# Global settings for workspace: ' . instance.workspace, '']
+  let path = ''
+  for setting in settings
+    if setting.path != path
+      if path != ''
+        let content += ['# }', '']
+      endif
+      let path = setting.path
+      call add(content, '# ' . path . ' {')
+    endif
+    let description = split(setting.description, '\n')
+    let content += map(description, "'\t# ' . v:val")
+    call add(content, "\t" . setting.name . '=' . setting.value)
+  endfor
+  if path != ''
+    call add(content, '# }')
+  endif
+
+  call eclim#util#TempWindow("Workspace_Settings", content)
+  setlocal buftype=acwrite
+  setlocal filetype=jproperties
+  setlocal noreadonly
+  setlocal modifiable
+  setlocal foldmethod=marker
+  setlocal foldmarker={,}
+  let b:eclimd_instance = instance
+
+  augroup eclim_settings
+    autocmd! BufWriteCmd <buffer>
+    exec 'autocmd BufWriteCmd <buffer> ' .
+      \ 'call eclim#SaveSettings(s:command_settings_update, "")'
+  augroup END
+endfunction " }}}
+
+function! eclim#ShutdownEclim() " {{{
+  call eclim#Execute(s:command_shutdown)
+endfunction " }}}
+
+function! eclim#LoadVimSettings() " {{{
+  let settings_file = eclim#UserHome() . '/.eclim/.eclim_settings'
+  if filereadable(settings_file)
+    let lines = readfile(settings_file)
+    if len(lines) == 1 && lines[0] =~ '^{.*}$'
+      let settings = eval(lines[0])
+      for [key, value] in items(settings)
+        let name = 'g:Eclim' . key
+        if !exists(name)
+          exec 'let ' . name . ' = ' . string(value)
+        endif
+        unlet value
+      endfor
+    endif
+  endif
+
+  " Handle legacy sign/log level values
+  let legacy = {0: 'off', 1: 'error', 2: 'error', 3: 'warning', 4: 'info', 5: 'debug', 6: 'trace'}
+  if exists('g:EclimLogLevel') && type(g:EclimLogLevel) == g:NUMBER_TYPE
+    let g:EclimLogLevel = get(legacy, g:EclimLogLevel, 'info')
+  endif
+  if exists('g:EclimSignLevel') && type(g:EclimSignLevel) == g:NUMBER_TYPE
+    let g:EclimSignLevel = get(legacy, g:EclimSignLevel, 'info')
+  endif
+endfunction " }}}
+
+function! eclim#AddVimSetting(namespace, name, default, desc, ...) " {{{
+  " Optional args:
+  "   regex: regular expression used to validate the setting's value.
+  if !has_key(s:vim_settings, a:namespace)
+    let s:vim_settings[a:namespace] = {}
+  endif
+  let name = substitute(a:name, 'g:Eclim', '', '')
+  let s:vim_settings[a:namespace][name] = {'desc': a:desc}
+  let s:vim_settings_defaults[name] = a:default
+  let s:vim_settings_types[name] = type(a:default)
+  let regex = a:0 ? a:1 : ''
+  if regex != ''
+    let s:vim_settings_validators[name] = regex
+    if exists(a:name)
+      exec 'let value = ' . a:name
+      if value !~ '^' . regex . '$'
+        echo a:name . ' must match ' . regex
+        exec 'unlet ' . a:name
+      endif
+    endif
+  endif
+
+  if !exists(a:name)
+    exec 'let ' . a:name . ' = ' . string(a:default)
+  endif
+endfunction " }}}
+
+function! eclim#VimSettings() " {{{
+  let content = [
+      \ "# Eclim's global vim settings",
+      \ "# The settings here allow you to configure the vim side behavior of eclim.",
+      \ "# You can use <cr> on a setting name to open the eclim docs for that setting.",
+      \ "#",
+      \ "# Note: If you have g:EclimXXX variables set in your .vimrc, those will take",
+      \ "# precedence over any changes you make here.",
+    \ ]
+  for namespace in sort(keys(s:vim_settings))
+    let content += ['', '# ' . namespace . ' {{{']
+    for name in sort(keys(s:vim_settings[namespace]))
+      let setting = s:vim_settings[namespace][name]
+      let desc = split(setting.desc, '\n')
+      let content += map(desc, "'\t# ' . v:val")
+      exec 'let value = string(g:Eclim' . name . ')'
+      call add(content, "\t" . name . '=' . value)
+    endfor
+    let content += ['# }}}']
+  endfor
+
+  call eclim#util#TempWindow("Vim_Settings", content)
+  setlocal buftype=acwrite
+  setlocal filetype=jproperties
+  setlocal noreadonly
+  setlocal modifiable
+  setlocal foldmethod=marker
+  setlocal foldmarker={{{,}}}
+  nnoremap <cr> :call <SID>VimSettingHelp()<cr>
+
+  augroup eclim_settings
+    autocmd! BufWriteCmd <buffer>
+    autocmd BufWriteCmd <buffer> call eclim#SaveVimSettings()
+  augroup END
+endfunction " }}}
+
+function! s:VimSettingHelp() " {{{
+  let pos = getpos('.')
+  try
+    call cursor(0, 1)
+    normal! w
+    let syntax =  synIDattr(synID(line('.'), col('.'), 1), 'name')
+  finally
+    call setpos('.', pos)
+  endtry
+
+  if syntax == 'jpropertiesIdentifier'
+    let line = getline('.')
+    let name = substitute(line, '^\s*\(\w\+\)=.*', '\1', '')
+    if name != line
+      exec 'EclimHelp g:Eclim' . name
+    endif
+  endif
+endfunction " }}}
+
+function! eclim#SaveVimSettings() " {{{
+  " get all lines, filtering out comments and blank lines
+  let lines = filter(getline(1, line('$')), 'v:val !~ "^\\s*\\(#\\|$\\)"')
+
+  " convert lines into a settings dict
+  let index = 0
+  let settings = {}
+  let pattern = '^\s*\([[:alnum:]_.-]\+\)\s*=\s*\(.*\)'
+  let errors = []
+  while index < len(lines)
+    try
+      if lines[index] =~ pattern
+        let name = substitute(lines[index], pattern, '\1', '')
+        if !has_key(s:vim_settings_types, name)
+          continue
+        endif
+
+        let value = substitute(lines[index], pattern, '\2', '')
+        while value =~ '\\$'
+          let index += 1
+          let value = substitute(value, '\\$', '', '')
+          let value .= substitute(lines[index], '^\s*', '', '')
+        endwhile
+        let value = substitute(value, "\\(^['\"]\\|['\"]$\\)", '', 'g')
+
+        if has_key(s:vim_settings_validators, name)
+          let regex = s:vim_settings_validators[name]
+          if value !~ '^' . regex . '$'
+            let [line, col] = searchpos('^\s*' . name . '=', 'nw')
+            call add(errors, {
+                \ 'filename': expand('%'),
+                \ 'message': name . ': must match ' . regex,
+                \ 'line': line,
+                \ 'column': col,
+                \ 'type': 'error',
+              \ })
+            continue
+          endif
+        endif
+
+        if s:vim_settings_types[name] != g:STRING_TYPE
+          try
+            let typed_value = eval(value)
+            unlet value
+            let value = typed_value
+          catch /E121\|E115/
+            let [line, col] = searchpos('^\s*' . name . '=', 'nw')
+            call add(errors, {
+                \ 'filename': expand('%'),
+                \ 'message': name . ': ' . v:exception,
+                \ 'line': line,
+                \ 'column': col,
+                \ 'type': 'error',
+              \ })
+            continue
+          endtry
+        endif
+
+        let default = s:vim_settings_defaults[name]
+        if value != default
+          let settings[name] = value
+        endif
+      endif
+    finally
+      let index += 1
+      unlet! value typed_value default
+    endtry
+  endwhile
+
+  if len(errors)
+    call eclim#util#SetLocationList(eclim#util#ParseLocationEntries(errors))
+    call eclim#util#EchoError(
+      \ len(errors) . ' error' . (len(errors) > 1 ? 's' : '') . ' found.')
+    return
+  endif
+
+  call eclim#util#ClearLocationList()
+
+  if !isdirectory(eclim#UserHome() . '/.eclim')
+    call mkdir(eclim#UserHome() . '/.eclim')
+  endif
+  let settings_file = eclim#UserHome() . '/.eclim/.eclim_settings'
+  if writefile([string(settings)], settings_file) == 0
+    call eclim#util#Echo('Settings saved. You may need to restart vim for all changes to take affect.')
+  else
+    call eclim#util#Echo('Unable to write settings.')
+  endif
+
+  setlocal nomodified
+endfunction " }}}
+
+function! eclim#UserHome() " {{{
+  let home = expand('$HOME')
+  if has('win32unix')
+    let home = eclim#cygwin#WindowsHome()
+  elseif has('win32') || has('win64')
+    let home = expand('$USERPROFILE')
+  endif
+  return substitute(home, '\', '/', 'g')
+endfunction " }}}
+
+function! eclim#WaitOnRunningJobs(timeout) " {{{
+  " Args:
+  "   timeout: max time to wait in milliseconds
+  let running = 1
+  let waited = 0
+  while running && waited < a:timeout
+    let jobs = eclim#Execute(s:command_jobs)
+    if type(jobs) == g:LIST_TYPE
+      let running = 0
+      for job in jobs
+        if job.status == 'running'
+          call eclim#util#EchoDebug('Wait on job: ' . job.job)
+          let running = 1
+          let waited += 300
+          sleep 300m
+          break
+        endif
+      endfor
+    endif
+  endwhile
+  if running
+    call eclim#util#EchoDebug('Timeout exceeded waiting on jobs')
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/client/nailgun.vim

@@ -0,0 +1,177 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Global Variables {{{
+  if !exists("g:EclimNailgunKeepAlive")
+    " keepAlive flag - can be re-defined in the user ~/.vimrc .
+    " Read once, on client initialization. Subsequent changes of
+    " this flag in run-time has no effect.
+    let g:EclimNailgunKeepAlive = 0
+  endif
+" }}}
+
+function! eclim#client#nailgun#ChooseEclimdInstance(...) " {{{
+  " Function which prompts the user to pick the target workspace and returns
+  " their choice or if only one workspace is active simply return it without
+  " prompting the user.  If the optional 'dir' argument is supplied and that dir
+  " is a subdirectory of one of the workspaces, then that workspace will be
+  " returned.
+  " Optional args:
+  "   dir
+
+  if !eclim#EclimAvailable()
+    return
+  endif
+
+  let instances = eclim#client#nailgun#GetEclimdInstances()
+  if len(instances) == 1
+    return instances[keys(instances)[0]]
+  endif
+
+  if len(instances) > 1
+    let path = a:0 && a:1 != '' ? a:1 : expand('%:p')
+    if path == ''
+      let path = getcwd() . '/'
+    endif
+    let path = substitute(path, '\', '/', 'g')
+
+    " when we are in a temp window, use the initiating filename
+    if &buftype != '' && exists('b:filename')
+      let path = b:filename
+    endif
+
+    " project inside of a workspace dir
+    for workspace in keys(instances)
+      if path =~ '^' . workspace
+        return instances[workspace]
+      endif
+    endfor
+
+    " project outside of a workspace dir
+    let project = eclim#project#util#GetProject(path)
+    if len(project) > 0
+      return get(instances, project.workspace, 0)
+    endif
+
+    let workspaces = keys(instances)
+    let response = eclim#util#PromptList(
+      \ 'Muliple workspaces found, please choose the target workspace',
+      \ workspaces, g:EclimHighlightInfo)
+
+    " user cancelled, error, etc.
+    if response < 0
+      return
+    endif
+
+    return instances[workspaces[response]]
+  endif
+
+  call eclim#util#Echo('No eclimd instances found running.')
+endfunction " }}}
+
+function! eclim#client#nailgun#GetEclimdInstances() " {{{
+  " Returns a dict with eclimd instances.
+  let instances = {}
+  if eclim#EclimAvailable()
+    let dotinstances = eclim#UserHome() . '/.eclim/.eclimd_instances'
+    let lines = readfile(dotinstances)
+    for line in lines
+      if line !~ '^{'
+        continue
+      endif
+      let values = eval(line)
+      let instances[values.workspace] = values
+    endfor
+  endif
+  return instances
+endfunction " }}}
+
+function! eclim#client#nailgun#Execute(instance, command, ...) " {{{
+  let exec = a:0 ? a:1 : 0
+
+  if !exec
+    if g:EclimNailgunClient == 'python' && has('python')
+      return eclim#client#python#nailgun#Execute(a:instance.port, a:command)
+    endif
+  endif
+
+  let [retcode, result] = eclim#client#nailgun#GetEclimCommand(a:instance.home)
+  if retcode != 0
+    return [retcode, result]
+  endif
+
+  let command = a:command
+  if exec
+    let command = escape(command, '%#')
+  endif
+
+  " on windows/cygwin where cmd.exe is used, we need to escape any '^'
+  " characters in the command args.
+  if has('win32') || has('win64') || has('win32unix')
+    let command = substitute(command, '\^', '^^', 'g')
+  endif
+
+  let eclim = result . ' --nailgun-server localhost --nailgun-port ' . a:instance.port . ' ' . command
+  if exec
+    let eclim = '!' . eclim
+  endif
+
+  let result = eclim#util#System(eclim, exec, exec)
+  return [v:shell_error, result]
+endfunction " }}}
+
+function! eclim#client#nailgun#GetEclimCommand(home) " {{{
+  " Gets the command to exexute eclim.
+  let command = a:home . 'bin/eclim'
+
+  if has('win32') || has('win64') || has('win32unix')
+    let command = command . '.bat'
+  endif
+
+  if !filereadable(command)
+    return [1, 'Could not locate file: ' . command]
+  endif
+
+  if has('win32unix')
+    " in cygwin, we must use 'cmd /c' to prevent issues with eclim script +
+    " some arg containing spaces causing a failure to invoke the script.
+    return 'cmd /c "' . eclim#cygwin#WindowsPath(command) . '"'
+  endif
+  return [0, '"' . command . '"']
+endfunction " }}}
+
+function! eclim#client#nailgun#CommandCompleteWorkspaces(argLead, cmdLine, cursorPos) " {{{
+  " Custom command completion for available workspaces.
+
+  let cmdLine = strpart(a:cmdLine, 0, a:cursorPos)
+  let args = eclim#util#ParseCmdLine(cmdLine)
+  let argLead = cmdLine =~ '\s$' ? '' : args[len(args) - 1]
+
+  let instances = eclim#client#nailgun#GetEclimdInstances()
+  let workspaces = sort(keys(instances))
+  if cmdLine !~ '[^\\]\s$'
+    call filter(workspaces, 'v:val =~ "^' . argLead . '"')
+  endif
+
+  return workspaces
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/client/python/nailgun.py

@@ -0,0 +1,214 @@
+"""
+Copyright (C) 2005 - 2011  Eric Van Dewoestine
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+@author: Anton Sharonov
+@author: Eric Van Dewoestine
+"""
+import socket
+
+try:
+  from cStringIO import StringIO
+except:
+  from StringIO import StringIO
+
+class Nailgun(object):
+  """
+  Client used to communicate with a nailgun server.
+  """
+
+  def __init__(self, **kwargs):
+    self.socket = None
+    self.port = kwargs.get('port')
+    self.keepAlive = int(kwargs.get('keepAlive', 0))
+    self.reconnectCounter = 0
+
+  def send(self, cmdline):
+    """
+    Sends a complete command to the nailgun server.  Handles connecting to the
+    server if not currently connected.
+    @param cmdline command, which is sent to server, for instance
+      "-command ping".
+    @return tuple consisting of:
+      - retcode from server (0 for success, non-0 for failure)
+      - string response from server
+    """
+    if not self.isConnected():
+      # with keepAlive do only first reconnect
+      if not self.keepAlive or self.reconnectCounter == 0:
+        (retcode, result) = self.reconnect()
+        if retcode:
+          return (retcode, result)
+
+    if not self.isConnected(): # Only for keepAlive
+      return (-1, "connect: ERROR - socket is not connected (nailgun.py)")
+
+    try: # outer try for pre python 2.5 support.
+      try:
+        for arg in self.parseArgs(cmdline):
+          self.sendChunk("A", arg)
+
+        if self.keepAlive:
+          self.sendChunk("K")
+
+        self.sendChunk("C", "org.eclim.command.Main")
+
+        (retcode, result) = self.processResponse()
+        if self.keepAlive and retcode:
+          # force reconnect on error (may not be necessary)
+          self.reconnect()
+
+        return (retcode, result)
+      except socket.error, ex:
+        args = ex.args
+        if len(args) > 1:
+          retcode, msg = args[0], args[1]
+        elif len(args):
+          retcode, msg = 1, args[0]
+        else:
+          retcode, msg = 1, 'No message'
+        return (retcode, 'send: %s' % msg)
+    finally:
+      if not self.keepAlive:
+        try:
+          self.close()
+        except:
+          # don't let an error on close mask any previous error.
+          pass
+
+  def connect(self, port=None):
+    """
+    Establishes the connection to specified port or if not supplied,
+    uses the default.
+    """
+    port = port or self.port
+    try:
+      sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+      sock.connect(('localhost', port))
+    except socket.error, ex:
+      args = ex.args
+      if len(args) > 1:
+        retcode, msg = args[0], args[1]
+      elif len(args):
+        retcode, msg = 1, args[0]
+      else:
+        retcode, msg = 1, 'No message'
+      return (retcode, 'connect: %s' % msg)
+
+    self.socket = sock
+    return (0, '')
+
+  def reconnect(self):
+    if self.socket != None:
+      self.close()
+    self.reconnectCounter += 1
+    return self.connect()
+
+  def close(self):
+    self.socket.close()
+    self.socket = None
+
+  def isConnected(self):
+    return self.socket != None
+
+  def parseArgs(self, cmdline):
+    # FIXME: doesn't handle escaping of spaces/quotes yet (may never need to)
+    args = []
+    arg = ''
+    quote = ''
+    for char in cmdline:
+      if char == ' ' and not quote:
+        if arg:
+          args.append(arg)
+          arg = ''
+      elif char == '"' or char == "'":
+        if quote and char == quote:
+          quote = ''
+        elif not quote:
+          quote = char
+        else:
+          arg += char
+      else:
+        arg += char
+
+    if arg:
+      args.append(arg)
+
+    return args
+
+  def sendChunk(self, chunkType, text=''):
+    """
+    Sends a nailgun 'chunk' to the server.
+    """
+    #print("sendChunk " + chunkType + " " + text)
+    length = len(text)
+    str = "%c%c%c%c%c" % (
+        (length / (65536*256)) % 256,
+        (length / 65536) % 256,
+        (length / 256) % 256,
+        length % 256,
+        chunkType)
+    nbytes = self.socket.sendall(str)
+    nbytes = self.socket.sendall(text)
+
+  def processResponse(self):
+    result = StringIO()
+    exit = 0
+    exitFlag = 1 # expecting 1 times exit chunk
+    while exitFlag > 0:
+      answer = self.recvBlocked(5)
+      if len(answer) < 5:
+        print("error: socket closed unexpectedly\n")
+        return None
+      lenPayload = ord(answer[0]) * 65536 * 256 \
+        + ord(answer[1]) * 65536 \
+        + ord(answer[2]) * 256 \
+        + ord(answer[3])
+      #print("lenPayload detected : %d" % lenPayload)
+      chunkType = answer[4]
+      if chunkType == "1":
+        # STDOUT
+        result.write(self.recvToFD(1, answer, lenPayload))
+      elif chunkType == "2":
+        # STDERR
+        result.write(self.recvToFD(2, answer, lenPayload))
+      elif chunkType == "X":
+        exitFlag = exitFlag - 1
+        exit = int(self.recvToFD(2, answer, lenPayload))
+      else:
+        print("error: unknown chunk type = %d\n" % chunkType)
+        exitFlag = 0
+
+    return [exit, result.getvalue()]
+
+  def recvBlocked(self, lenPayload):
+    """
+    Receives until all data is read - necessary because usual recv sometimes
+    returns with number of bytes read less then asked.
+    """
+    received = ""
+    while (len(received) < lenPayload):
+      received = received + self.socket.recv(lenPayload - len(received))
+    return received
+
+  def recvToFD(self, destFD, buf, lenPayload):
+    """
+    This function just mimics the function with the same name from the C
+    client.  We don't really care which file descriptor the server tells us to
+    write to - STDOUT and STDERR are the same on VIM side (see eclim.bat,
+    "2>&1" at the end of command).
+    """
+    received = self.recvBlocked(lenPayload)
+    return received

vim/bundle/eclim/autoload/eclim/client/python/nailgun.vim

@@ -0,0 +1,115 @@
+" Author:  Anton Sharonov
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2010  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+  let s:python_dir = expand("<sfile>:h")
+" }}}
+
+" Execute(port, command) {{{
+" Sends to the eclimd server command, supplied as argument string.
+" Returns server's respond.
+function! eclim#client#python#nailgun#Execute(port, command)
+  call s:InitClient(a:port)
+  let result_viml = ""
+  let retcode = 0
+
+  let begin = localtime()
+  try
+python << PYTHONEOF
+command = vim.eval('a:command')
+(retcode, result) = client.send(command)
+vim.command('let retcode = %i' % retcode)
+vim.command("let result = '%s'" % result.replace("'", "''"))
+PYTHONEOF
+  finally
+    call eclim#util#EchoTrace(
+      \ 'nailgun.py (port: ' . a:port . '): ' . a:command, localtime() - begin)
+  endtry
+
+  return [retcode, result]
+endfunction " }}}
+
+" Reconnect(port) {{{
+" Does unconditional reconnect of the python_if
+" (useful to manual recover from errors in the python_if)
+function! eclim#client#python#nailgun#Reconnect(port)
+  call s:InitClient(a:port)
+python << PYTHONEOF
+client.reconnect()
+PYTHONEOF
+endfunction " }}}
+
+" SetKeepAlive(port, value) {{{
+" Updates the in runtime value of the keepAlive flag.
+function! eclim#client#python#nailgun#SetKeepAlive(port, value)
+  call s:InitClient(a:port)
+python << PYTHONEOF
+client.keepAlive = int(vim.eval('a:value'))
+PYTHONEOF
+endfunction " }}}
+
+" GetKeepAlive(port) {{{
+" Retrieves the value of the keepAlive flag.
+function! eclim#client#python#nailgun#GetKeepAlive(port)
+  call s:InitClient(a:port)
+  let result = 0
+python << PYTHONEOF
+vim.command("let result = %s" % client.keepAlive)
+PYTHONEOF
+  return result
+endfunction " }}}
+
+" GetReconnectCounter(port) {{{
+" Retrieves the value of the reconnect counter.
+function! eclim#client#python#nailgun#GetReconnectCounter(port)
+  call s:InitClient(a:port)
+  let result = 0
+python << PYTHONEOF
+vim.command("let result = %d" % client.reconnectCounter)
+PYTHONEOF
+  return result
+endfunction " }}}
+
+" s:InitClient(port) {{{
+" Initializes the python interface to the nailgun server.
+function! s:InitClient(port)
+python << PYTHONEOF
+if not vars().has_key('clients'):
+  import sys, vim
+  sys.path.append(vim.eval('s:python_dir'))
+  import nailgun
+
+  clients = {}
+
+port = int(vim.eval('a:port'))
+if not clients.has_key(port):
+  clients[port] = nailgun.Nailgun(
+    port=port,
+    keepAlive=vim.eval('g:EclimNailgunKeepAlive'),
+  )
+client = clients[port]
+PYTHONEOF
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/common/buffers.vim

@@ -0,0 +1,379 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" ScriptVariables {{{
+  let s:eclim_tab_id = 0
+" }}}
+
+function! eclim#common#buffers#Buffers(bang) " {{{
+  " Like, :buffers, but opens a temporary buffer.
+
+  let options = {'maxfilelength': 0}
+  let buffers = eclim#common#buffers#GetBuffers(options)
+
+  if g:EclimBuffersSort != ''
+    call sort(buffers, 'eclim#common#buffers#BufferCompare')
+  endif
+
+  let lines = []
+  let buflist = []
+  let filelength = options['maxfilelength']
+  let tabid = exists('*gettabvar') ? s:GetTabId() : 0
+  let tabbuffers = tabpagebuflist()
+  for buffer in buffers
+    let eclim_tab_id = getbufvar(buffer.bufnr, 'eclim_tab_id')
+    if a:bang != '' || eclim_tab_id == '' || eclim_tab_id == tabid
+      " for buffers w/ out a tab id, don't show them in the list if they
+      " are active, but aren't open on the current tab.
+      if a:bang == '' && buffer.status =~ 'a' && index(tabbuffers, buffer.bufnr) == -1
+        continue
+      endif
+
+      call add(lines, s:BufferEntryToLine(buffer, filelength))
+      call add(buflist, buffer)
+    endif
+  endfor
+
+  call eclim#util#TempWindow('[buffers]', lines)
+
+  setlocal modifiable noreadonly
+  call append(line('$'), ['', '" use ? to view help'])
+  setlocal nomodifiable readonly
+
+  let b:eclim_buffers = buflist
+
+  " syntax
+  set ft=eclim_buffers
+  hi link BufferActive Special
+  hi link BufferHidden Comment
+  syntax match BufferActive /+\?active\s\+\(\[RO\]\)\?/
+  syntax match BufferHidden /+\?hidden\s\+\(\[RO\]\)\?/
+  syntax match Comment /^".*/
+
+  " mappings
+  nnoremap <silent> <buffer> <cr> :call <SID>BufferOpen(g:EclimBuffersDefaultAction)<cr>
+  nnoremap <silent> <buffer> E :call <SID>BufferOpen('edit')<cr>
+  nnoremap <silent> <buffer> S :call <SID>BufferOpen('split')<cr>
+  nnoremap <silent> <buffer> V :call <SID>BufferOpen('vsplit')<cr>
+  nnoremap <silent> <buffer> T :call <SID>BufferOpen('tablast \| tabnew')<cr>
+  nnoremap <silent> <buffer> D :call <SID>BufferDelete()<cr>
+  nnoremap <silent> <buffer> R :Buffers<cr>
+
+  " assign to buffer var to get around weird vim issue passing list containing
+  " a string w/ a '<' in it on execution of mapping.
+  let b:buffers_help = [
+      \ '<cr> - open buffer with default action',
+      \ 'E - open with :edit',
+      \ 'S - open in a new split window',
+      \ 'V - open in a new vertically split window',
+      \ 'T - open in a new tab',
+      \ 'D - delete the buffer',
+      \ 'R - refresh the buffer list',
+    \ ]
+  nnoremap <buffer> <silent> ?
+    \ :call eclim#help#BufferHelp(b:buffers_help, 'vertical', 40)<cr>
+
+  "augroup eclim_buffers
+  "  autocmd!
+  "  autocmd BufAdd,BufWinEnter,BufDelete,BufWinLeave *
+  "    \ call eclim#common#buffers#BuffersUpdate()
+  "  autocmd BufUnload <buffer> autocmd! eclim_buffers
+  "augroup END
+endfunction " }}}
+
+function! eclim#common#buffers#BuffersToggle(bang) " {{{
+  let name = eclim#util#EscapeBufferName('[buffers]')
+  if bufwinnr(name) == -1
+    call eclim#common#buffers#Buffers(a:bang)
+  else
+    exec "bdelete " . bufnr(name)
+  endif
+endfunction " }}}
+
+function! eclim#common#buffers#BufferCompare(buffer1, buffer2) " {{{
+  exec 'let attr1 = a:buffer1.' . g:EclimBuffersSort
+  exec 'let attr2 = a:buffer2.' . g:EclimBuffersSort
+  let compare = attr1 == attr2 ? 0 : attr1 > attr2 ? 1 : -1
+  if g:EclimBuffersSortDirection == 'desc'
+    let compare = 0 - compare
+  endif
+  return compare
+endfunction " }}}
+
+function! eclim#common#buffers#Only() " {{{
+  let curwin = winnr()
+  let winnum = 1
+  while winnum <= winnr('$')
+    let fixed = g:EclimOnlyExcludeFixed && (
+      \ getwinvar(winnum, '&winfixheight') == 1 ||
+      \ getwinvar(winnum, '&winfixwidth') == 1)
+    let excluded = bufname(winbufnr(winnum)) =~ g:EclimOnlyExclude
+    if winnum != curwin && !fixed && !excluded
+      if winnum < curwin
+        let curwin -= 1
+      endif
+      exec winnum . 'winc w'
+      close
+      exec curwin . 'winc w'
+      continue
+    endif
+    let winnum += 1
+  endwhile
+endfunction " }}}
+
+function! eclim#common#buffers#GetBuffers(...) " {{{
+  let options = a:0 ? a:1 : {}
+
+  redir => list
+  silent buffers
+  redir END
+
+  let buffers = []
+  let maxfilelength = 0
+  for entry in split(list, '\n')
+    let buffer = {}
+    let buffer.status = substitute(entry, '\s*[0-9]\+\s\+\(.\{-}\)\s\+".*', '\1', '')
+    let buffer.path = substitute(entry, '.\{-}"\(.\{-}\)".*', '\1', '')
+    let buffer.path = fnamemodify(buffer.path, ':p')
+    let buffer.file = fnamemodify(buffer.path, ':p:t')
+    let buffer.dir = fnamemodify(buffer.path, ':p:h')
+    let buffer.bufnr = str2nr(substitute(entry, '\s*\([0-9]\+\).*', '\1', ''))
+    let buffer.lnum = str2nr(substitute(entry, '.*"\s\+\w\+\s\+\(\d\+\)', '\1', ''))
+    call add(buffers, buffer)
+
+    if len(buffer.file) > maxfilelength
+      let maxfilelength = len(buffer.file)
+    endif
+  endfor
+
+  if has_key(options, 'maxfilelength')
+    let options['maxfilelength'] = maxfilelength
+  endif
+
+  return buffers
+endfunction " }}}
+
+function! eclim#common#buffers#TabInit() " {{{
+  let tabnr = 1
+  while tabnr <= tabpagenr('$')
+    let tab_id = gettabvar(tabnr, 'eclim_tab_id')
+    if tab_id == ''
+      let s:eclim_tab_id += 1
+      call settabvar(tabnr, 'eclim_tab_id', s:eclim_tab_id)
+      for bufnr in tabpagebuflist(tabnr)
+        let btab_id = getbufvar(bufnr, 'eclim_tab_id')
+        if btab_id == ''
+          call setbufvar(bufnr, 'eclim_tab_id', s:eclim_tab_id)
+        endif
+      endfor
+    endif
+    let tabnr += 1
+  endwhile
+endfunction " }}}
+
+function! eclim#common#buffers#TabEnter() " {{{
+  if !s:GetTabId()
+    call s:SetTabId()
+  endif
+
+  if g:EclimBuffersDeleteOnTabClose
+    if exists('s:tab_count') && s:tab_count > tabpagenr('$')
+      " delete any buffers associated with the closed tab
+      let buffers = eclim#common#buffers#GetBuffers()
+      for buffer in buffers
+        let eclim_tab_id = getbufvar(buffer.bufnr, 'eclim_tab_id')
+        " don't delete active buffers, just in case the tab has the wrong
+        " eclim_tab_id
+        if eclim_tab_id == s:tab_prev && buffer.status !~ 'a'
+          try
+            exec 'bdelete ' . buffer.bufnr
+          catch /E89/
+            " ignore since it happens when using bd! on the last buffer for
+            " another tab.
+          endtry
+        endif
+      endfor
+    endif
+  endif
+endfunction " }}}
+
+function! eclim#common#buffers#TabLeave() " {{{
+  let s:tab_prev = s:GetTabId()
+  let s:tab_count = tabpagenr('$')
+endfunction " }}}
+
+function! eclim#common#buffers#TabLastOpenIn() " {{{
+  if !buflisted('%')
+    silent! unlet b:eclim_tab_id
+  endif
+
+  if !s:GetTabId()
+    call s:SetTabId()
+  endif
+
+  let tabnr = 1
+  let other_tab = 0
+  let bufnr = bufnr('%')
+  while tabnr <= tabpagenr('$')
+    if tabnr != tabpagenr() &&
+     \ eclim#util#ListContains(tabpagebuflist(tabnr), bufnr)
+      let other_tab = tabnr
+      break
+    endif
+    let tabnr += 1
+  endwhile
+
+  if !exists('b:eclim_tab_id') || !other_tab
+    let b:eclim_tab_id = s:GetTabId()
+  endif
+endfunction " }}}
+
+function! eclim#common#buffers#OpenNextHiddenTabBuffer(current) " {{{
+  let allbuffers = eclim#common#buffers#GetBuffers()
+
+  " build list of buffers open in other tabs to exclude
+  let tabbuffers = []
+  let lasttab = tabpagenr('$')
+  let index = 1
+  while index <= lasttab
+    if index != tabpagenr()
+      for bnum in tabpagebuflist(index)
+        call add(tabbuffers, bnum)
+      endfor
+    endif
+    let index += 1
+  endwhile
+
+  " build list of buffers not open in any window, and last seen on the
+  " current tab.
+  let hiddenbuffers = []
+  for buffer in allbuffers
+    let bnum = buffer.bufnr
+    if bnum != a:current && index(tabbuffers, bnum) == -1 && bufwinnr(bnum) == -1
+      let eclim_tab_id = getbufvar(bnum, 'eclim_tab_id')
+      if eclim_tab_id != '' && eclim_tab_id != t:eclim_tab_id
+        continue
+      endif
+
+      if bnum < a:current
+        call insert(hiddenbuffers, bnum)
+      else
+        call add(hiddenbuffers, bnum)
+      endif
+    endif
+  endfor
+
+  " we found a hidden buffer, so open it
+  if len(hiddenbuffers) > 0
+    exec 'buffer ' . hiddenbuffers[0]
+    doautocmd BufEnter
+    doautocmd BufWinEnter
+    doautocmd BufReadPost
+    return hiddenbuffers[0]
+  endif
+  return 0
+endfunction " }}}
+
+function! s:BufferDelete() " {{{
+  let line = line('.')
+  if line > len(b:eclim_buffers)
+    return
+  endif
+
+  let index = line - 1
+  setlocal modifiable
+  setlocal noreadonly
+  exec line . ',' . line . 'delete _'
+  setlocal nomodifiable
+  setlocal readonly
+  let buffer = b:eclim_buffers[index]
+  call remove(b:eclim_buffers, index)
+
+  let winnr = winnr()
+  " make sure the autocmds are executed in the following order
+  noautocmd exec 'bd ' . buffer.bufnr
+  doautocmd BufDelete
+  doautocmd BufEnter
+  exec winnr . 'winc w'
+endfunction " }}}
+
+function! s:BufferEntryToLine(buffer, filelength) " {{{
+  let line = ''
+  let line .= a:buffer.status =~ '+' ? '+' : ' '
+  let line .= a:buffer.status =~ 'a' ? 'active' : 'hidden'
+  let line .= a:buffer.status =~ '[-=]' ? ' [RO] ' : '      '
+  let line .= a:buffer.file
+
+  let pad = a:filelength - len(a:buffer.file) + 2
+  while pad > 0
+    let line .= ' '
+    let pad -= 1
+  endwhile
+
+  let line .= a:buffer.dir
+  return line
+endfunction " }}}
+
+function! s:BufferOpen(cmd) " {{{
+  let line = line('.')
+  if line > len(b:eclim_buffers)
+    return
+  endif
+
+  let file = bufname(b:eclim_buffers[line - 1].bufnr)
+  let winnr = b:winnr
+  close
+
+  " prevent opening the buffer in a split of a vertical tool window (project
+  " tree, taglist, etc.)
+  if exists('g:VerticalToolBuffers') && has_key(g:VerticalToolBuffers, winbufnr(winnr))
+    let winnr = 1
+    while has_key(g:VerticalToolBuffers, winbufnr(winnr))
+      let winnr += 1
+      if winnr > winnr('$')
+        let winnr -= 1
+        break
+      endif
+    endwhile
+  endif
+
+  exec winnr . 'winc w'
+  call eclim#util#GoToBufferWindowOrOpen(file, a:cmd)
+endfunction " }}}
+
+function! s:GetTabId(...) " {{{
+  let tabnr = a:0 ? a:1 : tabpagenr()
+  " using gettabvar over t:eclim_tab_id because while autocmds are executing,
+  " the tabpagenr() may return the correct tab number, but accessing
+  " t:eclim_tab_id may return the value from the previously focused tab.
+  return gettabvar(tabnr, 'eclim_tab_id')
+endfunction " }}}
+
+function! s:SetTabId(...) " {{{
+  let tabnr = a:0 ? a:1 : tabpagenr()
+  let s:eclim_tab_id += 1
+  " using settabvar for reason explained in s:GetTabId()
+  call settabvar(tabnr, 'eclim_tab_id', s:eclim_tab_id)
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/common/history.vim

@@ -0,0 +1,316 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+let s:command_add = '-command history_add -p "<project>" -f "<file>"'
+let s:command_list = '-command history_list -p "<project>" -f "<file>"'
+let s:command_revision =
+  \ '-command history_revision -p "<project>" -f "<file>" -r <revision>'
+let s:command_clear = '-command history_clear -p "<project>" -f "<file>"'
+" }}}
+
+function! eclim#common#history#AddHistory() " {{{
+  " Adds the current state of the file to the eclipse local history (should be
+  " invoked prior to saving to disk).
+  if !filereadable(expand('%')) || !eclim#project#util#IsCurrentFileInProject(0)
+    return
+  endif
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let command = s:command_add
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  call eclim#Execute(command)
+endfunction " }}}
+
+function! eclim#common#history#History() " {{{
+  " Opens a temporary buffer with a list of local history revisions.
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let command = s:command_list
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let history = eclim#Execute(command)
+  if type(history) != g:LIST_TYPE
+    return
+  endif
+
+  let lines = [file]
+  let revisions = [0]
+  let indent = eclim#util#GetIndent(1)
+  for rev in history
+    call add(lines, indent . rev.datetime . ' (' . rev.delta . ')')
+    call add(revisions, rev.timestamp)
+  endfor
+  call add(lines, '')
+  call eclim#util#TempWindow('[History]', lines)
+
+  setlocal modifiable noreadonly
+  if !g:EclimKeepLocalHistory
+    call append(line('$'),
+      \ '" Note: local history is currently disabled: ' .
+      \ 'g:EclimKeepLocalHistory = ' . g:EclimKeepLocalHistory)
+  endif
+  call append(line('$'), '" use ? to view help')
+  setlocal nomodifiable readonly
+  syntax match Comment /^".*/
+
+  let b:history_revisions = revisions
+  call s:Syntax()
+
+  command! -count=1 HistoryDiffNext call s:DiffNextPrev(1, <count>)
+  command! -count=1 HistoryDiffPrev call s:DiffNextPrev(-1, <count>)
+  augroup eclim_history_window
+    autocmd! BufWinLeave <buffer>
+    autocmd BufWinLeave <buffer>
+      \ delcommand HistoryDiffNext |
+      \ delcommand HistoryDiffPrev
+  augroup END
+  noremap <buffer> <silent> <cr> :call <SID>View()<cr>
+  noremap <buffer> <silent> d :call <SID>Diff()<cr>
+  noremap <buffer> <silent> r :call <SID>Revert()<cr>
+  noremap <buffer> <silent> c :call <SID>Clear(1)<cr>
+
+  " assign to buffer var to get around weird vim issue passing list containing
+  " a string w/ a '<' in it on execution of mapping.
+  let b:history_help = [
+      \ '<cr> - view the entry',
+      \ 'd - diff the file with the version under the cursor',
+      \ 'r - revert the file to the version under the cursor',
+      \ 'c - clear the history',
+      \ ':HistoryDiffNext - diff the file with the next version in the history',
+      \ ':HistoryDiffPrev - diff the file with the previous version in the history',
+    \ ]
+  nnoremap <buffer> <silent> ?
+    \ :call eclim#help#BufferHelp(b:history_help, 'vertical', 50)<cr>
+endfunction " }}}
+
+function! eclim#common#history#HistoryClear(bang) " {{{
+  " Clear the history for the current file.
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  call s:Clear(a:bang == '', expand('%:p'))
+endfunction " }}}
+
+function s:View(...) " {{{
+  " View the contents of the revision under the cursor.
+  if line('.') == 1 || line('.') > len(b:history_revisions)
+    return
+  endif
+
+  let current = b:filename
+  let entry = line('.') - 1
+  let revision = b:history_revisions[entry]
+  if eclim#util#GoToBufferWindow(current)
+    let filetype = &ft
+    let project = eclim#project#util#GetCurrentProjectName()
+    let file = eclim#project#util#GetProjectRelativeFilePath()
+    let command = s:command_revision
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+    let command = substitute(command, '<revision>', revision, '')
+    let result = eclim#Execute(command)
+    if result == "0"
+      return
+    endif
+
+    let cmd = len(a:000) > 0 ? a:000[0] : 'split'
+    call eclim#util#GoToBufferWindowOrOpen(
+      \ current . '_' . revision, 'keepalt ' . cmd)
+
+    setlocal modifiable
+    setlocal noreadonly
+
+    let temp = tempname()
+    call writefile(split(result, '\n'), temp)
+    try
+      silent 1,$delete _
+      silent read ++edit `=temp`
+      silent 1,1delete _
+    finally
+      call delete(temp)
+    endtry
+
+    exec 'setlocal filetype=' . filetype
+    setlocal nomodified
+    setlocal readonly
+    setlocal nomodifiable
+    setlocal noswapfile
+    setlocal nobuflisted
+    setlocal buftype=nofile
+    setlocal bufhidden=wipe
+    doautocmd BufReadPost
+
+    call s:HighlightEntry(entry)
+
+    return 1
+  else
+    call eclim#util#EchoWarning('Target file is no longer open.')
+  endif
+endfunction " }}}
+
+function s:Diff() " {{{
+  " Diff the contents of the revision under the cursor against the current
+  " contents.
+  let hist_buf = bufnr('%')
+  let winend = winnr('$')
+  let winnum = 1
+  while winnum <= winend
+    let bufnr = winbufnr(winnum)
+    if getbufvar(bufnr, 'history_diff') != ''
+      exec bufnr . 'bd'
+      continue
+    endif
+    let winnum += 1
+  endwhile
+  call eclim#util#GoToBufferWindow(hist_buf)
+
+  let current = b:filename
+  let orien = g:EclimHistoryDiffOrientation == 'horizontal' ? '' : 'vertical'
+  if s:View(orien . ' below split')
+    let b:history_diff = 1
+    diffthis
+    augroup history_diff
+      autocmd! BufWinLeave <buffer>
+      call eclim#util#GoToBufferWindowRegister(current)
+      autocmd BufWinLeave <buffer> diffoff
+    augroup END
+
+    call eclim#util#GoToBufferWindow(current)
+    diffthis
+  endif
+endfunction " }}}
+
+function s:DiffNextPrev(dir, count) " {{{
+  let winnr = winnr()
+  if eclim#util#GoToBufferWindow('[History]')
+    let num = v:count > 0 ? v:count : a:count
+    let cur = exists('b:history_current_entry') ? b:history_current_entry : 0
+    let index = cur + (a:dir * num)
+    if index < 0 || index > len(b:history_revisions)
+      call eclim#util#EchoError('Operation exceeds history stack range.')
+      exec winnr . 'winc w'
+      return
+    endif
+    call cursor(index + 1, 0)
+    call s:Diff()
+  endif
+endfunction " }}}
+
+function s:Revert() " {{{
+  " Revert the file to the revision under the cursor.
+  if line('.') == 1 || line('.') > len(b:history_revisions)
+    return
+  endif
+
+  let current = b:filename
+  let revision = b:history_revisions[line('.') - 1]
+  if eclim#util#GoToBufferWindow(current)
+    let project = eclim#project#util#GetCurrentProjectName()
+    let file = eclim#project#util#GetProjectRelativeFilePath()
+    let command = s:command_revision
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+    let command = substitute(command, '<revision>', revision, '')
+    let result = eclim#Execute(command)
+    if result == "0"
+      return
+    endif
+
+    let ff = &ff
+    let temp = tempname()
+    call writefile(split(result, '\n'), temp)
+    try
+      silent 1,$delete _
+      silent read ++edit `=temp`
+      silent 1,1delete _
+    finally
+      call delete(temp)
+    endtry
+
+    if ff != &ff
+      call eclim#util#EchoWarning(
+        \ "Warning: the file format is being reverted from '" . ff . "' to '" .
+        \ &ff . "'. Using vim's undo will not restore the previous format so " .
+        \ "if you choose to undo the reverting of this file, you will need to " .
+        \ "manually set the file format back to " . ff . " (set ff=" . ff . ").")
+    endif
+  endif
+endfunction " }}}
+
+function s:Clear(prompt, ...) " {{{
+  " Optional args:
+  "   filename
+  let response = 1
+  if a:prompt
+    let response = eclim#util#PromptConfirm(
+      \ 'Clear local history?', g:EclimHighlightInfo)
+  endif
+
+  if response == 1
+    let filename = len(a:000) > 0 ? a:000[0] : b:filename
+    let current = eclim#project#util#GetProjectRelativeFilePath(filename)
+    let project = eclim#project#util#GetCurrentProjectName()
+    let command = s:command_clear
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', current, '')
+    let result = eclim#Execute(command)
+    if result == "0"
+      return
+    endif
+
+    if filename != expand('%:p')
+      quit
+    endif
+    call eclim#util#Echo(result)
+  endif
+endfunction " }}}
+
+function! s:Syntax() " {{{
+  set ft=eclim_history
+  hi link HistoryFile Identifier
+  hi link HistoryCurrentEntry Constant
+  syntax match HistoryFile /.*\%1l.*/
+  syntax match Comment /^".*/
+endfunction " }}}
+
+function s:HighlightEntry(index) " {{{
+  let winnr = winnr()
+  if eclim#util#GoToBufferWindow('[History]')
+    let b:history_current_entry = a:index
+    try
+      " forces reset of syntax
+      call s:Syntax()
+      exec 'syntax match HistoryCurrentEntry /.*\%' . (a:index + 1) . 'l.*/'
+    finally
+      exec winnr . 'winc w'
+    endtry
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/common/largefile.vim

@@ -0,0 +1,58 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   Initially based on vimscript 1506
+"
+" License:
+"
+" Copyright (C) 2005 - 2012  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Settings {{{
+let s:file_size = g:EclimLargeFileSize * 1024 * 1024
+let s:events = ['BufRead', 'CursorHold', 'FileType']
+" }}}
+
+function! eclim#common#largefile#InitSettings() " {{{
+  let file = expand("<afile>")
+  let size = getfsize(file)
+  if size >= s:file_size || size == -2
+    if !exists('b:save_events')
+      let b:save_events = &eventignore
+      call s:ApplySettings()
+      setlocal noswapfile nowrap bufhidden=unload
+      autocmd eclim_largefile BufEnter,BufWinEnter <buffer> call <SID>ApplySettings()
+      autocmd eclim_largefile BufLeave,BufWinLeave <buffer> call <SID>RevertSettings()
+    endif
+  endif
+endfunction " }}}
+
+function! s:ApplySettings() " {{{
+  let &eventignore=join(s:events, ',')
+  if !exists('b:largefile_notified')
+    let b:largefile_notified = 1
+    call eclim#util#Echo('Note: Large file settings applied.')
+  endif
+endfunction " }}}
+
+function! s:RevertSettings() " {{{
+  if exists('b:save_events')
+    let &eventignore=b:save_events
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/common/license.vim

@@ -0,0 +1,87 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2012  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+  let s:year = exists('*strftime') ? strftime('%Y') : '2009'
+" }}}
+
+" GetLicense() {{{
+" Retrieves the file containing the license text.
+function! eclim#common#license#GetLicense()
+  let file = eclim#project#util#GetProjectSetting('org.eclim.project.copyright')
+  if type(file) == g:NUMBER_TYPE
+    return
+  elseif file == ''
+    call eclim#util#EchoWarning(
+      \ "Project setting 'org.eclim.project.copyright' has not been supplied.")
+    return
+  endif
+
+  let file = eclim#project#util#GetCurrentProjectRoot() . '/' . file
+  if !filereadable(file)
+    return
+  endif
+  return file
+endfunction " }}}
+
+" License(pre, post, mid) {{{
+" Retrieves the license configured license and applies the specified prefix
+" and postfix as the lines before and after the license and uses 'mid' as the
+" prefix for every line.
+" Returns the license as a list of strings.
+function! eclim#common#license#License(pre, post, mid)
+  let file = eclim#common#license#GetLicense()
+  if type(file) == g:NUMBER_TYPE && file == 0
+    return ''
+  endif
+
+  let contents = readfile(file)
+  if a:mid != ''
+    call map(contents, 'a:mid . v:val')
+  endif
+
+  if a:pre != ''
+    call insert(contents, a:pre)
+  endif
+
+  if a:post != ''
+    call add(contents, a:post)
+  endif
+
+  call map(contents, "substitute(v:val, '${year}', s:year, 'g')")
+
+  let author = eclim#project#util#GetProjectSetting('org.eclim.user.name')
+  if type(author) == g:STRING_TYPE && author != ''
+    call map(contents, "substitute(v:val, '${author}', author, 'g')")
+  endif
+
+  let email = eclim#project#util#GetProjectSetting('org.eclim.user.email')
+  if type(email) == g:STRING_TYPE && email != ''
+    call map(contents, "substitute(v:val, '${email}', email, 'g')")
+  endif
+  call map(contents, "substitute(v:val, '\\s\\+$', '', '')")
+
+  return contents
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/common/locate.vim

@@ -0,0 +1,643 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Global Variables {{{
+let g:eclim_locate_default_updatetime = &updatetime
+
+" disable autocomplpop in the locate prompt
+if exists('g:acp_behavior')
+  let g:acp_behavior['locate_prompt'] = []
+endif
+
+" }}}
+
+" Script Variables {{{
+let s:command_locate = '-command locate_file -s "<scope>"'
+let s:scopes = [
+    \ 'project',
+    \ 'workspace',
+    \ 'buffers',
+    \ 'quickfix',
+  \ ]
+
+let s:help = [
+    \ '<esc> - close the locate prompt + results',
+    \ '<tab>, <down> - select the next file',
+    \ '<s-tab>, <up> - select the previous file',
+    \ '<cr> - open selected file w/ default action',
+    \ '<c-e> - open with :edit',
+    \ '<c-s> - open in a split window',
+    \ '<c-t> - open in a new tab',
+    \ '<c-l> - choose search scope',
+    \ '<c-h> - toggle help buffer',
+  \ ]
+" }}}
+
+function! eclim#common#locate#LocateFile(action, file, ...) " {{{
+  " Locates a file using the specified action for opening the file when found.
+  "   action - '' (use user default), 'split', 'edit', etc.
+  "   file - 'somefile.txt',
+  "          '', (kick off completion mode),
+  "          '<cursor>' (locate the file under the cursor)
+  "   scope - optional scope to search in (project, workspace, buffers, etc.)
+  let project = eclim#project#util#GetCurrentProjectName()
+  let scope = a:0 > 0 ? a:1 : g:EclimLocateFileScope
+
+  if !eclim#util#ListContains(s:scopes, scope) &&
+   \ !eclim#util#ListContains(g:EclimLocateUserScopes, scope)
+    call eclim#util#EchoWarning('Unrecognized scope: ' . scope)
+    return
+  endif
+
+  if scope == 'project' && (project == '' || !eclim#EclimAvailable(0))
+    let scope = g:EclimLocateFileNonProjectScope
+  endif
+
+  let workspace = ''
+  if scope == 'project' || scope == 'workspace'
+    let instance = eclim#client#nailgun#ChooseEclimdInstance()
+    if type(instance) != g:DICT_TYPE
+      return
+    endif
+
+    let workspace = instance.workspace
+    if !eclim#PingEclim(0, workspace)
+      call eclim#util#EchoError('Unable to connect to eclimd.')
+      return
+    endif
+  endif
+
+  let results = []
+  let action = a:action
+  if action == ''
+    let action = g:EclimLocateFileDefaultAction
+  endif
+
+  let file = a:file
+  if file == ''
+    call s:LocateFileCompletionInit(action, scope, project, workspace)
+    return
+  elseif file == '<cursor>'
+    let file = eclim#util#GrabUri()
+
+    " if grabbing a relative url, remove any anchor info or query parameters
+    let file = substitute(file, '[#?].*', '', '')
+  endif
+
+  let name = fnamemodify(file, ':t')
+  if name == ''
+    call eclim#util#Echo('Please supply more than just a directory name.')
+    return
+  endif
+
+  let pattern = file
+  let pattern = s:LocateFileConvertPattern(pattern, 0)
+  let pattern = '[^/]*' . pattern
+  try
+    let b:workspace = workspace
+    let b:project = project
+    let results = s:LocateFileFunction(scope)(pattern)
+  finally
+    unlet! b:workspace
+    unlet! b:project
+  endtry
+
+  call map(results, "v:val.path")
+
+  let result = ''
+  " One result.
+  if len(results) == 1
+    let result = results[0]
+
+  " More than one result.
+  elseif len(results) > 1
+    let message = "Multiple results, choose the file to open"
+    let response = eclim#util#PromptList(message, results, g:EclimHighlightInfo)
+    if response == -1
+      return
+    endif
+
+    let result = results[response]
+
+  " No results
+  else
+    call eclim#util#Echo('Unable to locate file pattern "' . file . '".')
+    return
+  endif
+
+  if has('win32unix')
+    let result = eclim#cygwin#CygwinPath(result)
+  endif
+
+  call eclim#util#GoToBufferWindowOrOpen(eclim#util#Simplify(result), action)
+  call eclim#util#Echo(' ')
+endfunction " }}}
+
+function! eclim#common#locate#LocateFileCompletion() " {{{
+  let line = getline('.')
+  if line !~ '^> '
+    call setline(1, substitute(line, '^>\?\s*', '> \1', ''))
+    call cursor(1, 3)
+    let line = getline('.')
+  endif
+
+  let completions = []
+  let display = []
+  let name = substitute(line, '^>\s*', '', '')
+  if name !~ '^\s*$'
+    let pattern = name
+    let pattern = s:LocateFileConvertPattern(pattern, g:EclimLocateFileFuzzy)
+
+    let results = s:LocateFileFunction(b:scope)(pattern)
+    if !empty(results)
+      for result in results
+        let rel = eclim#util#Simplify(get(result, 'projectPath', result.path))
+        let dict = {'word': result.name, 'menu': rel, 'info': result.path}
+        call add(completions, dict)
+        call add(display, result.name . '  ' . rel)
+      endfor
+    endif
+  endif
+  let b:completions = completions
+  let winnr = winnr()
+  noautocmd exec bufwinnr(b:results_bufnum) . 'winc w'
+  setlocal modifiable
+  1,$delete _
+  call append(1, display)
+  1,1delete _
+  setlocal nomodifiable
+  exec winnr . 'winc w'
+
+  " part of bad hack for gvim on windows
+  let b:start_selection = 1
+
+  call s:LocateFileSelection(1)
+endfunction " }}}
+
+function! eclim#common#locate#LocateFileClose() " {{{
+  if bufname(bufnr('%')) !~ '^\[Locate.*\]$'
+    let bufnr = bufnr('\[Locate in *\]')
+    let winnr = bufwinnr(bufnr)
+    if winnr != -1
+      let curbuf = bufnr('%')
+      exec winnr . 'winc w'
+      try
+        exec 'bw ' . b:results_bufnum
+        bw
+        autocmd! locate_file_init
+        stopinsert
+      finally
+        exec bufwinnr(curbuf) . 'winc w'
+      endtry
+    endif
+  endif
+endfunction " }}}
+
+function! s:LocateFileCompletionInit(action, scope, project, workspace) " {{{
+  let file = expand('%')
+  let bufnum = bufnr('%')
+  let winrestcmd = winrestcmd()
+
+  topleft 12split [Locate\ Results]
+  set filetype=locate_results
+  setlocal nonumber nowrap
+  setlocal noswapfile nobuflisted
+  setlocal buftype=nofile bufhidden=delete
+
+  let results_bufnum = bufnr('%')
+
+  let locate_in = (a:scope == 'project' ? a:project : a:scope)
+  exec 'topleft 1split ' . escape('[Locate in ' . locate_in . ']', ' -')
+  setlocal modifiable
+  call setline(1, '> ')
+  call cursor(1, col('$'))
+  set filetype=locate_prompt
+  syntax match Keyword /^>/
+  setlocal winfixheight
+  setlocal nonumber
+  setlocal nolist
+  setlocal noswapfile nobuflisted
+  setlocal buftype=nofile bufhidden=delete
+
+  let b:bufnum = bufnum
+  let b:project = a:project
+  let b:workspace = a:workspace
+  let b:scope = a:scope
+  let b:results_bufnum = results_bufnum
+  let b:help_bufnum = 0
+  let b:selection = 1
+  let b:winrestcmd = winrestcmd
+
+  set updatetime=300
+
+  augroup locate_file_init
+    autocmd!
+    autocmd BufEnter <buffer> nested startinsert! | let &updatetime = 300
+    autocmd BufLeave \[Locate*\]
+      \ call eclim#util#DelayedCommand('call eclim#common#locate#LocateFileClose()')
+    exec 'autocmd InsertLeave <buffer> ' .
+      \ 'let &updatetime = g:eclim_locate_default_updatetime | ' .
+      \ 'doautocmd BufWinLeave | bw | ' .
+      \ 'doautocmd BufWinLeave | bw ' . b:results_bufnum . ' | ' .
+      \ 'call eclim#util#GoToBufferWindow(' .  b:bufnum . ') | ' .
+      \ 'doautocmd BufEnter | ' .
+      \ 'doautocmd WinEnter | ' .
+      \ winrestcmd
+    exec 'autocmd WinEnter <buffer=' . b:results_bufnum .'> '
+      \ 'exec bufwinnr(' . bufnr('%') . ') "winc w"'
+  augroup END
+
+  " enable completion after user starts typing
+  call s:LocateFileCompletionAutocmdDeferred()
+
+  imap <buffer> <silent> <tab> <c-r>=<SID>LocateFileSelection("n")<cr>
+  imap <buffer> <silent> <c-j> <c-r>=<SID>LocateFileSelection("n")<cr>
+  imap <buffer> <silent> <down> <c-r>=<SID>LocateFileSelection("n")<cr>
+  imap <buffer> <silent> <s-tab> <c-r>=<SID>LocateFileSelection("p")<cr>
+  imap <buffer> <silent> <up> <c-r>=<SID>LocateFileSelection("p")<cr>
+  imap <buffer> <silent> <c-k> <c-r>=<SID>LocateFileSelection("p")<cr>
+  exec 'imap <buffer> <silent> <cr> ' .
+    \ '<c-r>=<SID>LocateFileSelect("' . a:action . '")<cr>'
+  imap <buffer> <silent> <c-e> <c-r>=<SID>LocateFileSelect('edit')<cr>
+  imap <buffer> <silent> <c-s> <c-r>=<SID>LocateFileSelect('split')<cr>
+  imap <buffer> <silent> <c-t> <c-r>=<SID>LocateFileSelect("tablast \| tabnew")<cr>
+  imap <buffer> <silent> <c-l> <c-r>=<SID>LocateFileChangeScope()<cr>
+  imap <buffer> <silent> <c-h> <c-r>=<SID>LocateFileHelp()<cr>
+
+  startinsert!
+endfunction " }}}
+
+function! s:LocateFileCompletionAutocmd() " {{{
+  augroup locate_file
+    autocmd!
+    autocmd CursorHoldI <buffer> call eclim#common#locate#LocateFileCompletion()
+  augroup END
+endfunction " }}}
+
+function! s:LocateFileCompletionAutocmdDeferred() " {{{
+  augroup locate_file
+    autocmd!
+    autocmd CursorMovedI <buffer> call <SID>LocateFileCompletionAutocmd()
+  augroup END
+endfunction " }}}
+
+function! s:LocateFileSelection(sel) " {{{
+  " pause completion while tabbing though results
+  augroup locate_file
+    autocmd!
+  augroup END
+
+  let sel = a:sel
+  let prev_sel = b:selection
+
+  " bad hack for gvim on windows
+  let start_sel = b:start_selection
+  let double_defer = 0
+  if sel =~ '^[np]$' && (has('win32') || has('win64'))
+    let double_defer = b:start_selection == 1
+    let b:start_selection = 0
+  endif
+
+  let winnr = winnr()
+  noautocmd exec bufwinnr(b:results_bufnum) . 'winc w'
+
+  if sel == 'n'
+    let sel = prev_sel < line('$') ? prev_sel + 1 : 1
+  elseif sel == 'p'
+    let sel = prev_sel > 1 ? prev_sel - 1 : line('$')
+  endif
+
+  syntax clear
+  exec 'syntax match PmenuSel /\%' . sel . 'l.*/'
+  exec 'call cursor(' . sel . ', 1)'
+  let save_scrolloff = &scrolloff
+  let &scrolloff = 5
+  normal! zt
+  let &scrolloff = save_scrolloff
+
+  exec winnr . 'winc w'
+
+  exec 'let b:selection = ' . sel
+
+  if double_defer
+    augroup locate_file
+      autocmd!
+      autocmd CursorMovedI <buffer> call <SID>LocateFileCompletionAutocmdDeferred()
+    augroup END
+  else
+    call s:LocateFileCompletionAutocmdDeferred()
+  endif
+
+  return ''
+endfunction " }}}
+
+function! s:LocateFileSelect(action) " {{{
+  if exists('b:completions') && !empty(b:completions)
+    let &updatetime = g:eclim_locate_default_updatetime
+
+    let file = eclim#util#Simplify(b:completions[b:selection - 1].info)
+    if has('win32unix')
+      let file = eclim#cygwin#CygwinPath(file)
+    endif
+
+    let bufnum = b:bufnum
+    let winrestcmd = b:winrestcmd
+
+    " close locate windows
+    exec 'bdelete ' . b:results_bufnum
+    exec 'bdelete ' . bufnr('%')
+
+    " reset windows to pre-locate sizes
+    exec winrestcmd
+
+    " open the selected result
+    call eclim#util#GoToBufferWindow(bufnum)
+    call eclim#util#GoToBufferWindowOrOpen(file, a:action)
+    call feedkeys("\<esc>", 'n')
+    doautocmd WinEnter
+  endif
+  return ''
+endfunction " }}}
+
+function! s:LocateFileChangeScope() " {{{
+  if b:help_bufnum && bufexists(b:help_bufnum)
+    exec 'bdelete ' . b:help_bufnum
+  endif
+
+  let bufnr = bufnr('%')
+  let winnr = winnr()
+
+  " trigger [Locate] buffer's BufLeave autocmd before we leave the buffer
+  doautocmd BufLeave
+
+  noautocmd exec bufwinnr(b:results_bufnum) . 'winc w'
+  silent noautocmd exec '50vnew [Locate\ Scope]'
+
+  let b:locate_bufnr = bufnr
+  let b:locate_winnr = winnr
+  stopinsert
+  setlocal modifiable
+  call append(1, s:scopes + g:EclimLocateUserScopes)
+  1,1delete _
+  call append(line('$'),
+    \ ['', '" <cr> - select a scope', '" <c-c>, <c-l>, or q - cancel'])
+  syntax match Comment /^".*/
+  setlocal nomodifiable
+  setlocal winfixheight
+  setlocal nonumber
+  setlocal nolist
+  setlocal noswapfile nobuflisted
+  setlocal buftype=nofile bufhidden=delete
+
+  nnoremap <buffer> <silent> <cr> :call <SID>ChooseScope()<cr>
+  nnoremap <buffer> <silent> q :call <SID>CloseScopeChooser()<cr>
+  nnoremap <buffer> <silent> <c-c> :call <SID>CloseScopeChooser()<cr>
+  nnoremap <buffer> <silent> <c-l> :call <SID>CloseScopeChooser()<cr>
+
+  autocmd BufLeave <buffer> call <SID>CloseScopeChooser()
+
+  return ''
+endfunction " }}}
+
+function! s:ChooseScope() " {{{
+  let scope = getline('.')
+  if scope =~ '^"\|^\s*$'
+    return
+  endif
+
+  let project = ''
+  let locate_in = scope
+
+  if scope == 'project'
+    let project = ''
+    let names = eclim#project#util#GetProjectNames()
+    let prompt = 'Choose a project (ctrl-c to cancel): '
+    while project == ''
+      let project = input(
+        \ prompt, '', 'customlist,eclim#project#util#CommandCompleteProject')
+      if project == ''
+        echo ''
+        return
+      endif
+
+      if !eclim#util#ListContains(names, project)
+        let prompt = "Project '" . project . "' not found (ctrl-c to cancel): "
+        let project = ''
+      endif
+    endwhile
+    let locate_in = project
+    let workspace = eclim#project#util#GetProjectWorkspace(project)
+    if type(workspace) == g:LIST_TYPE
+      let workspaces = workspace
+      unlet workspace
+      let response = eclim#util#PromptList(
+        \ 'Muliple workspaces found, please choose the target workspace',
+        \ workspaces, g:EclimHighlightInfo)
+
+      " user cancelled, error, etc.
+      if response < 0
+        return
+      endif
+
+      let workspace = workspaces[response]
+    endif
+
+  elseif scope == 'workspace'
+    let project = ''
+    let instance = eclim#client#nailgun#ChooseEclimdInstance()
+    if type(instance) != g:DICT_TYPE
+      return
+    endif
+    let workspace = instance.workspace
+  else
+    let workspace = ''
+  endif
+
+  call s:CloseScopeChooser()
+
+  let b:scope = scope
+  let b:project = project
+  let b:workspace = workspace != '' ? workspace : b:workspace
+
+  exec 'file ' . escape('[Locate in ' . locate_in . ']', ' ')
+
+  call eclim#common#locate#LocateFileCompletion()
+endfunction " }}}
+
+function! s:CloseScopeChooser() " {{{
+  let winnum = b:locate_winnr
+  bwipeout
+  exec winnum . 'winc w'
+
+  " hack to make :q work like the other close mappings
+  doautocmd BufEnter
+  " if we end up in a non-Locate window, make sure everything is as it should
+  " be (a hack for the above hack).
+  augroup locate_file_chooser_hack
+    autocmd!
+    autocmd BufEnter *
+      \ if bufname('%') !~ '^\[Locate in .*\]$' |
+      \   call eclim#common#locate#LocateFileClose() |
+      \ endif |
+      \ autocmd! locate_file_chooser_hack
+  augroup END
+endfunction " }}}
+
+function! s:LocateFileHelp() " {{{
+  let winnr = winnr()
+  noautocmd exec bufwinnr(b:results_bufnum) . 'winc w'
+  let help_bufnum = eclim#help#BufferHelp(s:help, 'vertical', 50)
+  exec winnr . 'winc w'
+  let b:help_bufnum = help_bufnum
+
+  return ''
+endfunction " }}}
+
+function! s:LocateFileConvertPattern(pattern, fuzzy) " {{{
+  let pattern = a:pattern
+
+  if a:fuzzy
+    let pattern = '.*' . substitute(pattern, '\(.\)', '\1.*?', 'g')
+    let pattern = substitute(pattern, '\.\([^*]\)', '\\.\1', 'g')
+  else
+    " if the user supplied a path, prepend a '.*/' to it so that they don't need
+    " to type full paths to match.
+    if pattern =~ '.\+/'
+      let pattern = '.*/' . pattern
+    endif
+    let pattern = substitute(pattern, '\*\*', '.*', 'g')
+    let pattern = substitute(pattern, '\(^\|\([^.]\)\)\*', '\1[^/]*?', 'g')
+    let pattern = substitute(pattern, '\.\([^*]\)', '\\.\1', 'g')
+    "let pattern = substitute(pattern, '\([^*]\)?', '\1.', 'g')
+    let pattern .= '.*'
+  endif
+
+  return pattern
+endfunction " }}}
+
+function! s:LocateFileFunction(scope) " {{{
+  if eclim#util#ListContains(s:scopes, a:scope)
+    return function('s:LocateFile_' . a:scope)
+  endif
+  return function('LocateFile_' . a:scope)
+endfunction " }}}
+
+function! s:LocateFileCommand(pattern) " {{{
+  let command = s:command_locate
+  if g:EclimLocateFileCaseInsensitive == 'always' ||
+   \ (a:pattern !~# '[A-Z]' && g:EclimLocateFileCaseInsensitive != 'never')
+    let command .= ' -i'
+  endif
+  let command .= ' -p "' . a:pattern . '"'
+  return command
+endfunction " }}}
+
+function! s:LocateFile_workspace(pattern) " {{{
+  let command = substitute(s:LocateFileCommand(a:pattern), '<scope>', 'workspace', '')
+  let results = eclim#Execute(command, {'workspace': b:workspace})
+  if type(results) != g:LIST_TYPE
+    return []
+  endif
+  return results
+endfunction " }}}
+
+function! s:LocateFile_project(pattern) " {{{
+  let command = substitute(s:LocateFileCommand(a:pattern), '<scope>', 'project', '')
+  let command .= ' -n "' . b:project . '"'
+  let results = eclim#Execute(command, {'workspace': b:workspace})
+  if type(results) != g:LIST_TYPE
+    return []
+  endif
+  return results
+endfunction " }}}
+
+function! s:LocateFile_buffers(pattern) " {{{
+  redir => list
+  silent exec 'buffers'
+  redir END
+
+  let buffers = map(split(list, '\n'),
+    \ "substitute(v:val, '.\\{-}\"\\(.\\{-}\\)\".*', '\\1', '')")
+  if a:pattern =~ '/'
+    let buffers = map(buffers, "fnamemodify(v:val, ':p')")
+  endif
+
+  if len(buffers) > 0
+    let tempfile = substitute(tempname(), '\', '/', 'g')
+    call writefile(buffers, tempfile)
+    try
+      return eclim#common#locate#LocateFileFromFileList(a:pattern, tempfile)
+    finally
+      call delete(tempfile)
+    endtry
+  endif
+  return []
+endfunction " }}}
+
+function! s:LocateFile_quickfix(pattern) " {{{
+  let buffers = []
+  let prev = ''
+  for entry in getqflist()
+    let name = bufname(entry.bufnr)
+    if a:pattern =~ '/'
+      let name = fnamemodify(name, ':p')
+    endif
+    if name != prev
+      call add(buffers, name)
+      let prev = name
+    endif
+  endfor
+
+  if len(buffers) > 0
+    let tempfile = substitute(tempname(), '\', '/', 'g')
+    call writefile(buffers, tempfile)
+    try
+      return eclim#common#locate#LocateFileFromFileList(a:pattern, tempfile)
+    finally
+      call delete(tempfile)
+    endtry
+  endif
+  return []
+endfunction " }}}
+
+function! eclim#common#locate#LocateFileFromFileList(pattern, file) " {{{
+  let file = a:file
+  if has('win32unix')
+    let file = eclim#cygwin#WindowsPath(file)
+  endif
+  if eclim#EclimAvailable(0)
+    let command = substitute(s:LocateFileCommand(a:pattern), '<scope>', 'list', '')
+    let command .= ' -f "' . file . '"'
+    let results = eclim#Execute(command, {'workspace': b:workspace})
+    if type(results) != g:LIST_TYPE
+      return []
+    endif
+  else
+    let results = []
+    for result in readfile(file)
+      call add(results, {'name': fnamemodify(result, ':t'), 'path': result})
+    endfor
+  endif
+
+  return results
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/common/template.vim

@@ -0,0 +1,237 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2012  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Global Variables {{{
+if !exists("g:EclimTemplateDir")
+  let g:EclimTemplateDir = g:EclimBaseDir . '/template'
+endif
+if !exists("g:EclimTemplateExtension")
+  let g:EclimTemplateExtension = '.vim'
+endif
+if !exists("g:EclimTemplateIgnore")
+  let g:EclimTemplateIgnore = []
+endif
+" }}}
+
+" Script Variables {{{
+let s:quote = "['\"]"
+let s:tag_regex =
+  \ '<vim:[a-zA-Z]\+\(\s\+[a-zA-Z]\+\s*=\s*' . s:quote . '.*' . s:quote . '\)\?\s*/>'
+let s:tagname_regex = '.\{-}<vim:\([a-zA-Z]\+\).*'
+" }}}
+
+" Template() {{{
+" Main method for finding and executing the template.
+function! eclim#common#template#Template()
+  " allow some plugins to disable templates temporarily
+  if exists('g:EclimTemplateTempIgnore') && g:EclimTemplateTempIgnore
+    return
+  endif
+
+  " ignore certain file patterns
+  for ignore in g:EclimTemplateIgnore
+    if expand('%') =~ ignore
+      return
+    endif
+  endfor
+
+  let template = s:FindTemplate()
+  if template != ''
+    let lines = readfile(template)
+    call s:ExecuteTemplate(lines)
+    1,1delete _
+  endif
+endfunction " }}}
+
+" s:FindTemplate() {{{
+" Finds the template file and returns the location.
+function! s:FindTemplate()
+  let templatesDir = expand(g:EclimTemplateDir)
+  if !isdirectory(templatesDir)
+    call eclim#util#EchoDebug(
+      \ 'Template dir not found (g:EclimTemplateDir): ' . templatesDir)
+    return ''
+  endif
+
+  let filename = expand('%:t')
+  let ext = ""
+
+  " template equal to the filename
+  if filereadable(templatesDir . '/' . filename . g:EclimTemplateExtension)
+    return templatesDir . '/' . filename . g:EclimTemplateExtension
+  endif
+
+  " template pattern
+  let templates = globpath(templatesDir, '*' . g:EclimTemplateExtension)
+  for template in split(templates, '\n')
+    " remove path info
+    let temp_template = substitute(template, '.*[/\\]', '', '')
+    if g:EclimTemplateExtension != ''
+      let temp_template =
+        \ strpart(temp_template, 0, stridx(temp_template, g:EclimTemplateExtension))
+    endif
+
+    while stridx(temp_template, '.') != -1
+      let ext = strpart(temp_template, stridx(temp_template, '.'))
+      let temp_template = strpart(temp_template, 0, stridx(temp_template, '.'))
+      if filename =~ '.*' . temp_template . '.*' . ext
+        return template
+      endif
+    endwhile
+  endfor
+
+  " template equal to file extension
+  if stridx(filename, '.') > 0
+    let ext = strpart(filename, stridx(filename, '.'))
+    while stridx(ext, '.') != -1
+      let ext = strpart(ext, stridx(ext, '.') + 1)
+      if filereadable(templatesDir . '/' . ext . g:EclimTemplateExtension)
+        return templatesDir . '/' . ext . g:EclimTemplateExtension
+      endif
+    endwhile
+  endif
+
+  " template equal to file type
+  if filereadable(templatesDir . '/' . &ft . g:EclimTemplateExtension)
+    return templatesDir . '/' . &ft . g:EclimTemplateExtension
+  endif
+
+  return ''
+endfunction " }}}
+
+" s:ExecuteTemplate(lines) {{{
+" Executes any logic in the supplied lines and appends those lines to the
+" current file.
+function! s:ExecuteTemplate(lines)
+  for line in a:lines
+    if line =~ s:tag_regex
+      let tag = substitute(line, s:tagname_regex, '\1', '')
+      call s:ExecuteTemplate(s:Process_{tag}(line))
+    else
+      call append(line('$'), line)
+    endif
+  endfor
+endfunction " }}}
+
+" s:EvaluateExpression(expression) {{{
+" Evaluates the supplied expression.
+function! s:EvaluateExpression(expression)
+  exec "return " . a:expression
+endfunction " }}}
+
+" s:GetAttribute(line, tag, attribute, fail) {{{
+" Gets the an attribute value.
+function! s:GetAttribute(line, tag, attribute, fail)
+  let attribute = substitute(a:line,
+    \ '.\{-}<vim:' . a:tag . '.\{-}\s\+' . a:attribute .
+      \ '\s*=\s*\(' . s:quote . '\)\(.\{-}\)\1.*/>.*',
+    \ '\2', '')
+
+  if attribute == a:line
+    if a:fail
+      call s:TemplateError(
+        \ a:line, "syntax error - missing '" . a:attribute . "' attribute")
+    endif
+    return ""
+  endif
+  return attribute
+endfunction " }}}
+
+" s:TemplateError(line, message) {{{
+" Echos an error message to the user.
+function! s:TemplateError(line, message)
+  call eclim#util#EchoError("Template error, line " . a:line . ": " . a:message)
+endfunction " }}}
+
+" s:Process_var(line) {{{
+" Process <vim:var/> tags.
+function! s:Process_var(line)
+  let name = expand(s:GetAttribute(a:line, 'var', 'name', 1))
+  let value = expand(s:GetAttribute(a:line, 'var', 'value', 1))
+
+  exec "let " . name . " = \"" .  s:EvaluateExpression(value) . "\""
+
+  return []
+endfunction " }}}
+
+" s:Process_import(line) {{{
+" Process <vim:import/> tags.
+function! s:Process_import(line)
+  let resource = expand(s:GetAttribute(a:line, 'import', 'resource', 1))
+  if resource !~ '^/\'
+    let resource = expand(g:EclimTemplateDir . '/' . resource)
+  endif
+
+  if !filereadable(resource)
+    call s:TemplateError(a:line, "resource not found '" . resource . "'")
+  endif
+
+  exec "source " . resource
+
+  return []
+endfunction " }}}
+
+" s:Process_out(line) {{{
+" Process <vim:out/> tags.
+function! s:Process_out(line)
+  let value = s:GetAttribute(a:line, 'out', 'value', 1)
+  let result = s:EvaluateExpression(value)
+  return s:Out(a:line, '<vim:out\s\+.\{-}\s*\/>', result)
+endfunction " }}}
+
+" s:Process_include(line) {{{
+" Process <vim:include/> tags.
+function! s:Process_include(line)
+  let template = expand(
+    \ g:EclimTemplateDir . '/' . s:GetAttribute(a:line, 'include', 'template', 1))
+
+  if !filereadable(template)
+    call s:TemplateError(a:line, "template not found '" . template . "'")
+    return []
+  endif
+
+  return readfile(template)
+endfunction " }}}
+
+" s:Process_username(line) {{{
+" Process <vim:username/> tags.
+function! s:Process_username(line)
+  silent! let username = eclim#project#util#GetProjectSetting('org.eclim.user.name')
+  if type(username) == g:NUMBER_TYPE
+    let username = ''
+  endif
+  return s:Out(a:line, '<vim:username\s*\/>', username)
+endfunction " }}}
+
+" s:Out(line, pattern, value) {{{
+function! s:Out(line, pattern, value)
+  let results = type(a:value) == g:LIST_TYPE ? a:value : [a:value]
+  if results[0] == '' && a:line =~ '^\s*' . a:pattern . '\s*$'
+    return []
+  endif
+
+  let line = substitute(a:line, a:pattern, results[0], '')
+  return [line] + (len(results) > 1 ? results[1:] : [])
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/common/util.vim

@@ -0,0 +1,257 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+let s:command_read = '-command archive_read -f "<file>"'
+" }}}
+
+function! eclim#common#util#DiffLastSaved() " {{{
+  " Diff a modified file with the last saved version.
+  if &modified
+    let winnum = winnr()
+    let filetype=&ft
+    vertical belowright new | r #
+    1,1delete _
+
+    diffthis
+    setlocal buftype=nofile
+    setlocal bufhidden=wipe
+    setlocal nobuflisted
+    setlocal noswapfile
+    setlocal readonly
+    exec "setlocal ft=" . filetype
+    let diffnum = winnr()
+
+    augroup diff_saved
+      autocmd! BufUnload <buffer>
+      autocmd BufUnload <buffer> :diffoff!
+    augroup END
+
+    exec winnum . "winc w"
+    diffthis
+
+    " for some reason, these settings only take hold if set here.
+    call setwinvar(diffnum, "&foldmethod", "diff")
+    call setwinvar(diffnum, "&foldlevel", "0")
+  else
+    echo "No changes"
+  endif
+endfunction " }}}
+
+function! eclim#common#util#SwapWords() " {{{
+  " Initially based on http://www.vim.org/tips/tip.php?tip_id=329
+
+  " save the last search pattern
+  let save_search = @/
+
+  normal! "_yiw
+  s/\(\%#\w\+\)\(\_W\+\)\(\w\+\)/\3\2\1/
+  exec "normal! \<C-O>"
+
+  " restore the last search pattern
+  let @/ = save_search
+
+  silent! call repeat#set(":call eclim#common#util#SwapWords()\<cr>", v:count)
+endfunction " }}}
+
+function! eclim#common#util#SwapAround(char) " {{{
+  if len(a:char) != 1
+    call eclim#util#EchoError('Arg must be a single character.')
+    return
+  endif
+
+  let pos = getpos('.')
+  let save_search = @/
+  try
+    let lnum = line('.')
+    let line = getline('.')
+    let start_col = 0
+    if line[col('.') - 1] =~ '[(\[{]'
+      let start_col = col('.')
+      normal! %
+    endif
+    let col = col('.')
+    exec 'normal! f' . a:char
+    if col('.') == col
+      call eclim#util#EchoError('Char not found on this line.')
+      return
+    endif
+
+    let delim_col = col('.')
+
+    let [_, end_col] = searchpos('\S', 'b', lnum)
+    if !start_col
+      if line[col('.') - 1] =~ '[)\]}]'
+        normal! %
+        let start_col = col('.')
+      else
+        let [_, start_col] = searchpos('[(\[{' . a:char . ']', 'b', lnum)
+        if start_col == end_col
+          call eclim#util#EchoError('Unable to determine the start of the first block.')
+          return
+        endif
+        let start_col += 1
+      endif
+    endif
+
+    let first = [start_col, end_col]
+
+    call cursor(0, delim_col)
+    let [_, start_col] = searchpos('\S', '', lnum)
+    if start_col == delim_col
+      call eclim#util#EchoError('Could not find item to swap with.')
+      return
+    endif
+    if line[col('.') - 1] =~ '[(\[{]'
+      normal! %
+      let end_col = col('.')
+    else
+      let [_, end_col] = searchpos('[)\]}' . a:char . ']', '', lnum)
+      if start_col == end_col
+        call eclim#util#EchoError('Unable to determine the end of the second block.')
+        return
+      endif
+      let end_col -= 1
+    endif
+
+    let second = [start_col, end_col]
+
+    let first_part = strpart(line, first[0] - 1, first[1] - first[0] + 1)
+    let second_part = strpart(line, second[0] - 1, second[1] - second[0] + 1)
+
+    " replace second with first
+    let prefix = strpart(line, 0, second[0] - 1)
+    let suffix = strpart(line, second[1])
+    let line = prefix . first_part . suffix
+
+    " replace first with second
+    let prefix = strpart(line, 0, first[0] - 1)
+    let suffix = strpart(line, first[1])
+    let line = prefix . second_part . suffix
+
+    call setline('.', line)
+    silent! call repeat#set(
+      \ ":call eclim#common#util#SwapAround(" . string(a:char) . ")\<cr>", v:count)
+  finally
+    call setpos('.', pos)
+    let @/ = save_search
+  endtry
+endfunction " }}}
+
+function! eclim#common#util#Tcd(dir) " {{{
+  " Like vim's :lcd, but tab local instead of window local.
+  let t:cwd = fnamemodify(a:dir, ':p')
+
+  " initialize the tab cwd for all other tabs if not already set
+  let curtab = tabpagenr()
+  try
+    let index = 1
+    while index <= tabpagenr('$')
+      if index != curtab
+        exec 'tabn ' . index
+        if !exists('t:cwd')
+          let t:cwd = getcwd()
+          " try to find a window without a localdir if necessary
+          if haslocaldir()
+            let curwin = winnr()
+            let windex = 1
+            while windex <= winnr('$')
+              if windex != curwin
+                exec windex . 'winc w'
+                if !haslocaldir()
+                  let t:cwd = getcwd()
+                  break
+                endif
+              endif
+              let windex += 1
+            endwhile
+            exec curwin . 'winc w'
+          endif
+        endif
+      endif
+      let index += 1
+    endwhile
+  finally
+    exec 'tabn ' . curtab
+  endtry
+
+  call s:ApplyTcd(0)
+
+  augroup tcd
+    autocmd!
+    autocmd TabEnter * call <SID>ApplyTcd(1)
+  augroup END
+endfunction " }}}
+
+function! s:ApplyTcd(honor_lcd) " {{{
+  if !exists('t:cwd')
+    return
+  endif
+
+  if a:honor_lcd && haslocaldir()
+    let lcwd = getcwd()
+    exec 'cd ' . escape(t:cwd, ' ')
+    exec 'lcd ' . escape(lcwd, ' ')
+  else
+    exec 'cd ' . escape(t:cwd, ' ')
+  endif
+endfunction " }}}
+
+function! eclim#common#util#ReadFile() " {{{
+  " Reads the contents of an archived file.
+  let archive = substitute(expand('%'), '\', '/', 'g')
+  let command = substitute(s:command_read, '<file>', archive, '')
+
+  let file = eclim#Execute(command)
+
+  if string(file) != '0'
+    let project = exists('b:eclim_project') ? b:eclim_project : ''
+    let bufnum = bufnr('%')
+    if has('win32unix')
+      let file = eclim#cygwin#CygwinPath(file)
+    endif
+    silent exec "keepalt keepjumps edit! " . escape(file, ' ')
+    if project != ''
+      let b:eclim_project = project
+      let b:eclim_file = archive
+    endif
+
+    exec 'bdelete ' . bufnum
+
+    " alternate solution, that keeps the archive url as the buffer's filename,
+    " but prevents taglist from being able to parse tags.
+    "setlocal noreadonly
+    "setlocal modifiable
+    "silent! exec "read " . file
+    "1,1delete _
+
+    silent exec "doautocmd BufReadPre " . file
+    silent exec "doautocmd BufReadPost " . file
+
+    setlocal readonly
+    setlocal nomodifiable
+    setlocal noswapfile
+    " causes taglist.vim errors (fold then delete fails)
+    "setlocal bufhidden=delete
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/css/complete.vim

@@ -0,0 +1,95 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/css/complete.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Varables {{{
+  let s:complete_command =
+    \ '-command css_complete -p "<project>" -f "<file>" -o <offset> -e <encoding>'
+" }}}
+
+" CodeComplete(findstart, base) {{{
+" Handles css code completion.
+function! eclim#css#complete#CodeComplete(findstart, base)
+  if !eclim#project#util#IsCurrentFileInProject(0)
+    return a:findstart ? -1 : []
+  endif
+
+  if a:findstart
+    call eclim#lang#SilentUpdate(1)
+
+    " locate the start of the word
+    let line = getline('.')
+
+    let start = col('.') - 1
+
+    while start > 0 && line[start - 1] =~ '[[:alnum:]_-]'
+      let start -= 1
+    endwhile
+
+    return start
+  else
+    let offset = eclim#util#GetOffset() + len(a:base)
+    let project = eclim#project#util#GetCurrentProjectName()
+    let file = eclim#lang#SilentUpdate(1, 0)
+    if file == ''
+      return []
+    endif
+
+    let command = s:complete_command
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+    let command = substitute(command, '<offset>', offset, '')
+    let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+
+    let completions = []
+    let results = eclim#Execute(command)
+    if type(results) != g:LIST_TYPE
+      return
+    endif
+
+    let filter = 0
+    for result in results
+      let word = result.completion
+      if word =~ '^:'
+        let word = strpart(word, 1)
+        let filter = 1
+      endif
+
+      let menu = result.menu
+      let info = result.info
+
+      let dict = {'word': tolower(word), 'menu': menu, 'info': info}
+
+      call add(completions, dict)
+    endfor
+
+    " eclipse doesn't filter out :results properly.
+    if filter
+      call filter(completions, 'v:val.word =~ "^" . a:base')
+    endif
+
+    return completions
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/css/validate.vim

@@ -0,0 +1,51 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/css/validate.html
+"
+" License:
+"
+" Copyright (C) 2012  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+function! eclim#css#validate#Filter(errors) " {{{
+  let results = []
+  let ignore_next_parse_error = 0
+  for error in a:errors
+    " ignore errors related to browser targeted properties
+    if error.text =~ '\(^\|\s\)-\(moz\|webkit\|khtml\|o\)-\w\+\>'
+      continue
+    endif
+
+    " ignore errors on IE filter property line
+    if getline(error.lnum) =~ '^\s*filter:\s*progid'
+      " next parse error will be because of this filter
+      let ignore_next_parse_error = 1
+      continue
+    endif
+    if error.text == 'Parse Error' && ignore_next_parse_error
+      let ignore_next_parse_error = 0
+      continue
+    endif
+
+    call add(results, error)
+  endfor
+
+  return results
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/cygwin.vim

@@ -0,0 +1,60 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   Utility functions for cygwin usage.
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+function! eclim#cygwin#CygwinPath(path) " {{{
+  return s:Cygpath(a:path, 'cygwin')
+endfunction " }}}
+
+function! eclim#cygwin#WindowsPath(path) " {{{
+  if type(a:path) == g:STRING_TYPE && a:path =~? '^[a-z]:'
+    return substitute(a:path, '\', '/', 'g')
+  endif
+  return s:Cygpath(a:path, 'windows')
+endfunction " }}}
+
+function! eclim#cygwin#WindowsHome() " {{{
+  if !exists('s:cygpath_winhome')
+    let dir = s:Cygpath('-D', 'cygwin')
+    let s:cygpath_winhome = dir != '-D' ? fnamemodify(dir, ':h') : ''
+  endif
+  return s:cygpath_winhome
+endfunction " }}}
+
+function! s:Cygpath(paths, type) " {{{
+  if executable('cygpath')
+    let paths = type(a:paths) == g:LIST_TYPE ? a:paths : [a:paths]
+    let paths = map(paths, "'\"' . substitute(v:val, '\\', '/', 'g') . '\"'")
+
+    let args = a:type == 'windows' ? '-m ' : ''
+    let results = split(eclim#util#System('cygpath ' . args . join(paths)), "\n")
+
+    if type(a:paths) == g:LIST_TYPE
+      return results
+    endif
+    return results[0]
+  endif
+  return a:paths
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/display/menu.vim

@@ -0,0 +1,103 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   Plugin to generate gvim eclim menus.
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+
+let s:eclim_menus_root = []
+let s:eclim_menus = {}
+
+" }}}
+
+" Generate() {{{
+" Generate gvim menu items for available eclim commands.
+function! eclim#display#menu#Generate()
+  " check that the menu bar is enabled or that we are running in a mac gui where
+  " the menu bar always exists regardless of guioptions
+  if &guioptions !~ 'm' && !has('gui_macvim')
+    if exists('b:eclim_menus')
+      unlet b:eclim_menus
+    endif
+    return
+  endif
+
+  redir => commands
+  silent exec 'command'
+  redir END
+
+  if !exists('b:eclim_menus')
+    let b:eclim_menus = {}
+
+    let pattern = '\<eclim#'
+    if len(s:eclim_menus_root) != 0
+      let pattern = '^..b.*\<eclim#'
+    endif
+
+    for cmd in split(commands, '\n')
+      if cmd =~ pattern
+        let name = substitute(cmd, '....\(\w\+\)\s.*', '\1', '')
+        if cmd =~ '\<eclim#[A-Z]'
+          if index(s:eclim_menus_root, name) == -1
+            call add(s:eclim_menus_root, name)
+          endif
+        else
+          let group = substitute(cmd, '.\{-}\<eclim#\(\w\+\)#.*', '\1', '')
+          let var = cmd =~ '^..b' ? 'b:eclim_menus' : 's:eclim_menus'
+          if !has_key({var}, group)
+            let {var}[group] = []
+          endif
+          if index({var}[group], name) == -1
+            call add({var}[group], name)
+          endif
+        endif
+      endif
+    endfor
+
+    call sort(s:eclim_menus_root)
+  endif
+
+  silent! unmenu &Plugin.eclim
+
+  " merge non-buffer items with buffer items
+  let menus = deepcopy(s:eclim_menus, 1)
+  for group in keys(b:eclim_menus)
+    if !has_key(menus, group)
+      let menus[group] = []
+    endif
+    for name in b:eclim_menus[group]
+      call add(menus[group], name)
+    endfor
+  endfor
+
+  for name in s:eclim_menus_root
+    exec 'menu &Plugin.eclim.' . name . ' :' . name . ' '
+  endfor
+
+  for group in sort(keys(menus))
+    for name in sort(menus[group])
+      exec 'menu &Plugin.eclim.' . group . '.' . name . ' :' . name . ' '
+    endfor
+  endfor
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/display/signs.vim

@@ -0,0 +1,375 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   Functions for working with vim signs.
+"
+" License:
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+
+  let s:sign_levels = {
+      \ 'trace': 5,
+      \ 'debug': 4,
+      \ 'info': 3,
+      \ 'warning': 2,
+      \ 'error': 1,
+      \ 'off': 0,
+    \ }
+
+" }}}
+
+function! eclim#display#signs#Define(name, text, highlight) " {{{
+  " Defines a new sign name or updates an existing one.
+  exec "sign define " . a:name . " text=" . a:text . " texthl=" . a:highlight
+endfunction " }}}
+
+function! eclim#display#signs#Place(name, line) " {{{
+  " Places a sign in the current buffer.
+  if a:line > 0
+    let lastline = line('$')
+    let line = a:line <= lastline ? a:line : lastline
+    let id = a:name == 'placeholder' ? 999999 : line
+    exec "sign place " . id . " line=" . line . " name=" . a:name .
+      \ " buffer=" . bufnr('%')
+  endif
+endfunction " }}}
+
+function! eclim#display#signs#PlaceAll(name, list) " {{{
+  " Places a sign in the current buffer for each line in the list.
+
+  let lastline = line('$')
+  for line in a:list
+    if line > 0
+      let line = line <= lastline ? line : lastline
+      exec "sign place " . line . " line=" . line . " name=" . a:name .
+        \ " buffer=" . bufnr('%')
+    endif
+  endfor
+endfunction " }}}
+
+function! eclim#display#signs#Undefine(name) " {{{
+  " Undefines a sign name.
+  exec "sign undefine " . a:name
+endfunction " }}}
+
+function! eclim#display#signs#Unplace(id) " {{{
+  " Un-places a sign in the current buffer.
+  exec 'sign unplace ' . a:id . ' buffer=' . bufnr('%')
+endfunction " }}}
+
+function! eclim#display#signs#UnplaceAll(list) " {{{
+  " Un-places all signs in the supplied list from the current buffer.
+  " The list may be a list of ids or a list of dictionaries as returned by
+  " GetExisting()
+
+  for sign in a:list
+    if type(sign) == g:DICT_TYPE
+      call eclim#display#signs#Unplace(sign['id'])
+    else
+      call eclim#display#signs#Unplace(sign)
+    endif
+  endfor
+endfunction " }}}
+
+function! eclim#display#signs#Toggle(name, line) " {{{
+  if g:EclimSignLevel == 'off'
+    call eclim#util#Echo('Eclim signs have been disabled.')
+    return
+  endif
+
+  " Toggle a sign on the current line.
+  if a:line > 0
+    let existing = eclim#display#signs#GetExisting(a:name)
+    let exists = len(filter(existing, "v:val['line'] == a:line"))
+    if exists
+      call eclim#display#signs#Unplace(a:line)
+    else
+      call eclim#display#signs#Place(a:name, a:line)
+    endif
+  endif
+endfunction " }}}
+
+function! s:CompareSigns(s1, s2) " {{{
+  " Used by ViewSigns to sort list of sign dictionaries.
+
+  if a:s1.line == a:s2.line
+    return 0
+  endif
+  if a:s1.line > a:s2.line
+    return 1
+  endif
+  return -1
+endfunction " }}}
+
+function! eclim#display#signs#ViewSigns(name) " {{{
+  " Open a window to view all placed signs with the given name in the current
+  " buffer.
+
+  if g:EclimSignLevel == 'off'
+    call eclim#util#Echo('Eclim signs have been disabled.')
+    return
+  endif
+
+  let filename = expand('%:p')
+  let signs = eclim#display#signs#GetExisting(a:name)
+  call sort(signs, 's:CompareSigns')
+  let content = map(signs, "v:val.line . '|' . getline(v:val.line)")
+
+  call eclim#util#TempWindow('[Sign List]', content)
+
+  set ft=qf
+  nnoremap <silent> <buffer> <cr> :call <SID>JumpToSign()<cr>
+
+  " Store filename so that plugins can use it if necessary.
+  let b:filename = filename
+  augroup temp_window
+    autocmd! BufWinLeave <buffer>
+    call eclim#util#GoToBufferWindowRegister(filename)
+  augroup END
+endfunction " }}}
+
+function! s:JumpToSign() " {{{
+  let winnr = bufwinnr(bufnr('^' . b:filename))
+  if winnr != -1
+    let line = substitute(getline('.'), '^\(\d\+\)|.*', '\1', '')
+    exec winnr . "winc w"
+    call cursor(line, 1)
+  endif
+endfunction " }}}
+
+function! eclim#display#signs#GetDefined() " {{{
+  " Gets a list of defined sign names.
+
+  redir => list
+  silent exec 'sign list'
+  redir END
+
+  let names = []
+  for name in split(list, '\n')
+    let name = substitute(name, 'sign\s\(.\{-}\)\s.*', '\1', '')
+    call add(names, name)
+  endfor
+  return names
+endfunction " }}}
+
+function! eclim#display#signs#GetExisting(...) " {{{
+  " Gets a list of existing signs for the current buffer.
+  " The list consists of dictionaries with the following keys:
+  "   id:   The sign id.
+  "   line: The line number.
+  "   name: The sign name (erorr, warning, etc.)
+  "
+  " Optionally a sign name may be supplied to only retrieve signs of that name.
+
+  if !has('signs') || g:EclimSignLevel == 'off'
+    return []
+  endif
+
+  let bufnr = bufnr('%')
+
+  redir => signs
+  silent exec 'sign place buffer=' . bufnr
+  redir END
+
+  let existing = []
+  for line in split(signs, '\n')
+    if line =~ '.\{-}=.\{-}=' " only two equals to account for swedish output
+      call add(existing, s:ParseSign(line))
+    endif
+  endfor
+
+  if len(a:000) > 0
+    call filter(existing, "v:val['name'] == a:000[0]")
+  endif
+
+  return existing
+endfunction " }}}
+
+function! eclim#display#signs#HasExisting(...) " {{{
+  " Determines if there are any existing signs.
+  " Optionally a sign name may be supplied to only test for signs of that name.
+
+  if !has('signs') || g:EclimSignLevel == 'off'
+    return 0
+  endif
+
+  let bufnr = bufnr('%')
+
+  redir => results
+  silent exec 'sign place buffer=' . bufnr
+  redir END
+
+  for line in split(results, '\n')
+    if line =~ '.\{-}=.\{-}=' " only two equals to account for swedish output
+      if len(a:000) == 0
+        return 1
+      endif
+      let sign = s:ParseSign(line)
+      if sign.name == a:000[0]
+        return 1
+      endif
+    endif
+  endfor
+
+  return 0
+endfunction " }}}
+
+function! s:ParseSign(raw) " {{{
+  let attrs = split(a:raw)
+
+  exec 'let line = ' . split(attrs[0], '=')[1]
+
+  let id = split(attrs[1], '=')[1]
+  " hack for the italian localization
+  if id =~ ',$'
+    let id = id[:-2]
+  endif
+
+  " hack for the swedish localization
+  if attrs[2] =~ '^namn'
+    let name = substitute(attrs[2], 'namn=\?', '', '')
+  else
+    let name = split(attrs[2], '=')[1]
+  endif
+
+  return {'id': id, 'line': line, 'name': name}
+endfunction " }}}
+
+function! eclim#display#signs#Update() " {{{
+  " Updates the signs for the current buffer.  This function will read both the
+  " location list and the quickfix list and place a sign for any entries for the
+  " current file.
+  " This function supports a severity level by examining the 'type' key of the
+  " dictionaries in the location or quickfix list.  It supports 'i' (info), 'w'
+  " (warning), and 'e' (error).
+
+  if !has('signs') || g:EclimSignLevel == 'off' || &ft == 'qf'
+    return
+  endif
+
+  let save_lazy = &lazyredraw
+  set lazyredraw
+
+  let placeholder = eclim#display#signs#SetPlaceholder()
+
+  " remove all existing signs
+  let existing = eclim#display#signs#GetExisting()
+  for exists in existing
+    if exists.name =~ '^\(qf_\)\?\(error\|info\|warning\)$'
+      call eclim#display#signs#Unplace(exists.id)
+    endif
+  endfor
+
+  let qflist = filter(g:EclimShowQuickfixSigns ? getqflist() : [],
+    \ 'bufnr("%") == v:val.bufnr')
+  let show_loclist = g:EclimShowLoclistSigns && exists('b:eclim_loclist')
+  let loclist = filter(show_loclist ? getloclist(0) : [],
+    \ 'bufnr("%") == v:val.bufnr')
+
+  for [list, marker, prefix] in [
+      \ [qflist, g:EclimQuickfixSignText, 'qf_'],
+      \ [loclist, g:EclimLoclistSignText, '']]
+    if s:sign_levels[g:EclimSignLevel] >= 3
+      let info = filter(copy(list), 'v:val.type == "" || tolower(v:val.type) == "i"')
+      call eclim#display#signs#Define(prefix . 'info', marker, g:EclimHighlightInfo)
+      call eclim#display#signs#PlaceAll(prefix . 'info', map(info, 'v:val.lnum'))
+    endif
+
+    if s:sign_levels[g:EclimSignLevel] >= 2
+      let warnings = filter(copy(list), 'tolower(v:val.type) == "w"')
+      call eclim#display#signs#Define(prefix . 'warning', marker, g:EclimHighlightWarning)
+      call eclim#display#signs#PlaceAll(prefix . 'warning', map(warnings, 'v:val.lnum'))
+    endif
+
+    if s:sign_levels[g:EclimSignLevel] >= 1
+      let errors = filter(copy(list), 'tolower(v:val.type) == "e"')
+      call eclim#display#signs#Define(prefix . 'error', marker, g:EclimHighlightError)
+      call eclim#display#signs#PlaceAll(prefix . 'error', map(errors, 'v:val.lnum'))
+    endif
+  endfor
+
+  if placeholder
+    call eclim#display#signs#RemovePlaceholder()
+  endif
+
+  let &lazyredraw = save_lazy
+endfunction " }}}
+
+function! eclim#display#signs#QuickFixCmdPost() " {{{
+  " Force 'make' results to be of type error if no type set.
+  if expand('<amatch>') == 'make'
+    let newentries = []
+    for entry in getqflist()
+      if entry['type'] == ''
+        let entry['type'] = 'e'
+      endif
+      call add(newentries, entry)
+    endfor
+    call setqflist(newentries, 'r')
+  endif
+  call eclim#display#signs#Update()
+  redraw!
+endfunction " }}}
+
+function! eclim#display#signs#SetPlaceholder(...) " {{{
+  " Set sign at line 1 to prevent sign column from collapsing, and subsiquent
+  " screen redraw.
+  " Optional args:
+  "   only_if_necessary: if 1, only set a placeholder if there are no existing
+  "   signs
+
+  if !has('signs') || g:EclimSignLevel == 'off'
+    return
+  endif
+
+  if len(a:000) > 0 && a:000[0]
+    let existing = eclim#display#signs#GetExisting()
+    if !len(existing)
+      return
+    endif
+  endif
+
+  call eclim#display#signs#Define('placeholder', '_ ', g:EclimHighlightInfo)
+  let existing = eclim#display#signs#GetExisting('placeholder')
+  if len(existing) == 0 && eclim#display#signs#HasExisting()
+    call eclim#display#signs#Place('placeholder', 1)
+    return 1
+  endif
+  return
+endfunction " }}}
+
+function! eclim#display#signs#RemovePlaceholder() " {{{
+  if !has('signs') || g:EclimSignLevel == 'off'
+    return
+  endif
+
+  let existing = eclim#display#signs#GetExisting('placeholder')
+  for exists in existing
+    call eclim#display#signs#Unplace(exists.id)
+  endfor
+endfunction " }}}
+
+" define signs for manually added user marks.
+if has('signs')
+  call eclim#display#signs#Define(
+    \ 'user', g:EclimUserSignText, g:EclimHighlightUserSign)
+endif
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/display/window.vim

@@ -0,0 +1,349 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" GlobalVariables {{{
+let g:VerticalToolBuffers = {}
+
+if !exists('g:VerticalToolWindowSide')
+  let g:VerticalToolWindowSide = 'left'
+endif
+
+if g:VerticalToolWindowSide == 'right'
+  let g:VerticalToolWindowPosition = 'botright vertical'
+else
+  let g:VerticalToolWindowPosition = 'topleft vertical'
+endif
+
+if !exists('g:VerticalToolWindowWidth')
+  let g:VerticalToolWindowWidth = 30
+endif
+" }}}
+
+function! eclim#display#window#VerticalToolWindowOpen(name, weight, ...) " {{{
+  " Handles opening windows in the vertical tool window on the left (taglist,
+  " project tree, etc.)
+
+  let taglist_window = -1
+  if exists('g:TagList_title')
+    let taglist_window = bufwinnr(eclim#util#EscapeBufferName(g:TagList_title))
+    let taglist_position = 'left'
+    if exists('g:Tlist_Use_Horiz_Window') && g:Tlist_Use_Horiz_Window
+      let taglist_position = 'horizontal'
+    elseif exists('g:TaglistTooPosition')
+      let taglist_position = g:TaglistTooPosition
+    elseif exists('g:Tlist_Use_Right_Window') && g:Tlist_Use_Right_Window
+      let taglist_position = 'right'
+    endif
+  endif
+  if taglist_window == -1 && exists(':TagbarOpen')
+    let taglist_window = bufwinnr('__Tagbar__')
+    let taglist_position = 'right'
+    if exists('g:tagbar_left') && g:tagbar_left
+      let taglist_position = 'left'
+    endif
+  endif
+  if taglist_window != -1
+    " don't consider horizontal taglist, or taglist configured to display
+    " opposite the tool windows as a tool window member.
+    if taglist_position != g:VerticalToolWindowSide
+      let taglist_window = -1
+    endif
+  endif
+
+
+  let relative_window = 0
+  let relative_window_loc = 'below'
+  if taglist_window != -1 || len(g:VerticalToolBuffers) > 0
+    if taglist_window != -1
+      let relative_window = taglist_window
+    endif
+    for toolbuf in keys(g:VerticalToolBuffers)
+      exec 'let toolbuf = ' . toolbuf
+      if bufwinnr(toolbuf) != -1
+        if relative_window == 0
+          let relative_window = bufwinnr(toolbuf)
+          if getbufvar(toolbuf, 'weight') > a:weight
+            let relative_window_loc = 'below'
+          else
+            let relative_window_loc = 'above'
+          endif
+        elseif getbufvar(toolbuf, 'weight') > a:weight
+          let relative_window = bufwinnr(toolbuf)
+          let relative_window_loc = 'below'
+        endif
+      endif
+    endfor
+  endif
+
+  if relative_window != 0
+    let wincmd = relative_window . 'winc w | keepalt ' . relative_window_loc . ' '
+  else
+    let wincmd = 'keepalt ' . g:VerticalToolWindowPosition . ' ' . g:VerticalToolWindowWidth
+  endif
+
+  let escaped = substitute(
+    \ a:name, '\(.\{-}\)\[\(.\{-}\)\]\(.\{-}\)', '\1[[]\2[]]\3', 'g')
+  if a:0 && a:1
+    let bufnum = -1
+    for bnr in tabpagebuflist()
+      if bufname(bnr) == a:name
+        let bufnum = bnr
+        break
+      endif
+    endfor
+  else
+    let bufnum = bufnr(escaped)
+  endif
+  let name = bufnum == -1 ? a:name : '+buffer' . bufnum
+  silent call eclim#util#ExecWithoutAutocmds(wincmd . ' split ' . name)
+
+  doautocmd BufWinEnter
+  setlocal winfixwidth
+  setlocal nonumber
+  setlocal nospell norelativenumber
+
+  let b:weight = a:weight
+  let bufnum = bufnr('%')
+  let g:VerticalToolBuffers[bufnum] = a:name
+  augroup eclim_vertical_tool_windows
+    autocmd!
+    autocmd BufDelete * call s:PreventCloseOnBufferDelete()
+    autocmd BufEnter * nested call s:CloseIfLastWindow()
+  augroup END
+
+  if exists('g:TagList_title') &&
+   \ (!exists('g:Tlist_Use_Horiz_Window') || !g:Tlist_Use_Horiz_Window)
+    augroup eclim_vertical_tool_windows_move_taglist
+      autocmd!
+      exec 'autocmd BufWinEnter ' . eclim#util#EscapeBufferName(g:TagList_title) .
+        \ ' call s:MoveRelativeTo()'
+    augroup END
+  endif
+  if exists(':TagbarOpen')
+    augroup eclim_vertical_tool_windows_move_tagbar
+      autocmd!
+      autocmd BufWinEnter __Tagbar__ call s:MoveRelativeTo()
+    augroup END
+  endif
+  augroup eclim_vertical_tool_windows_buffer
+    exec 'autocmd BufWinLeave <buffer> ' .
+      \ 'silent! call remove(g:VerticalToolBuffers, ' . bufnum . ') | ' .
+      \ 'autocmd! eclim_vertical_tool_windows_buffer * <buffer=' . bufnum . '>'
+  augroup END
+endfunction " }}}
+
+function! eclim#display#window#VerticalToolWindowRestore() " {{{
+  " Used to restore the tool windows to their proper width if some action
+  " altered them.
+
+  for toolbuf in keys(g:VerticalToolBuffers)
+    exec 'let toolbuf = ' . toolbuf
+    if bufwinnr(toolbuf) != -1
+      exec 'vertical ' . bufwinnr(toolbuf) . 'resize ' . g:VerticalToolWindowWidth
+    endif
+  endfor
+endfunction " }}}
+
+function! eclim#display#window#GetWindowOptions(winnum) " {{{
+  " Gets a dictionary containing all the localy set options for the specified
+  " window.
+
+  let curwin = winnr()
+  try
+    exec a:winnum . 'winc w'
+    redir => list
+    silent exec 'setlocal'
+    redir END
+  finally
+    exec curwin . 'winc w'
+  endtry
+
+  let list = substitute(list, '---.\{-}---', '', '')
+  let winopts = {}
+  for wopt in split(list, '\(\n\|\s\s\+\)')[1:]
+    if wopt =~ '^[a-z]'
+      if wopt =~ '='
+        let key = substitute(wopt, '\(.\{-}\)=.*', '\1', '')
+        let value = substitute(wopt, '.\{-}=\(.*\)', '\1', '')
+        let winopts[key] = value
+      else
+        let winopts[wopt] = ''
+      endif
+    endif
+  endfor
+  return winopts
+endfunction " }}}
+
+function! eclim#display#window#SetWindowOptions(winnum, options) " {{{
+  " Given a dictionary of options, sets each as local options for the specified
+  " window.
+
+  let curwin = winnr()
+  try
+    exec a:winnum . 'winc w'
+    for key in keys(a:options)
+      if key =~ '^no'
+        silent! exec 'setlocal ' . key
+      else
+        silent! exec 'setlocal ' . key . '=' . escape(a:options[key], ' ')
+      endif
+    endfor
+  finally
+    exec curwin . 'winc w'
+  endtry
+endfunction " }}}
+
+function! s:CloseIfLastWindow() " {{{
+  if histget(':', -1) !~ '^bd'
+    let close = 1
+    for bufnr in tabpagebuflist()
+      if has_key(g:VerticalToolBuffers, bufnr)
+        continue
+      endif
+      if exists('g:TagList_title') && bufname(bufnr) == g:TagList_title
+        continue
+      endif
+      if exists('g:BufExplorer_title') && bufname(bufnr) == '[BufExplorer]'
+        let close = 0
+        break
+      endif
+
+      let buftype = getbufvar(bufnr, '&buftype')
+      if buftype != '' && buftype != 'help'
+        continue
+      endif
+
+      let close = 0
+      break
+    endfor
+
+    if close
+      if tabpagenr('$') > 1
+        tabclose
+      else
+        quitall
+      endif
+    endif
+  endif
+endfunction " }}}
+
+function! s:MoveRelativeTo() " {{{
+  " get the buffer that the taglist was opened from
+  let curwin = winnr()
+  let list_buffer = bufnr('%')
+  winc p
+  let orig_buffer = bufnr('%')
+  exec curwin . 'winc p'
+
+  for toolbuf in keys(g:VerticalToolBuffers)
+    exec 'let toolbuf = ' . toolbuf
+    if bufwinnr(toolbuf) != -1
+      call setwinvar(bufwinnr(toolbuf), 'marked_for_removal', 1)
+      let winoptions = eclim#display#window#GetWindowOptions(bufwinnr(toolbuf))
+      call remove(winoptions, 'filetype')
+      call remove(winoptions, 'syntax')
+      call eclim#display#window#VerticalToolWindowOpen(
+        \ g:VerticalToolBuffers[toolbuf], getbufvar(toolbuf, 'weight'))
+      call eclim#display#window#SetWindowOptions(winnr(), winoptions)
+    endif
+  endfor
+
+  let winnum = 1
+  while winnum <= winnr('$')
+    if getwinvar(winnum, 'marked_for_removal') == 1
+      exec winnum . 'winc w'
+      close
+    else
+      let winnum += 1
+    endif
+  endwhile
+  call eclim#display#window#VerticalToolWindowRestore()
+
+  " some window juggling so that winc p from taglist goes back to the original
+  " buffer
+  exec bufwinnr(orig_buffer) . 'winc w'
+  exec bufwinnr(list_buffer) . 'winc w'
+endfunction " }}}
+
+function! s:PreventCloseOnBufferDelete() " {{{
+  let index = 1
+  let numtoolwindows = 0
+  let numtempwindows = 0
+  let tempbuffersbot = []
+  while index <= winnr('$')
+    let buf = winbufnr(index)
+    let bufname = bufname(buf)
+    if index(keys(g:VerticalToolBuffers), string(buf)) != -1
+      let numtoolwindows += 1
+    elseif getwinvar(index, '&winfixheight') || getwinvar(index, '&winfixwidth')
+      let numtempwindows += 1
+      if getwinvar(index, '&winfixheight')
+        call add(tempbuffersbot, buf)
+      endif
+    endif
+    let index += 1
+  endwhile
+
+  if winnr('$') == (numtoolwindows + numtempwindows)
+    let toolbuf = bufnr('%')
+    if g:VerticalToolWindowSide == 'right'
+      vertical topleft new
+    else
+      vertical botright new
+    endif
+    setlocal noreadonly modifiable
+    let curbuf = bufnr('%')
+    let removed = str2nr(expand('<abuf>'))
+    let next = eclim#common#buffers#OpenNextHiddenTabBuffer(removed)
+    if next != 0
+      let curbuf = next
+    endif
+
+    " resize windows
+    exec bufwinnr(toolbuf) . 'winc w'
+    exec 'vertical resize ' . g:VerticalToolWindowWidth
+
+    " fix the position of the temp windows
+    for buf in tempbuffersbot
+      " open the buffer in the temp window position
+      botright 10new
+      exec 'buffer ' . buf
+      setlocal winfixheight
+
+      " close the old window
+      let winnr = winnr()
+      let index = 1
+      while index <= winnr('$')
+        if winbufnr(index) == buf && index != winnr
+          exec index . 'winc w'
+          close
+          winc p
+          break
+        endif
+        let index += 1
+      endwhile
+    endfor
+
+    exec bufwinnr(curbuf) . 'winc w'
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/help.vim

@@ -0,0 +1,169 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   Commands view / search eclim help files.
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Global Variables {{{
+  let g:EclimHelpDir = g:EclimBaseDir . '/eclim/doc'
+" }}}
+
+" Help(tag) {{{
+function! eclim#help#Help(tag, link)
+  if !filereadable(substitute(g:EclimHelpDir, '\\\s', ' ', 'g') . '/tags')
+    call eclim#util#Echo('indexing eclim help files...')
+    exec 'helptags ' . g:EclimHelpDir
+    let paths = split(glob(g:EclimHelpDir . '/**/*'), '\n')
+    call filter(paths, 'isdirectory(v:val)')
+    for path in paths
+      exec 'helptags ' . path
+    endfor
+    call eclim#util#Echo('eclim help files indexed')
+  endif
+
+  let savetags = &tags
+  exec 'set tags=' . escape(escape(g:EclimHelpDir, ' '), ' ') . '/**/tags'
+  try
+    let tag = a:tag
+    if tag == '' && !a:link
+      let tag = 'index'
+    elseif tag ==''
+      let line = getline('.')
+      let tag = substitute(
+        \ line, '.*|\(\S\{-}\%' . col('.') . 'c\S\{-}\)|.*', '\1', '')
+      if tag == line
+        return
+      endif
+    endif
+
+    call s:HelpWindow()
+    exec 'tag ' . tag
+    let w:eclim_help = 1
+
+    " needed to ensure taglist is updated if open
+    doautocmd BufEnter
+  catch /^Vim\%((\a\+)\)\=:E426/
+    if !exists('w:eclim_help')
+      close
+    endif
+    call eclim#util#EchoError('Sorry no eclim help for ' . tag)
+  finally
+    let &tags = savetags
+  endtry
+endfunction " }}}
+
+" HelpGrep() {{{
+function! eclim#help#HelpGrep(args)
+  exec 'vimgrep ' a:args . ' ' . g:EclimHelpDir . '/**/*.txt'
+endfunction " }}}
+
+" s:HelpWindow() {{{
+function s:HelpWindow()
+  let max = winnr('$')
+  let index = 1
+  while index <= max
+    if getwinvar(index, 'eclim_help')
+      exec index . 'winc w'
+      return
+    endif
+    let index += 1
+  endwhile
+
+  new
+endfunction " }}}
+
+" BufferHelp(lines, orientation, size) {{{
+" Function to display a help window for the current buffer.
+function! eclim#help#BufferHelp(lines, orientation, size)
+  let orig_bufnr = bufnr('%')
+  let name = expand('%')
+  if name =~ '^\W.*\W$'
+    let name = name[:-2] . ' Help' . name[len(name) - 1]
+  else
+    let name .= ' Help'
+  endif
+
+  let bname = eclim#util#EscapeBufferName(name)
+
+  let orient = a:orientation == 'vertical' ? 'v' : ''
+  if bufwinnr(bname) != -1
+    exec 'bd ' . bufnr(bname)
+    return
+  endif
+
+  silent! noautocmd exec a:size . orient . "new " . escape(name, ' ')
+  if a:orientation == 'vertical'
+    setlocal winfixwidth
+  else
+    setlocal winfixheight
+  endif
+  setlocal nowrap
+  setlocal noswapfile nobuflisted nonumber
+  setlocal nospell norelativenumber
+  setlocal buftype=nofile bufhidden=delete
+  nnoremap <buffer> <silent> ? :bd<cr>
+  nnoremap <buffer> <silent> q :bd<cr>
+
+  setlocal modifiable noreadonly
+  silent 1,$delete _
+  call append(1, a:lines)
+  retab
+  silent 1,1delete _
+
+  if len(a:000) == 0 || a:000[0]
+    setlocal nomodified nomodifiable readonly
+  endif
+
+  let help_bufnr = bufnr('%')
+  augroup eclim_help_buffer
+    autocmd! BufWinLeave <buffer>
+    autocmd BufWinLeave <buffer> nested autocmd! eclim_help_buffer * <buffer>
+    exec 'autocmd BufWinLeave <buffer> nested ' .
+      \ 'autocmd! eclim_help_buffer * <buffer=' . orig_bufnr . '>'
+    exec 'autocmd! BufWinLeave <buffer=' . orig_bufnr . '>'
+    exec 'autocmd BufWinLeave <buffer=' . orig_bufnr . '> nested bd ' . help_bufnr
+  augroup END
+
+  return help_bufnr
+endfunction " }}}
+
+" CommandComplete(argLead, cmdLine, cursorPos) {{{
+function! eclim#help#CommandCompleteTag(argLead, cmdLine, cursorPos)
+  let cmdTail = strpart(a:cmdLine, a:cursorPos)
+  let argLead = substitute(a:argLead, cmdTail . '$', '', '')
+
+  let savetags = &tags
+  exec 'set tags=' . escape(escape(g:EclimHelpDir, ' '), ' ') . '/**/tags'
+  try
+    let tags = sort(map(taglist(argLead . '.*'), "v:val['name']"))
+    let results = []
+    for tag in tags
+      if index(results, tag) == -1
+        call add(results, tag)
+      endif
+    endfor
+    return results
+  finally
+    let &tags = savetags
+  endtry
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/html/complete.vim

@@ -0,0 +1,59 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/html/complete.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2012  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Varables {{{
+  let s:complete_command =
+    \ '-command html_complete -p "<project>" -f "<file>" -o <offset> -e <encoding>'
+" }}}
+
+" CodeComplete(findstart, base) {{{
+" Handles html code completion.
+function! eclim#html#complete#CodeComplete(findstart, base)
+  "if eclim#html#util#InJavascriptBlock()
+  "  return eclim#javascript#complete#CodeComplete(a:findstart, a:base)
+  "endif
+
+  if eclim#html#util#InCssBlock()
+    return eclim#css#complete#CodeComplete(a:findstart, a:base)
+  endif
+
+  if a:findstart
+    call eclim#lang#SilentUpdate(1)
+
+    " locate the start of the word
+    let line = getline('.')
+
+    let start = col('.') - 1
+
+    while start > 0 && line[start - 1] =~ '[[:alnum:]_-]'
+      let start -= 1
+    endwhile
+
+    return start
+  else
+    return eclim#lang#CodeComplete(s:complete_command, a:findstart, a:base)
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/html/util.vim

@@ -0,0 +1,135 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   Various html relatd functions.
+"
+" License:
+"
+" Copyright (C) 2005 - 2009  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" HtmlToText() {{{
+" Converts the supplied basic html to text.
+function! eclim#html#util#HtmlToText(html)
+  let text = a:html
+  let text = substitute(text, '<br/\?>\c', '\n', 'g')
+  let text = substitute(text, '</\?b>\c', '', 'g')
+  let text = substitute(text, '</\?ul>\c', '', 'g')
+  let text = substitute(text, '<li>\c', '- ', 'g')
+  let text = substitute(text, '</li>\c', '', 'g')
+  let text = substitute(text, '</\?p/\?>\c', '', 'g')
+  let text = substitute(text, '</\?code>\c', '', 'g')
+  let text = substitute(text, '</\?pre>\c', '', 'g')
+  let text = substitute(text, '<a .\{-}>\c', '', 'g')
+  let text = substitute(text, '</a>', '', 'g')
+  let text = substitute(text, '&quot;\c', '"', 'g')
+  let text = substitute(text, '&amp;\c', '&', 'g')
+  let text = substitute(text, '&lt;\c', '<', 'g')
+  let text = substitute(text, '&gt;\c', '>', 'g')
+
+  return text
+endfunction " }}}
+
+" InCssBlock() {{{
+" Determines if the cusor is inside of <style> tags.
+function! eclim#html#util#InCssBlock()
+  let line = line('.')
+
+  let stylestart = search('<style\>', 'bcWn')
+  if stylestart > 0
+    let styleend = search('</style\s*>', 'bWn')
+  endif
+  if stylestart > 0 && stylestart < line &&
+      \ (styleend == 0 || (styleend > stylestart && line < styleend))
+    return stylestart
+  endif
+
+  return 0
+endfunction " }}}
+
+" InJavascriptBlock() {{{
+" Determines if the cursor is inside of <script> tags.
+function! eclim#html#util#InJavascriptBlock()
+  let line = line('.')
+
+  let scriptstart = search('<script\>', 'bcWn')
+  if scriptstart > 0
+    let scriptend = search('</script\s*>', 'bWn')
+  endif
+  if scriptstart > 0 && scriptstart < line &&
+        \ (scriptend == 0 || (scriptend > scriptstart && line < scriptend))
+    return scriptstart
+  endif
+
+  return 0
+endfunction " }}}
+
+" OpenInBrowser(file) {{{
+function! eclim#html#util#OpenInBrowser(file)
+  let file = a:file
+  if file == ''
+    let file = expand('%:p')
+  else
+    let file = getcwd() . '/' . file
+  endif
+  let url = 'file://' . file
+  call eclim#web#OpenUrl(url)
+endfunction " }}}
+
+" UrlEncode(string) {{{
+function! eclim#html#util#UrlEncode(string)
+  let result = a:string
+
+  " must be first
+  let result = substitute(result, '%', '%25', 'g')
+
+  let result = substitute(result, '\s', '%20', 'g')
+  let result = substitute(result, '!', '%21', 'g')
+  let result = substitute(result, '"', '%22', 'g')
+  let result = substitute(result, '#', '%23', 'g')
+  let result = substitute(result, '\$', '%24', 'g')
+  let result = substitute(result, '&', '%26', 'g')
+  let result = substitute(result, "'", '%27', 'g')
+  let result = substitute(result, '(', '%28', 'g')
+  let result = substitute(result, ')', '%29', 'g')
+  let result = substitute(result, '*', '%2A', 'g')
+  let result = substitute(result, '+', '%2B', 'g')
+  let result = substitute(result, ',', '%2C', 'g')
+  let result = substitute(result, '-', '%2D', 'g')
+  let result = substitute(result, '\.', '%2E', 'g')
+  let result = substitute(result, '\/', '%2F', 'g')
+  let result = substitute(result, ':', '%3A', 'g')
+  let result = substitute(result, ';', '%3B', 'g')
+  let result = substitute(result, '<', '%3C', 'g')
+  let result = substitute(result, '=', '%3D', 'g')
+  let result = substitute(result, '>', '%3E', 'g')
+  let result = substitute(result, '?', '%3F', 'g')
+  let result = substitute(result, '@', '%40', 'g')
+  let result = substitute(result, '[', '%5B', 'g')
+  let result = substitute(result, '\\', '%5C', 'g')
+  let result = substitute(result, ']', '%5D', 'g')
+  let result = substitute(result, '\^', '%5E', 'g')
+  let result = substitute(result, '`', '%60', 'g')
+  let result = substitute(result, '{', '%7B', 'g')
+  let result = substitute(result, '|', '%7C', 'g')
+  let result = substitute(result, '}', '%7D', 'g')
+  let result = substitute(result, '\~', '%7E', 'g')
+
+  return result
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/html/validate.vim

@@ -0,0 +1,64 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/html/validate.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+function! eclim#html#validate#Validate(on_save) " {{{
+  let validate = !a:on_save || (
+    \ g:EclimHtmlValidate &&
+    \ (!exists('g:EclimFileTypeValidate') || g:EclimFileTypeValidate))
+
+  if !validate || eclim#util#WillWrittenBufferClose()
+    return
+  endif
+
+  if !eclim#project#util#IsCurrentFileInProject(!a:on_save)
+    return
+  endif
+
+  " prevent closing of sign column between validation methods
+  call eclim#display#signs#SetPlaceholder()
+
+  call eclim#lang#Validate('html', a:on_save)
+
+  " prevent closing of sign column between validation methods
+  "call eclim#display#signs#SetPlaceholder()
+
+  " disabled for now since the parser will attempt to follow all style tags
+  " and interprets //domain.com/styles.css as an ftp path leading to
+  " long validation delays due to connection timeouts.
+  "let html_errors = getloclist(0)
+  "let css_errors = []
+  "if search('<style', 'cnw')
+  "  call eclim#lang#Validate('css', a:on_save)
+  "  let css_errors = getloclist(0)
+  "endif
+
+  "call eclim#util#SetLocationList(html_errors + css_errors)
+
+  if search('<script', 'cnw')
+    call eclim#javascript#util#UpdateSrcFile(a:on_save)
+  endif
+  call eclim#display#signs#RemovePlaceholder()
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/ant/complete.vim

@@ -0,0 +1,144 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/java/ant/complete.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Varables {{{
+  let s:complete_command =
+    \ '-command ant_complete -p "<project>" -f "<file>" -o <offset> -e <encoding>'
+  let s:command_targets = '-command ant_targets -p "<project>" -f "<file>"'
+" }}}
+
+" CodeComplete(findstart, base) {{{
+" Handles ant code completion.
+function! eclim#java#ant#complete#CodeComplete(findstart, base)
+  if !eclim#project#util#IsCurrentFileInProject(0)
+    return a:findstart ? -1 : []
+  endif
+
+  if a:findstart
+    call eclim#lang#SilentUpdate(1)
+
+    " locate the start of the word
+    let line = getline('.')
+
+    let start = col('.') - 1
+
+    "exceptions that break the rule
+    if line[start - 1] == '.'
+      let start -= 1
+    endif
+
+    " always start in front of the the '<'
+    if line[start] == '<'
+      let start += 1
+    endif
+
+    while start > 0 && line[start - 1] =~ '\w'
+      let start -= 1
+    endwhile
+
+    " if prev char is '/' then back off the start pos, since the completion
+    " result will contain the '/'.
+    if line[start - 1] == '/'
+      let start -= 1
+    endif
+
+    return start
+  else
+    let offset = eclim#util#GetOffset() + len(a:base) - 1
+    let project = eclim#project#util#GetCurrentProjectName()
+    let file = eclim#lang#SilentUpdate(1, 0)
+    if file == ''
+      return []
+    endif
+
+    let command = s:complete_command
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+    let command = substitute(command, '<offset>', offset, '')
+    let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+
+    let completions = []
+    let results = eclim#Execute(command)
+    if type(results) != g:LIST_TYPE
+      return
+    endif
+
+    " if the word has a '.' in it (like package completion) then we need to
+    " strip some off according to what is currently in the buffer.
+    let prefix = substitute(getline('.'),
+      \ '.\{-}\([[:alnum:].]\+\%' . col('.') . 'c\).*', '\1', '')
+
+    for result in results
+      let word = result.completion
+      " removed '<' and '>' from end tag results
+      let word = substitute(word, '^<\(.*\)>$', '\1', '')
+
+      " strip off prefix if necessary.
+      if word =~ '\.'
+        let word = substitute(word, escape(prefix, '*'), '', '')
+      endif
+
+      let menu = eclim#html#util#HtmlToText(result.menu)
+      let info = eclim#html#util#HtmlToText(result.info)
+
+      let dict = {'word': word, 'menu': menu, 'info': info}
+
+      call add(completions, dict)
+    endfor
+
+    return completions
+  endif
+endfunction " }}}
+
+" CommandCompleteTarget(argLead, cmdLine, cursorPos) {{{
+" Custom command completion for ant targets.
+function! eclim#java#ant#complete#CommandCompleteTarget(argLead, cmdLine, cursorPos)
+  let project = eclim#project#util#GetCurrentProjectName()
+  if project == ''
+    return []
+  endif
+
+  let file = eclim#java#ant#util#FindBuildFile()
+  if project != "" && file != ""
+    let file = eclim#project#util#GetProjectRelativeFilePath(file)
+    let command = s:command_targets
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+
+    let targets = eclim#Execute(command)
+    if type(targets) != g:LIST_TYPE
+      return []
+    endif
+
+    let cmdTail = strpart(a:cmdLine, a:cursorPos)
+    let argLead = substitute(a:argLead, cmdTail . '$', '', '')
+    call filter(targets, 'v:val =~ "^' . argLead . '"')
+
+    return targets
+  endif
+
+  return []
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/ant/doc.vim

@@ -0,0 +1,170 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/java/ant/doc.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Global Varables {{{
+if !exists("g:EclimAntDocDefaultUrl")
+  let g:EclimAntDocDefaultUrl =
+    \ 'http://www.google.com/search?btnI=1&q=allintitle%3A<element>+task+%7C+type+site%3Aant.apache.org'
+endif
+
+if !exists("g:EclimAntUserDocs")
+  let g:EclimAntUserDocs = {}
+endif
+" }}}
+
+" Script Varables {{{
+let s:targets = 'http://ant.apache.org/manual/targets.html'
+let s:using = 'http://ant.apache.org/manual/using.html#<element>s'
+let s:conditions = 'http://ant.apache.org/manual/Tasks/conditions.html#<element>'
+let s:mappers = 'http://ant.apache.org/manual/Types/mapper.html'
+let s:paths = 'http://ant.apache.org/manual/using.html#path'
+let s:types =
+  \ 'http://ant.apache.org/manual/Types/<element>.html'
+let s:selectors =
+  \ 'http://ant.apache.org/manual/Types/selectors.html#<element>select'
+let s:contrib_1 =
+  \ 'http://ant-contrib.sourceforge.net/tasks/tasks/<element>.html'
+let s:contrib_2 =
+  \ 'http://ant-contrib.sourceforge.net/tasks/tasks/<element>_task.html'
+let s:element_docs = {
+    \  'project'           : s:using,
+    \  'target'            : s:targets,
+    \  'and'               : s:conditions,
+    \  'checksum'          : s:conditions,
+    \  'checs'             : s:conditions,
+    \  'contains'          : s:conditions,
+    \  'equals'            : s:conditions,
+    \  'filesmatch'        : s:conditions,
+    \  'http'              : s:conditions,
+    \  'isfalse'           : s:conditions,
+    \  'isfileselected'    : s:conditions,
+    \  'isreference'       : s:conditions,
+    \  'isset'             : s:conditions,
+    \  'istrue'            : s:conditions,
+    \  'length'            : s:conditions,
+    \  'not'               : s:conditions,
+    \  'or'                : s:conditions,
+    \  'os'                : s:conditions,
+    \  'socket'            : s:conditions,
+    \  'compositemapper'   : s:mappers,
+    \  'filtermapper'      : s:mappers,
+    \  'flattenmapper'     : s:mappers,
+    \  'globmapper'        : s:mappers,
+    \  'identitymapper'    : s:mappers,
+    \  'mergemapper'       : s:mappers,
+    \  'packagemapper'     : s:mappers,
+    \  'regexmapper'       : s:mappers,
+    \  'antlib'            : s:types,
+    \  'description'       : s:types,
+    \  'dirset'            : s:types,
+    \  'filelist'          : s:types,
+    \  'fileset'           : s:types,
+    \  'filterchain'       : s:types,
+    \  'filterset'         : s:types,
+    \  'mapper'            : s:types,
+    \  'patternset'        : s:types,
+    \  'permissions'       : s:types,
+    \  'propertyset'       : s:types,
+    \  'redirector'        : s:types,
+    \  'regexp'            : s:types,
+    \  'xmlcatalog'        : s:types,
+    \  'zipfileset'        : s:types,
+    \  'classpath'         : s:paths,
+    \  'path'              : s:paths,
+    \  'containsregexp'    : s:selectors,
+    \  'date'              : s:selectors,
+    \  'depend'            : s:selectors,
+    \  'depth'             : s:selectors,
+    \  'different'         : s:selectors,
+    \  'filename'          : s:selectors,
+    \  'majority'          : s:selectors,
+    \  'modified'          : s:selectors,
+    \  'none'              : s:selectors,
+    \  'present'           : s:selectors,
+    \  'selector'          : s:selectors,
+    \  'size'              : s:selectors,
+    \  'type'              : s:selectors,
+    \  'for'               : s:contrib_1,
+    \  'foreach'           : s:contrib_1,
+    \  'if'                : s:contrib_1,
+    \  'outofdate'         : s:contrib_1,
+    \  'runtarget'         : s:contrib_1,
+    \  'switch'            : s:contrib_1,
+    \  'throw'             : s:contrib_1,
+    \  'timestampselector' : s:contrib_1,
+    \  'trycatch'          : s:contrib_1,
+    \  'osfamily'          : s:contrib_1,
+    \  'shellscript'       : s:contrib_1,
+    \  'propertycopy'      : s:contrib_1,
+    \  'propertyselector'  : s:contrib_1,
+    \  'pathoffileset'     : s:contrib_1,
+    \  'propertyregex'     : s:contrib_1,
+    \  'sortlist'          : s:contrib_1,
+    \  'urlencode'         : s:contrib_1,
+    \  'forget'            : s:contrib_1,
+    \  'compilewithwalls'  : s:contrib_1,
+    \  'inifile'           : s:contrib_1,
+    \  'verifydesign'      : s:contrib_1,
+    \  'antcallback'       : s:contrib_2,
+    \  'antfetch'          : s:contrib_2,
+    \  'assert'            : s:contrib_2,
+    \  'post'              : s:contrib_2,
+    \  'stopwatch'         : s:contrib_2,
+    \  'match'             : s:contrib_2,
+    \  'variable'          : s:contrib_2,
+    \  'limit'             : s:contrib_2,
+    \  'antclipse'         : s:contrib_2
+  \ }
+" }}}
+
+function! eclim#java#ant#doc#FindDoc(element) " {{{
+  " Open the url to the documentation for the supplied element name or if not
+  " provided, the element name under the cursor.
+  let element = a:element
+  if element == ''
+    let col = eclim#util#GetCurrentElementColumn()
+    if getline('.')[col - 2] !~ '<\|\/'
+      " not on an element
+      return
+    endif
+    let element = expand('<cword>')
+  endif
+  let element = tolower(element)
+
+  if has_key(s:element_docs, element)
+    let url = s:element_docs[element]
+  elseif has_key(g:EclimAntUserDocs, element)
+    let url = g:EclimAntUserDocs[element]
+  else
+    let url = g:EclimAntDocDefaultUrl
+  endif
+
+  "let url = escape(url, '&%#')
+  "let url = escape(url, '%#')
+  let url = substitute(url, '<element>', element, 'g')
+
+  call eclim#web#OpenUrl(url)
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/ant/ivy.vim

@@ -0,0 +1,31 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/java/classpath.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2012  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" SetRepo(path) {{{
+" Sets the location of the ivy repository.
+function! eclim#java#ant#ivy#SetRepo(path)
+  call eclim#java#classpath#VariableCreate('IVY_REPO', a:path)
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/ant/util.vim

@@ -0,0 +1,36 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   Utility functions for working with ant.
+"
+" License:
+"
+" Copyright (C) 2005 - 2012  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" FindBuildFile() {{{
+" Finds the build file relative to the current file (like ant -find).
+function! eclim#java#ant#util#FindBuildFile()
+  let buildFile = eclim#util#Findfile('build.xml', fnamemodify(expand('%:p'), ':h') . ';')
+  if filereadable(buildFile)
+    return substitute(fnamemodify(buildFile, ':p'), '\', '/', 'g')
+  endif
+
+  return ''
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/classpath.vim

@@ -0,0 +1,241 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/java/classpath.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+  let s:command_variables = '-command java_classpath_variables'
+  let s:command_variable_create =
+    \ '-command java_classpath_variable_create -n "<name>" -p "<path>"'
+  let s:command_variable_delete =
+    \ '-command java_classpath_variable_delete -n "<name>"'
+
+  let s:entry_project =
+    \ "\t<classpathentry exported=\"true\" kind=\"src\" path=\"/<path>\"/>"
+  let s:entry ="\t<classpathentry kind=\"<kind>\" path=\"<path>\"/>"
+  let s:entry_sourcepath =
+    \ "\t<classpathentry kind=\"<kind>\" path=\"<path>\"\n\t\t\tsourcepath=\"<src>\"/>"
+  let s:entry_javadoc =
+    \ "\t<classpathentry kind=\"<kind>\" path=\"<path>\"\n" .
+    \ "\t\t\tsourcepath=\"<src>\">\n" .
+    \ "\t\t<attributes>\n" .
+    \ "\t\t\t<attribute name=\"javadoc_location\" value=\"<javadoc>\"/>\n" .
+    \ "\t\t</attributes>\n" .
+    \ "\t</classpathentry>"
+" }}}
+
+function! eclim#java#classpath#NewClasspathEntry(kind, arg, ...) " {{{
+  " Adds a new entry to the current .classpath file.
+  let template_name = 's:entry'
+  let args = {'kind': a:kind, 'path': substitute(a:arg, '\', '/', 'g')}
+  if a:0
+    if a:0 == 1
+      let template_name = 's:entry_sourcepath'
+      let args['src'] = substitute(a:1, '\', '/', 'g')
+    elseif a:0 == 2
+      let template_name = 's:entry_javadoc'
+      let args['src'] = substitute(a:1, '\', '/', 'g')
+      let javadoc = substitute(a:2, '\', '/', 'g')
+      let absolute = javadoc =~? '^\([a-z]:\)\?/'
+
+      " handle absolute vs project relative javadoc location
+      if absolute
+        " windows paths need a leading slash
+        if javadoc =~? '^[a-z]:/'
+          let javadoc = '/' . javadoc
+        endif
+        let javadoc = 'file:' . javadoc
+      else
+        if !eclim#project#util#IsCurrentFileInProject(1)
+          return
+        endif
+        if javadoc =~? '\.jar$'
+          let project = eclim#project#util#GetCurrentProjectName()
+          let javadoc = 'platform:/resource/' . project . '/' . javadoc
+        else
+          " relative dirs must be made absolute
+          let project = eclim#project#util#GetCurrentProjectRoot()
+          let javadoc = project . '/' . javadoc
+        endif
+      endif
+
+      if javadoc =~? '\.jar$'
+        let javadoc = 'jar:' . javadoc . '!/'
+      elseif javadoc !~ '^file:'
+        let javadoc = 'file:' . javadoc
+      endif
+      let args['javadoc'] = javadoc
+    else
+      call eclim#util#EchoError('Too many arguments.')
+      return
+    endif
+  endif
+
+  if exists(template_name . '_' . a:kind)
+    let template = {template_name}_{a:kind}
+  else
+    let template = {template_name}
+  endif
+
+  for [key, value] in items(args)
+    let template = substitute(template, '<' . key . '>', value, 'g')
+  endfor
+
+  let cline = line('.')
+  let ccol = col('.')
+  call s:MoveToInsertPosition()
+  let line = line('.')
+  call append(line, split(template, '\n'))
+  call cursor(cline + 1, ccol)
+endfunction " }}}
+
+function! s:MoveToInsertPosition() " {{{
+  " If necessary moves the cursor to a valid insert position.
+  let start = search('<classpath\s*>', 'wn')
+  let end = search('</classpath\s*>', 'wn')
+  if line('.') < start || line('.') >= end
+    call cursor(end - 1, 1)
+  endif
+endfunction " }}}
+
+function! eclim#java#classpath#GetVariableNames() " {{{
+  let variables = eclim#Execute(s:command_variables)
+  if type(variables) != g:LIST_TYPE
+    return []
+  endif
+  return map(variables, "v:val.name")
+endfunction " }}}
+
+function! eclim#java#classpath#VariableList() " {{{
+  let variables = eclim#Execute(s:command_variables)
+  if type(variables) != g:LIST_TYPE
+    return
+  endif
+  if len(variables) == 0
+    call eclim#util#Echo("No variables.")
+  endif
+
+  let pad = 0
+  for variable in variables
+    let pad = len(variable.name) > pad ? len(variable.name) : pad
+  endfor
+
+  let output = []
+  for variable in variables
+    call add(output, eclim#util#Pad(variable.name, pad) . ' - ' . variable.path)
+  endfor
+
+  call eclim#util#Echo(join(output, "\n"))
+endfunction " }}}
+
+function! eclim#java#classpath#VariableCreate(name, path) " {{{
+  let path = substitute(fnamemodify(a:path, ':p'), '\', '/', 'g')
+  if has('win32unix')
+    let path = eclim#cygwin#WindowsPath(path)
+  endif
+  let command = s:command_variable_create
+  let command = substitute(command, '<name>', a:name, '')
+  let command = substitute(command, '<path>', path, '')
+
+  let result = eclim#Execute(command)
+  if result != '0'
+    call eclim#util#Echo(result)
+  endif
+endfunction " }}}
+
+function! eclim#java#classpath#VariableDelete(name) " {{{
+  let command = s:command_variable_delete
+  let command = substitute(command, '<name>', a:name, '')
+
+  let result = eclim#Execute(command)
+  if result != '0'
+    call eclim#util#Echo(result)
+  endif
+endfunction " }}}
+
+function! eclim#java#classpath#CommandCompleteVar(argLead, cmdLine, cursorPos) " {{{
+  " Custom command completion for classpath var relative files.
+  let cmdTail = strpart(a:cmdLine, a:cursorPos)
+  let argLead = substitute(a:argLead, cmdTail . '$', '', '')
+
+  let vars = eclim#java#classpath#GetVariableNames()
+  call filter(vars, 'v:val =~ "\\M^' . argLead . '"')
+
+  return vars
+endfunction " }}}
+
+function! eclim#java#classpath#CommandCompleteVarPath(argLead, cmdLine, cursorPos) " {{{
+  " Custom command completion for classpath var relative files.
+  let cmdLine = strpart(a:cmdLine, 0, a:cursorPos)
+  let args = eclim#util#ParseCmdLine(cmdLine)
+  let argLead = cmdLine =~ '\s$' ? '' : args[len(args) - 1]
+
+  let vars = eclim#Execute(s:command_variables)
+
+  " just the variable name
+  if argLead !~ '/'
+    let var_names = deepcopy(vars)
+    call filter(var_names, 'v:val.name =~ "^' . argLead . '"')
+    if len(var_names) > 0
+      call map(var_names,
+        \ "isdirectory(v:val.path) ? v:val.name . '/' : v:val.name")
+    endif
+    return var_names
+  endif
+
+  " variable name + path
+  let var = substitute(argLead, '\(.\{-}\)/.*', '\1', '')
+  let var_dir = ""
+  for cv in vars
+    if cv.name =~ '^' . var
+      let var_dir = cv.path
+      break
+    endif
+  endfor
+  if var_dir == ''
+    return []
+  endif
+
+  let var_dir = escape(substitute(var_dir, '\', '/', 'g'), ' ')
+  let argLead = substitute(argLead, var, var_dir, '')
+  let files = eclim#util#CommandCompleteFile(argLead, a:cmdLine, a:cursorPos)
+  let replace = escape(var_dir, '\')
+  call map(files, "substitute(v:val, '" . replace . "', '" . var . "', '')")
+
+  return files
+endfunction " }}}
+
+function! eclim#java#classpath#CommandCompleteVarAndDir(argLead, cmdLine, cursorPos) " {{{
+  " Custom command completion for classpath var relative files.
+  let cmdLine = strpart(a:cmdLine, 0, a:cursorPos)
+  let args = eclim#util#ParseCmdLine(cmdLine)
+  let argLead = cmdLine =~ '\s$' ? '' : args[len(args) - 1]
+
+  " complete vars for first arg
+  if cmdLine =~ '^' . args[0] . '\s*' . escape(argLead, '~.\') . '$'
+    return eclim#java#classpath#CommandCompleteVar(argLead, a:cmdLine, a:cursorPos)
+  endif
+
+  return eclim#util#CommandCompleteDir(a:argLead, a:cmdLine, a:cursorPos)
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/complete.vim

@@ -0,0 +1,169 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Varables {{{
+  let s:complete_command =
+    \ '-command java_complete -p "<project>" -f "<file>" ' .
+    \ '-o <offset> -e <encoding> -l <layout>'
+" }}}
+
+function! eclim#java#complete#CodeComplete(findstart, base) " {{{
+  if !eclim#project#util#IsCurrentFileInProject(0)
+    return a:findstart ? -1 : []
+  endif
+
+  if a:findstart
+    call eclim#lang#SilentUpdate(1)
+
+    " locate the start of the word
+    let line = getline('.')
+
+    let start = col('.') - 1
+
+    "exceptions that break the rule
+    if line[start] == '.' && line[start - 1] != '.'
+      let start -= 1
+    endif
+
+    while start > 0 && line[start - 1] =~ '\w'
+      let start -= 1
+    endwhile
+
+    return start
+  else
+    let offset = eclim#util#GetOffset() + len(a:base)
+    let project = eclim#project#util#GetCurrentProjectName()
+    let file = eclim#lang#SilentUpdate(1, 0)
+    if file == ''
+      return []
+    endif
+
+    let command = s:complete_command
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+    let command = substitute(command, '<offset>', offset, '')
+    let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+    let command = substitute(command, '<layout>', g:EclimJavaCompleteLayout, '')
+
+    let completions = []
+    let response = eclim#Execute(command)
+    if type(response) != g:DICT_TYPE
+      return
+    endif
+
+    if has_key(response, 'imports') && len(response.imports)
+      let imports = response.imports
+      if exists('g:TestEclimWorkspace') " allow this to be tested somewhat
+        call eclim#java#complete#ImportThenComplete(imports)
+      else
+        let func = "eclim#java#complete#ImportThenComplete(" . string(imports) . ")"
+        call feedkeys("\<c-e>\<c-r>=" . func . "\<cr>", 'n')
+      endif
+      " prevents supertab's completion chain from attempting the next
+      " completion in the chain.
+      return -1
+    endif
+
+    if has_key(response, 'error') && len(response.completions) == 0
+      call eclim#util#EchoError(response.error.message)
+      return -1
+    endif
+
+    " if the word has a '.' in it (like package completion) then we need to
+    " strip some off according to what is currently in the buffer.
+    let prefix = substitute(getline('.'),
+      \ '.\{-}\([[:alnum:].]\+\%' . col('.') . 'c\).*', '\1', '')
+
+    " as of eclipse 3.2 it will include the parens on a completion result even
+    " if the file already has them.
+    let open_paren = getline('.') =~ '\%' . col('.') . 'c\s*('
+    let close_paren = getline('.') =~ '\%' . col('.') . 'c\s*(\s*)'
+
+    " when completing imports, the completions include ending ';'
+    let semicolon = getline('.') =~ '\%' . col('.') . 'c\s*;'
+
+    for result in response.completions
+      let word = result.completion
+
+      " strip off prefix if necessary.
+      if word =~ '\.'
+        let word = substitute(word, prefix, '', '')
+      endif
+
+      " strip off close paren if necessary.
+      if word =~ ')$' && close_paren
+        let word = strpart(word, 0, strlen(word) - 1)
+      endif
+
+      " strip off open paren if necessary.
+      if word =~ '($' && open_paren
+        let word = strpart(word, 0, strlen(word) - 1)
+      endif
+
+      " strip off semicolon if necessary.
+      if word =~ ';$' && semicolon
+        let word = strpart(word, 0, strlen(word) - 1)
+      endif
+
+      " if user wants case sensitivity, then filter out completions that don't
+      " match
+      if g:EclimJavaCompleteCaseSensitive && a:base != ''
+        if word !~ '^' . a:base . '\C'
+          continue
+        endif
+      endif
+
+      let menu = result.menu
+      let info = eclim#html#util#HtmlToText(result.info)
+
+      let dict = {
+          \ 'word': word,
+          \ 'menu': menu,
+          \ 'info': info,
+          \ 'kind': result.type,
+          \ 'dup': 1,
+          \ 'icase': !g:EclimJavaCompleteCaseSensitive,
+        \ }
+
+      call add(completions, dict)
+    endfor
+
+    return completions
+  endif
+endfunction " }}}
+
+function! eclim#java#complete#ImportThenComplete(choices) " {{{
+  " Called by CodeComplete when the completion depends on a missing import.
+  let choice = ''
+  if len(a:choices) > 1
+    let choice = eclim#java#import#ImportPrompt(a:choices)
+  elseif len(a:choices)
+    let choice = a:choices[0]
+  endif
+
+  if choice != ''
+    call eclim#java#import#Import(choice)
+    call feedkeys("\<c-x>\<c-u>", 'tn')
+  endif
+  return ''
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/correct.vim

@@ -0,0 +1,139 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/java/correct.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" define Correction group based on Normal.
+hi link Correction Normal
+hi Correction gui=underline,bold term=underline,bold cterm=underline,bold
+
+" Script Varables {{{
+  let s:command_correct =
+    \ '-command java_correct -p "<project>" -f "<file>" ' .
+    \ '-l <line> -o <offset> -e <encoding>'
+  let s:command_correct_apply = s:command_correct . ' -a <apply>'
+" }}}
+
+" Correct() {{{
+function! eclim#java#correct#Correct()
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  call eclim#lang#SilentUpdate()
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+
+  let command = s:command_correct
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<line>', line('.'), '')
+  let command = substitute(command, '<offset>', eclim#util#GetOffset(), '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+
+  let window_name = file . "_correct"
+  let filename = expand('%:p')
+  call eclim#util#TempWindowClear(window_name)
+
+  let result = eclim#Execute(command)
+
+  " error executing the command.
+  if type(result) != g:DICT_TYPE && type(result) != g:STRING_TYPE
+    return
+
+  " no error on the current line
+  elseif type(result) == g:STRING_TYPE
+    call eclim#util#Echo(result)
+    return
+
+  " no correction proposals found.
+  elseif len(result.corrections) == 0
+    call eclim#util#EchoInfo('No Suggestions')
+    return
+  endif
+
+  let content = []
+  call add(content, result.message)
+  for correction in result.corrections
+    call add(content,
+      \ correction.index . '.' . result.offset . ': ' . correction.description)
+    for line in split(correction.preview, '\n')
+      call add(content, line != '' ? ("\t" . line) : line)
+    endfor
+  endfor
+
+  call eclim#util#TempWindow(window_name, content)
+
+  let b:filename = filename
+  augroup temp_window
+    autocmd! BufWinLeave <buffer>
+    call eclim#util#GoToBufferWindowRegister(filename)
+  augroup END
+
+  setlocal ft=java
+
+  "exec "syntax match Normal /" . escape(getline(1), '^$/\') . "/"
+  syntax match Correction /^[0-9]\+\.[0-9]\+:.*/
+
+  nnoremap <silent> <buffer> <cr>
+    \ :call eclim#java#correct#CorrectApply()<cr>
+
+  redraw | echo ""
+endfunction " }}}
+
+" CorrectApply() {{{
+function! eclim#java#correct#CorrectApply()
+  let line = getline('.')
+  if line =~ '^[0-9]\+\.[0-9]\+:'
+    let winnr = bufwinnr('%')
+    let name = substitute(expand('%:p'), '_correct$', '', '')
+    let file_winnr = bufwinnr(bufnr('^' . b:filename))
+    if file_winnr != -1
+      let filename = b:filename
+      exec file_winnr . "winc w"
+      call eclim#lang#SilentUpdate()
+
+      let index = substitute(line, '^\([0-9]\+\)\..*', '\1', '')
+
+      let project = eclim#project#util#GetCurrentProjectName()
+      let file = eclim#project#util#GetProjectRelativeFilePath()
+      let command = s:command_correct_apply
+      let command = substitute(command, '<project>', project, '')
+      let command = substitute(command, '<file>', file, '')
+      let command = substitute(command, '<line>', line('.'), '')
+      let command = substitute(command, '<offset>', eclim#util#GetOffset(), '')
+      let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+      let command = substitute(command, '<apply>', index, '')
+
+      call eclim#lang#Refactor(command)
+      call eclim#lang#UpdateSrcFile('java', 1)
+
+      exec winnr . "winc w"
+      close
+    else
+      call eclim#util#EchoError(name . ' no longer found in an open window.')
+    endif
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/doc.vim

@@ -0,0 +1,269 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+let s:command_comment =
+  \ '-command javadoc_comment -p "<project>" -f "<file>" -o <offset> -e <encoding>'
+let s:command_element_doc =
+  \ '-command java_element_doc -p "<project>" -f "<file>" -o <offset> -l <length> -e <encoding>'
+let s:command_doc_link = '-command java_element_doc -u "<url>"'
+let s:command_source_dirs = '-command java_src_dirs -p "<project>"'
+" }}}
+
+function! eclim#java#doc#Comment() " {{{
+  " Add / update the comments for the element under the cursor.
+
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  call eclim#lang#SilentUpdate()
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let offset = eclim#util#GetCurrentElementOffset()
+
+  let command = s:command_comment
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<offset>', offset, '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+
+  let result =  eclim#Execute(command)
+
+  if result != "0"
+    call eclim#util#Reload({'retab': 1})
+    write
+  endif
+endfunction " }}}
+
+function! eclim#java#doc#Preview() " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  if !eclim#java#util#IsValidIdentifier(expand('<cword>'))
+    call eclim#util#EchoError
+      \ ("Element under the cursor is not a valid java identifier.")
+    return 0
+  endif
+
+  exec 'pedit +:call\ eclim#java#doc#PreviewOpen(' . bufnr('%') . ') [javadoc]'
+endfunction " }}}
+
+function! eclim#java#doc#PreviewOpen(bufnr_or_url) " {{{
+  if a:bufnr_or_url =~ '^\d\+$'
+    let curwin = winnr()
+    exec bufwinnr(a:bufnr_or_url) . 'winc w'
+
+    let project = eclim#project#util#GetCurrentProjectName()
+    let file = eclim#lang#SilentUpdate(1, 1)
+    let position = eclim#util#GetCurrentElementPosition()
+    let offset = substitute(position, '\(.*\);\(.*\)', '\1', '')
+    let length = substitute(position, '\(.*\);\(.*\)', '\2', '')
+
+    exec curwin . 'winc w'
+
+    let command = s:command_element_doc
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+    let command = substitute(command, '<offset>', offset, '')
+    let command = substitute(command, '<length>', length, '')
+    let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+  else
+    let command = s:command_doc_link
+    let command = substitute(command, '<url>', a:bufnr_or_url, '')
+  endif
+
+  let result =  eclim#Execute(command)
+  if type(result) == g:DICT_TYPE
+    if !exists('b:eclim_javadoc_stack')
+      let b:eclim_javadoc_stack = []
+      let b:eclim_javadoc_index = -1
+    elseif b:eclim_javadoc_index >= 0
+      let b:eclim_javadoc_stack = b:eclim_javadoc_stack[:b:eclim_javadoc_index]
+    endif
+    call add(b:eclim_javadoc_stack, result)
+    let b:eclim_javadoc_index += 1
+    let b:eclim_javadoc = result
+
+    setlocal modifiable
+    call append(0, split(result.text, '\n'))
+    retab
+    if getline('$') =~ '^\s*$'
+      $,$delete _
+    endif
+    call cursor(1, 1)
+
+  elseif type(result) == g:STRING_TYPE
+    if result == ''
+      call eclim#util#EchoWarning('No javadoc found.')
+    else
+      call eclim#util#EchoError(result)
+    endif
+
+    return
+  endif
+
+  setlocal wrap
+  setlocal nomodifiable
+  setlocal nolist
+  setlocal noswapfile
+  setlocal nobuflisted
+  setlocal buftype=nofile
+  setlocal bufhidden=wipe
+  setlocal conceallevel=2 concealcursor=ncv
+
+  set ft=javadoc_preview
+  hi link javadocPreviewLink Label
+  syntax match javadocPreviewLinkStart contained /|/ conceal
+  syntax match javadocPreviewLinkEnd contained /\[\d\+\]|/ conceal
+  syntax region javadocPreviewLink start="|" end="" concealends
+  syntax match javadocPreviewLink /|.\{-}\[\d\+\]|/
+    \ contains=JavadocPreviewLinkStart,JavadocPreviewLinkEnd
+
+  nnoremap <silent> <buffer> <cr> :call eclim#java#doc#PreviewLink()<cr>
+  nnoremap <silent> <buffer> <c-]> :call eclim#java#doc#PreviewLink()<cr>
+  nnoremap <silent> <buffer> <c-o> :call eclim#java#doc#PreviewHistory(-1)<cr>
+  nnoremap <silent> <buffer> <c-i> :call eclim#java#doc#PreviewHistory(1)<cr>
+endfunction " }}}
+
+function! eclim#java#doc#PreviewLink() " {{{
+  let line = getline('.')
+  let cnum = col('.')
+  if line[cnum - 1] == '|'
+    let cnum += cnum > 1 && line[cnum - 2] == ']' ? -1 : 1
+  endif
+  let text = substitute(line, '.*|\(.\{-}\%' . cnum . 'c.\{-}\)|.*', '\1', '')
+  if text == line || text !~ '\[\d\+]$'
+    return
+  endif
+
+  exec 'let index = ' . substitute(text, '.*\[\(\d\+\)\]$', '\1', '')
+  if !exists('b:eclim_javadoc') || len(b:eclim_javadoc.links) <= index
+    return
+  endif
+
+  let url = b:eclim_javadoc.links[index].href
+  if url =~ '^eclipse-javadoc:'
+    exec 'pedit +:call\ eclim#java#doc#PreviewOpen("' . url . '") [javadoc]'
+  else
+    call eclim#web#OpenUrl(url)
+  endif
+endfunction " }}}
+
+function! eclim#java#doc#PreviewHistory(offset) " {{{
+  if !exists('b:eclim_javadoc_stack')
+    return
+  endif
+
+  let index = b:eclim_javadoc_index + a:offset
+  if index < 0 || index > len(b:eclim_javadoc_stack) -1
+    return
+  endif
+
+  let result = b:eclim_javadoc_stack[index]
+  let b:eclim_javadoc = result
+  let b:eclim_javadoc_index = index
+
+  setlocal modifiable
+  1,$delete _
+  call append(0, split(result.text, '\n'))
+  retab
+  if getline('$') =~ '^\s*$'
+    $,$delete _
+  endif
+  setlocal nomodifiable
+  call cursor(1, 1)
+endfunction " }}}
+
+function! eclim#java#doc#Javadoc(bang, ...) " {{{
+  " Run javadoc for all, or the supplied, source files.
+  " Optional args:
+  "   file, file, file, ...: one ore more source files.
+
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  let project_path = eclim#project#util#GetCurrentProjectRoot()
+  let project = eclim#project#util#GetCurrentProjectName()
+  let args = '-p "' . project . '"'
+
+  if len(a:000) > 0 && (len(a:000) > 1 || a:000[0] != '')
+    let args .= ' -f "' . join(a:000, ' ') . '"'
+  endif
+
+  let cwd = getcwd()
+  try
+    exec 'lcd ' . escape(project_path, ' ')
+    call eclim#util#MakeWithCompiler('eclim_javadoc', a:bang, args)
+  finally
+    exec 'lcd ' . escape(cwd, ' ')
+  endtry
+endfunction " }}}
+
+function! eclim#java#doc#CommandCompleteJavadoc(argLead, cmdLine, cursorPos) " {{{
+  let dir = eclim#project#util#GetCurrentProjectRoot()
+
+  let cmdLine = strpart(a:cmdLine, 0, a:cursorPos)
+  let args = eclim#util#ParseCmdLine(cmdLine)
+  let argLead = cmdLine =~ '\s$' ? '' : args[len(args) - 1]
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let command = substitute(s:command_source_dirs, '<project>', project, '')
+  let result =  eclim#Execute(command)
+  let paths = []
+  if result != '' && result != '0'
+    let paths = map(split(result, "\n"),
+      \ "eclim#project#util#GetProjectRelativeFilePath(v:val)")
+  endif
+
+  let results = []
+
+  if argLead !~ '^\s*$'
+    let follow = 0
+    for path in paths
+      if argLead =~ '^' . path
+        let follow = 1
+        break
+      elseif  path =~ '^' . argLead
+        call add(results, path)
+      endif
+    endfor
+
+    if follow
+      let results = split(eclim#util#Glob(dir . '/' . argLead . '*', 1), '\n')
+      call filter(results, "isdirectory(v:val) || v:val =~ '\\.java$'")
+      call map(results, "substitute(v:val, '\\', '/', 'g')")
+      call map(results, 'isdirectory(v:val) ? v:val . "/" : v:val')
+      call map(results, 'substitute(v:val, dir, "", "")')
+      call map(results, 'substitute(v:val, "^\\(/\\|\\\\\\)", "", "g")')
+      call map(results, "substitute(v:val, ' ', '\\\\ ', 'g')")
+    endif
+  else
+    let results = paths
+  endif
+
+  return eclim#util#ParseCommandCompletionResults(argLead, results)
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/hierarchy.vim

@@ -0,0 +1,135 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+let s:command_hierarchy =
+  \ '-command java_hierarchy -p "<project>" -f "<file>" -o <offset> -e <encoding>'
+
+" }}}
+
+function! eclim#java#hierarchy#Hierarchy() " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let command = s:command_hierarchy
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<offset>', eclim#util#GetOffset(), '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+  let result = eclim#Execute(command)
+  if type(result) != g:DICT_TYPE
+    return
+  endif
+
+  let lines = []
+  let info = []
+  call s:FormatHierarchy(result, lines, info, '')
+  call eclim#util#TempWindow('[Hierarchy]', lines)
+  set ft=java
+
+  setlocal modifiable noreadonly
+  call append(line('$'), ['', '" use ? to view help'])
+  setlocal nomodifiable readonly
+  syntax match Comment /^".*/
+
+  let b:hierarchy_info = info
+  call eclim#util#Echo(b:hierarchy_info[line('.') - 1])
+
+  augroup eclim_java_hierarchy
+    autocmd!
+    autocmd CursorMoved <buffer>
+      \ if line('.') <= len(b:hierarchy_info) |
+      \   call eclim#util#Echo(b:hierarchy_info[line('.') - 1]) |
+      \ else |
+      \   echo '' |
+      \ endif
+  augroup END
+
+  nnoremap <buffer> <silent> <cr>
+    \ :call <SID>Open(g:EclimJavaHierarchyDefaultAction)<cr>
+  nnoremap <buffer> <silent> E :call <SID>Open('edit')<cr>
+  nnoremap <buffer> <silent> S :call <SID>Open('split')<cr>
+  nnoremap <buffer> <silent> T :call <SID>Open("tablast \| tabnew")<cr>
+
+  " assign to buffer var to get around weird vim issue passing list containing
+  " a string w/ a '<' in it on execution of mapping.
+  let b:hierarchy_help = [
+      \ '<cr> - open file with default action',
+      \ 'E - open with :edit',
+      \ 'S - open in a new split window',
+      \ 'T - open in a new tab',
+    \ ]
+  nnoremap <buffer> <silent> ?
+    \ :call eclim#help#BufferHelp(b:hierarchy_help, 'vertical', 40)<cr>
+endfunction " }}}
+
+function! s:FormatHierarchy(hierarchy, lines, info, indent) " {{{
+  call add(a:lines, a:indent . a:hierarchy.name)
+  call add(a:info, a:hierarchy.qualified)
+  let indent = eclim#util#GetIndent(1)
+  for child in a:hierarchy.children
+    call s:FormatHierarchy(child, a:lines, a:info, a:indent . indent)
+  endfor
+endfunction " }}}
+
+function! s:Open(action) " {{{
+  let line = line('.')
+  if line > len(b:hierarchy_info)
+    return
+  endif
+
+  let type = b:hierarchy_info[line - 1]
+  " go to the buffer that initiated the hierarchy
+  exec b:winnr . 'winc w'
+
+  " source the search plugin if necessary
+  if !exists("g:EclimJavaSearchSingleResult")
+    runtime autoload/eclim/java/search.vim
+  endif
+
+  let action = a:action
+  let filename = expand('%:p')
+  if exists('b:filename')
+    let filename = b:filename
+    if !eclim#util#GoToBufferWindow(b:filename)
+      " if the file is no longer open, open it
+      silent! exec action . ' ' . b:filename
+      let action = 'edit'
+    endif
+  endif
+
+  if line != 1
+    let saved = g:EclimJavaSearchSingleResult
+    try
+      let g:EclimJavaSearchSingleResult = action
+      if eclim#java#search#SearchAndDisplay('java_search', '-x declarations -p ' . type)
+        let b:filename = filename
+      endif
+    finally
+      let g:EclimJavaSearchSingleResult = saved
+    endtry
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/impl.vim

@@ -0,0 +1,346 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/java/impl.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Varables {{{
+  let s:command_constructor =
+    \ '-command java_constructor -p "<project>" -f "<file>" -o <offset> -e <encoding>'
+  let s:command_properties =
+    \ '-command java_bean_properties -p "<project>" -f "<file>" ' .
+    \ '-o <offset> -e <encoding> -t <type> -r <properties> <indexed>'
+  let s:command_impl =
+    \ '-command java_impl -p "<project>" -f "<file>" -o <offset> -e <encoding>'
+  let s:command_impl_insert =
+    \ '-command java_impl -p "<project>" -f "<file>" -t "<type>" ' .
+    \ '-s "<superType>" <methods>'
+  let s:command_delegate =
+    \ '-command java_delegate -p "<project>" -f "<file>" -o <offset> -e <encoding>'
+  let s:command_delegate_insert =
+    \ '-command java_delegate -p "<project>" -f "<file>" -v "<type>" ' .
+    \ '-s "<superType>" <methods>'
+
+
+  let s:no_properties =
+    \ 'Unable to find property at current cursor position: ' .
+    \ 'Not on a field declaration or possible java syntax error.'
+  let s:cross_type_selection = "Visual selection is currently limited to methods of one super type at a time."
+" }}}
+
+function! eclim#java#impl#Constructor(first, last, bang) " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  call eclim#lang#SilentUpdate()
+
+  let properties = a:last == 1 ? [] :
+    \ eclim#java#util#GetSelectedFields(a:first, a:last)
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+
+  let command = s:command_constructor
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<offset>', eclim#util#GetOffset(), '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+  if a:bang == ''
+    let command .= ' -s'
+  endif
+  if len(properties) > 0
+    let json = substitute(string(properties), "'", '"', 'g')
+    if has('win32') || has('win64')
+      let command .= ' -r "' . json . '"'
+    else
+      let command .= " -r '" . json . "'"
+    endif
+  endif
+
+  let result = eclim#Execute(command)
+  if type(result) == g:STRING_TYPE && result != ''
+    call eclim#util#EchoError(result)
+    return
+  endif
+
+  if result != "0"
+    call eclim#util#Reload({'retab': 1})
+    write
+  endif
+endfunction " }}}
+
+function! eclim#java#impl#GetterSetter(first, last, bang, type) " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  call eclim#lang#SilentUpdate()
+
+  let properties = eclim#java#util#GetSelectedFields(a:first, a:last)
+
+  if len(properties) == 0
+    call eclim#util#EchoError(s:no_properties)
+    return
+  endif
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let indexed = a:bang != '' ? '-i' : ''
+
+  let command = s:command_properties
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<offset>', eclim#util#GetOffset(), '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+  let command = substitute(command, '<type>', a:type, '')
+  let command = substitute(command, '<properties>', join(properties, ','), '')
+  let command = substitute(command, '<indexed>', indexed, '')
+
+  let result = eclim#Execute(command)
+  if result != "0"
+    call eclim#util#Reload({'retab': 1})
+    write
+  endif
+endfunction " }}}
+
+function! eclim#java#impl#Impl() " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  call eclim#lang#SilentUpdate()
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let offset = eclim#util#GetCurrentElementOffset()
+
+  let command = s:command_impl
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<offset>', offset, '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+
+  call eclim#java#impl#ImplWindow(command)
+endfunction " }}}
+
+function! eclim#java#impl#ImplWindow(command) " {{{
+  if (eclim#java#impl#Window(a:command, "impl"))
+    nnoremap <silent> <buffer> <cr> :call <SID>AddImpl(0)<cr>
+    vnoremap <silent> <buffer> <cr> :<C-U>call <SID>AddImpl(1)<cr>
+  endif
+endfunction " }}}
+
+function! eclim#java#impl#ImplWindowFolding() " {{{
+  setlocal foldmethod=syntax
+  setlocal foldlevel=99
+endfunction " }}}
+
+function! eclim#java#impl#Delegate() " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  call eclim#lang#SilentUpdate()
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let offset = eclim#util#GetCurrentElementOffset()
+  let encoding = eclim#util#GetEncoding()
+
+  let command = s:command_delegate
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<offset>', offset, '')
+  let command = substitute(command, '<encoding>', encoding, '')
+
+  call eclim#java#impl#DelegateWindow(command)
+endfunction " }}}
+
+function! eclim#java#impl#DelegateWindow(command) " {{{
+  if (eclim#java#impl#Window(a:command, "delegate"))
+    nnoremap <silent> <buffer> <cr> :call <SID>AddDelegate(0)<cr>
+    vnoremap <silent> <buffer> <cr> :<C-U>call <SID>AddDelegate(1)<cr>
+  endif
+endfunction " }}}
+
+function! eclim#java#impl#Add(command, function, visual) " {{{
+  let winnr = bufwinnr(bufnr('^' . b:filename))
+  " src window is not longer open.
+  if winnr == -1
+    call eclim#util#EchoError(b:filename . ' no longer found in an open window.')
+    return
+  endif
+
+  if a:visual
+    let start = line("'<")
+    let end = line("'>")
+  endif
+
+  let superType = ""
+  let methods = []
+  " non-visual mode or only one line selected
+  if !a:visual || start == end
+    " not a valid selection
+    if line('.') == 1 || getline('.') =~ '^\(\s*//\|package\|$\|}\)'
+      return
+    endif
+
+    let line = getline('.')
+    if line =~ '^\s*throws'
+      let line = getline(line('.') - 1)
+    endif
+    " on a method line
+    if line =~ '^\s\+'
+      call add(methods, s:MethodSig(line))
+      let ln = search('^\w', 'bWn')
+      if ln > 0
+        let superType = substitute(getline(ln), '.*\s\(.*\) {', '\1', '')
+      endif
+    " on a type line
+    else
+      let superType = substitute(line, '.*\s\(.*\) {', '\1', '')
+    endif
+
+  " visual mode
+  else
+    let pos = getpos('.')
+    let index = start
+    while index <= end
+      let line = getline(index)
+      if line =~ '^\s*\($\|throws\|package\)'
+        " do nothing
+      " on a method line
+      elseif line =~ '^\s\+'
+        call add(methods, s:MethodSig(line))
+        call cursor(index, 1)
+        let ln = search('^\w', 'bWn')
+        if ln > 0
+          let super = substitute(getline(ln), '.*\s\(.*\) {', '\1', '')
+          if superType != "" && super != superType
+            call eclim#util#EchoError(s:cross_type_selection)
+            call setpos('.', pos)
+            return
+          endif
+          let superType = super
+        endif
+      " on a type line
+      else
+        let super = substitute(line, '.*\s\(.*\) {', '\1', '')
+        if superType != "" && super != superType
+          call eclim#util#EchoError(s:cross_type_selection)
+          call setpos('.', pos)
+          return
+        endif
+        let superType = super
+      endif
+      call setpos('.', pos)
+
+      let index += 1
+    endwhile
+
+    if superType == ""
+      return
+    endif
+  endif
+
+  " search up for the nearest package
+  let ln = search('^package', 'bWn')
+  if ln > 0
+    let package = substitute(getline(ln), '.*\s\(.*\);', '\1', '')
+    let superType = package . '.' . substitute(superType, '<.\{-}>', '', 'g')
+  endif
+
+  let type = getline(1)
+  let impl_winnr = winnr()
+  exec winnr . "winc w"
+  call eclim#lang#SilentUpdate()
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+
+  let command = a:command
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<type>', type, '')
+  let command = substitute(command, '<superType>', superType, '')
+  if len(methods)
+    let json = substitute(string(methods), "'", '"', 'g')
+    let command = substitute(command, '<methods>', '-m ''' . json . '''', '')
+  else
+    let command = substitute(command, '<methods>', '', '')
+  endif
+
+  call a:function(command)
+
+  noautocmd exec winnr . "winc w"
+  call eclim#util#Reload({'retab': 1})
+  write
+  noautocmd exec impl_winnr . "winc w"
+endfunction " }}}
+
+function! eclim#java#impl#Window(command, name) " {{{
+  let name = eclim#project#util#GetProjectRelativeFilePath() . '_' . a:name
+  let project = eclim#project#util#GetCurrentProjectName()
+  let result = eclim#Execute(a:command, {'project': project})
+  if type(result) == g:STRING_TYPE
+    call eclim#util#EchoError(result)
+    return
+  endif
+  if type(result) != g:DICT_TYPE
+    return
+  endif
+
+  let content = [result.type]
+  for super in result.superTypes
+    call add(content, '')
+    call add(content, 'package ' . super.packageName . ';')
+    call add(content, super.signature . ' {')
+    for method in super.methods
+      let signature = split(method, '\n')
+      let content += map(signature, '"\t" . v:val')
+    endfor
+    call add(content, '}')
+  endfor
+
+  call eclim#util#TempWindow(name, content, {'preserveCursor': 1})
+  setlocal ft=java
+  call eclim#java#impl#ImplWindowFolding()
+  return 1
+endfunction " }}}
+
+function! s:AddImpl(visual) " {{{
+  call eclim#java#impl#Add
+    \ (s:command_impl_insert, function("eclim#java#impl#ImplWindow"), a:visual)
+endfunction " }}}
+
+function! s:AddDelegate(visual) " {{{
+  call eclim#java#impl#Add
+    \ (s:command_delegate_insert, function("eclim#java#impl#DelegateWindow"), a:visual)
+endfunction " }}}
+
+function! s:MethodSig(line) " {{{
+  let sig = substitute(a:line, '.*\s\(\w\+(.*\)', '\1', '')
+  let sig = substitute(sig, ',\s', ',', 'g')
+  let sig = substitute(sig, '<.\{-}>', '', 'g')
+  return sig
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/import.vim

@@ -0,0 +1,140 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/java/import.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+let s:command_import =
+  \ '-command java_import -p "<project>" -f "<file>" -o <offset> -e <encoding>'
+let s:command_organize =
+  \ '-command java_import_organize -p "<project>" -f "<file>" -o <offset> -e <encoding>'
+" }}}
+
+function! eclim#java#import#Import(...) " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  if !a:0
+    let name = expand('<cword>')
+    if !eclim#java#util#IsValidIdentifier(name) ||
+       \ eclim#java#util#IsKeyword(name)
+      call eclim#util#EchoError("'" . name . "' not a classname.")
+      return
+    endif
+  endif
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#lang#SilentUpdate()
+  let offset = eclim#util#GetOffset()
+  let command = s:command_import
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<offset>', offset, '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+  if a:0
+    let command .= ' -t ' . a:1
+  endif
+  let result = eclim#Execute(command)
+
+  if type(result) == g:STRING_TYPE
+    call eclim#util#EchoError(result)
+    return
+  endif
+
+  if type(result) == g:DICT_TYPE
+    call eclim#util#Reload({'pos': [result.line, result.column]})
+    call eclim#lang#UpdateSrcFile('java', 1)
+    if result.offset != offset
+      call eclim#util#Echo('Imported ' . (a:0 ? a:1 : ''))
+    endif
+    return
+  endif
+
+  if type(result) != g:LIST_TYPE
+    return
+  endif
+
+  let choice = eclim#java#import#ImportPrompt(result)
+  if choice != ''
+    call eclim#java#import#Import(choice)
+  endif
+endfunction " }}}
+
+function! eclim#java#import#OrganizeImports(...) " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#lang#SilentUpdate()
+  let offset = eclim#util#GetOffset()
+  let command = s:command_organize
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<offset>', offset, '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+  if a:0
+    let command .= ' -t ' . join(a:1, ',')
+  endif
+  let result = eclim#Execute(command)
+
+  if type(result) == g:STRING_TYPE
+    call eclim#util#EchoError(result)
+    return
+  endif
+
+  if type(result) == g:DICT_TYPE
+    call eclim#util#Reload({'pos': [result.line, result.column]})
+    call eclim#lang#UpdateSrcFile('java', 1)
+    return
+  endif
+
+  if type(result) != g:LIST_TYPE
+    return
+  endif
+
+  let chosen = []
+  for choices in result
+    let choice = eclim#java#import#ImportPrompt(choices)
+    if choice == ''
+      return
+    endif
+    call add(chosen, choice)
+  endfor
+
+  if len(chosen)
+    call eclim#java#import#OrganizeImports(chosen)
+  endif
+endfunction " }}}
+
+function! eclim#java#import#ImportPrompt(choices) " {{{
+  " prompt the user to choose the class to import.
+  let response = eclim#util#PromptList("Choose the class to import", a:choices)
+  if response == -1
+    return ''
+  endif
+
+  return get(a:choices, response)
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/junit.vim

@@ -0,0 +1,253 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/java/junit.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+let s:command_junit = '-command java_junit -p "<project>"'
+let s:command_tests = '-command java_junit_tests -p "<project>"'
+let s:command_find_test =
+  \ '-command java_junit_find_test -p "<project>" -f "<file>" ' .
+  \ '-o <offset> -e <encoding>'
+let s:command_impl = '-command java_junit_impl -p "<project>" -f "<file>"'
+let s:command_insert =
+  \ '-command java_junit_impl -p "<project>" -f "<file>" ' .
+  \ '-t "<type>" -s "<superType>" <methods>'
+" }}}
+
+function! eclim#java#junit#JUnit(test, bang) " {{{
+  let project = eclim#project#util#GetCurrentProjectName()
+  if project == '' && exists('b:project')
+    let project = b:project
+  endif
+
+  if project == ''
+    call eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  Validate
+  if len(getloclist(0)) > 0
+    call eclim#util#EchoError('Test case contains validation errors.')
+    return
+  endif
+
+  let command = s:command_junit
+  let command = substitute(command, '<project>', project, '')
+  if a:test != ''
+    if a:test == '%'
+      let command .= ' -f "' . eclim#project#util#GetProjectRelativeFilePath() . '"'
+    elseif a:test != '*'
+      let command .= ' -t "' . a:test . '"'
+    endif
+  else
+    let command .= ' -f "' . eclim#project#util#GetProjectRelativeFilePath() . '"'
+    let command .= ' -o ' . eclim#util#GetOffset()
+    let command .= ' -e ' . eclim#util#GetEncoding()
+  endif
+
+  let curbuf = bufnr('%')
+  let result = eclim#Execute(command, {'project': project, 'exec': 1, 'raw': 1})
+  let results = split(substitute(result, "^\n*", '', 'g'), "\n")
+  call eclim#util#TempWindow('[JUnit Output]', results)
+  let b:project = project
+
+  if exists(":JUnit") != 2
+    command -buffer -nargs=? -complete=customlist,eclim#java#junit#CommandCompleteTest
+      \ JUnit :call eclim#java#junit#JUnit('<args>', '<bang>')
+  endif
+
+  exec bufwinnr(curbuf) . 'winc w'
+endfunction " }}}
+
+function! eclim#java#junit#JUnitFindTest() " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  runtime eclim/autoload/eclim/java/search.vim
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#lang#SilentUpdate()
+  let command = s:command_find_test
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<offset>', eclim#util#GetOffset(), '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+  let result = eclim#Execute(command)
+  if type(result) == g:STRING_TYPE
+    call eclim#util#EchoError(result)
+    return
+  endif
+
+  if type(result) != g:DICT_TYPE
+    return
+  endif
+
+  call eclim#util#SetLocationList(eclim#util#ParseLocationEntries([result]))
+  let entry = getloclist(0)[0]
+  let name = substitute(bufname(entry.bufnr), '\', '/', 'g')
+  if g:EclimJavaSearchSingleResult != 'lopen'
+    call eclim#util#GoToBufferWindowOrOpen(name, g:EclimJavaSearchSingleResult)
+    call eclim#util#SetLocationList(eclim#util#ParseLocationEntries([result]))
+    call eclim#display#signs#Update()
+    call cursor(entry.lnum, entry.col)
+  else
+    exec 'lopen ' . g:EclimLocationListHeight
+  endif
+endfunction " }}}
+
+function! eclim#java#junit#JUnitResult(test) " {{{
+  " Argument test can be one of the following:
+  "   Empty string: Use the current file to determine the test result file.
+  "   Class name of a test: Locate the results for class (ex. 'TestMe').
+  "   The results dir relative results file name: TEST-org.foo.TestMe.xml
+
+  let path = s:GetResultsDir()
+  if path == ''
+    call eclim#util#EchoWarning(
+      \ "Output directory setting for 'junit' not set. " .
+      \ "Use :WorkspaceSettings or :ProjectSettings to set it.")
+    return
+  endif
+
+  if a:test != ''
+    let file = a:test
+    if file !~ '^TEST-'
+      let file = '*' . file
+    endif
+  else
+    let file = substitute(eclim#java#util#GetFullyQualifiedClassname(), '\.', '/', 'g')
+  endif
+
+  if file !~ '^TEST-'
+    let file = substitute(file, '\/', '.', 'g')
+    let file = 'TEST-' . file . '.xml'
+  endif
+
+  let found = eclim#util#Globpath(path, file)
+
+  " try text version if xml not found.
+  if found == ""
+    let file = fnamemodify(file, ':r') . '.txt'
+    let found = eclim#util#Globpath(path, file)
+  endif
+
+  if found != ""
+    let filename = expand('%:p')
+    exec "below split " . escape(found, ' ')
+
+    augroup temp_window
+      autocmd! BufWinLeave <buffer>
+      call eclim#util#GoToBufferWindowRegister(filename)
+    augroup END
+
+    return
+  endif
+  call eclim#util#Echo("Test result file not found for: " . fnamemodify(file, ':r'))
+endfunction " }}}
+
+function! eclim#java#junit#JUnitImpl() " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  call eclim#lang#SilentUpdate()
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let command = s:command_impl
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  call eclim#java#junit#JUnitImplWindow(command)
+endfunction " }}}
+
+function! eclim#java#junit#JUnitImplWindow(command) " {{{
+  if (eclim#java#impl#Window(a:command, "impl"))
+    nnoremap <silent> <buffer> <cr> :call <SID>AddTestImpl(0)<cr>
+    vnoremap <silent> <buffer> <cr> :<C-U>call <SID>AddTestImpl(1)<cr>
+  endif
+endfunction " }}}
+
+function! s:AddTestImpl(visual) " {{{
+  call eclim#java#impl#Add
+    \ (s:command_insert, function("eclim#java#junit#JUnitImplWindow"), a:visual)
+endfunction " }}}
+
+function! s:GetResultsDir() " {{{
+  let path = eclim#project#util#GetProjectSetting("org.eclim.java.junit.output_dir")
+  if type(path) == g:NUMBER_TYPE
+    return
+  endif
+
+  let root = eclim#project#util#GetCurrentProjectRoot()
+  let path = substitute(path, '<project>', root, '')
+  let path = path != '' && path !~ '/$' ? path . '/' : path
+  if path != '' && has('win32unix')
+    let path = eclim#cygwin#CygwinPath(path)
+  endif
+  return path
+endfunction " }}}
+
+function! eclim#java#junit#CommandCompleteTest(argLead, cmdLine, cursorPos) " {{{
+  let cmdTail = strpart(a:cmdLine, a:cursorPos)
+  let argLead = substitute(a:argLead, cmdTail . '$', '', '')
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  if project == '' && exists('b:project')
+    let project = b:project
+  endif
+  if project == ''
+    return []
+  endif
+
+  let command = s:command_tests
+  let command = substitute(command, '<project>', project, '')
+  let results = eclim#Execute(command)
+  if type(results) != g:LIST_TYPE
+    return []
+  endif
+
+  call filter(results, 'v:val =~ "' . argLead . '"')
+  return results
+endfunction " }}}
+
+function! eclim#java#junit#CommandCompleteResult(argLead, cmdLine, cursorPos) " {{{
+  let cmdTail = strpart(a:cmdLine, a:cursorPos)
+  let argLead = substitute(a:argLead, cmdTail . '$', '', '')
+
+  let path = s:GetResultsDir()
+  if path == ''
+    call eclim#util#EchoWarning(
+      \ "Output directory setting for 'junit' not set. " .
+      \ "Use :WorkspaceSettings or :ProjectSettings to set it.")
+    return []
+  endif
+
+  let results = split(eclim#util#Globpath(path, '*'), '\n')
+  call map(results, 'fnamemodify(v:val, ":r:e")')
+  call filter(results, 'v:val =~ "^' . argLead . '"')
+
+  return results
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/logging.vim

@@ -0,0 +1,127 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"  see http://eclim.org/vim/java/logging.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+function! eclim#java#logging#LoggingInit(var) " {{{
+  let char = nr2char(getchar())
+  " only execute if the user types a '.' for a method call and if the logger
+  " is not already present.
+  if char == '.' && s:InitLoggingSettings() &&
+    \ !search('\(final\|static\)\>.\{-}\<Log\(ger\)\?\s', 'n')
+    let line = line('.')
+    let col = col('.')
+    let position = eclim#java#util#GetClassDeclarationPosition(1)
+    if position
+      let logger = s:logger
+      let logger = substitute(logger, '\${class}', eclim#java#util#GetClassname(), '')
+      let logger = substitute(logger, '\${var}', a:var, '')
+      if strlen(logger) > &textwidth && logger !~ '\n'
+        let logger = substitute(logger,
+          \ '\(.*\)\s\(.*\)', '\1\n' . eclim#util#GetIndent(2) . '\2', '')
+      endif
+
+      let position = search('{')
+      let lines = split(logger, '\n')
+      let offset = len(lines) + 1
+      call append(position, '')
+      call append(position, lines)
+      call cursor(line + offset, col)
+      for import in s:logger_imports
+        call eclim#java#import#Import(import)
+      endfor
+    endif
+  endif
+  return char
+endfunction " }}}
+
+function! s:InitLoggingSettings() " {{{
+  let s:EclimLoggingImpl =
+    \ eclim#project#util#GetProjectSetting("org.eclim.java.logging.impl")
+  if type(s:EclimLoggingImpl) == g:NUMBER_TYPE || s:EclimLoggingImpl == '0'
+    unlet s:EclimLoggingImpl
+    return
+  endif
+
+  let indent = eclim#util#GetIndent(1)
+  if s:EclimLoggingImpl == "commons-logging"
+    let s:logger = indent .
+      \ "private static final Log ${var} = LogFactory.getLog(${class}.class);"
+    let s:logger_imports = [
+      \ "org.apache.commons.logging.Log",
+      \ "org.apache.commons.logging.LogFactory"]
+  elseif s:EclimLoggingImpl == "slf4j"
+    let s:logger = indent .
+      \ "private static final Logger ${var} = LoggerFactory.getLogger(${class}.class);"
+    let s:logger_imports = ["org.slf4j.Logger", "org.slf4j.LoggerFactory"]
+  elseif s:EclimLoggingImpl == "log4j"
+    let s:logger = indent .
+      \ "private static final Logger ${var} = Logger.getLogger(${class}.class);"
+    let s:logger_imports = ["org.apache.log4j.Logger"]
+  elseif s:EclimLoggingImpl == "jdk"
+    let s:logger = indent .
+      \ "private static final Logger ${var} = Logger.getLogger(${class}.class.getName());"
+    let s:logger_imports = ["java.util.logging.Logger"]
+  elseif s:EclimLoggingImpl == "custom"
+    let instance = eclim#client#nailgun#ChooseEclimdInstance()
+    if type(instance) != g:DICT_TYPE
+      return
+    endif
+
+    let name = eclim#project#util#GetProjectSetting("org.eclim.java.logging.template")
+    if type(name) == g:NUMBER_TYPE || name == ''
+      return
+    endif
+
+    let local = eclim#UserHome() . '/.eclim/resources/jdt/templates/' . name
+    let remote = substitute(instance.home, 'org.eclim_', 'org.eclim.jdt_', '') .
+      \ '/resources/templates/' . name
+    if filereadable(local)
+      let template = local
+    elseif filereadable(remote)
+      let template = remote
+    else
+      call eclim#util#EchoError(
+        \ "Custom logger template not found local or remote location:\n" .
+        \ "  local: " . local . "\n" .
+        \ "  remote: " . remote)
+      return
+    endif
+    let lines = readfile(template)
+    let s:logger_imports = lines[:]
+    call filter(s:logger_imports, "v:val =~ '^\\s*import\\>'")
+    call map(s:logger_imports,
+      \ "substitute(v:val, '^\\s*import\\>\\s*\\(.*\\);\\s*', '\\1', '')")
+    call filter(lines, "v:val !~ '\\(^\\s*$\\|^\\s*import\\>\\)'")
+    let s:logger = indent . join(lines, "\n" . indent)
+  elseif s:EclimLoggingImpl == ''
+    " no setting returned, probably not in a project, or user is attempting to
+    " disable this functionality for the current project.
+    return
+  else
+    echoe "Invalid logging implementation '" . s:EclimLoggingImpl . "' configured."
+    return
+  endif
+  return 1
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/maven.vim

@@ -0,0 +1,118 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+let s:update_command = '-command project_update -p "<project>" -b "<build>"'
+" }}}
+
+function! eclim#java#maven#SetClasspathVariable(cmd, variable, args) " {{{
+  let instance = eclim#client#nailgun#ChooseEclimdInstance()
+  if type(instance) != g:DICT_TYPE
+    return
+  endif
+
+  let workspace = instance.workspace
+
+  " maven 1.x
+  if a:cmd == 'Maven'
+    let prefs = workspace .
+      \ '/.metadata/.plugins/org.eclipse.jdt.core/pref_store.ini'
+    let command = a:cmd .
+      \ ' "-Dmaven.eclipse.workspace=' . workspace . '"' .
+      \ ' eclipse:add-maven-repo'
+
+  " maven 2.x
+  else
+    let prefs = workspace .
+      \ '/.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.jdt.core.prefs'
+    let command = a:cmd . ' ' . a:args .
+      \ ' "-Declipse.workspace=' . workspace . '"' .
+      \ ' eclipse:configure-workspace'
+  endif
+
+  call eclim#util#Exec(command)
+
+  if !v:shell_error
+    " the maven command edits the eclipse preference file directly, so in
+    " order to get the value in memory without restarting eclim, we read the
+    " value out and let the server set it again.
+    let winrestore = winrestcmd()
+
+    if filereadable(prefs)
+      silent exec 'sview ' . prefs
+      let line = search('org.eclipse.jdt.core.classpathVariable.' . a:variable, 'cnw')
+      let value = line ? substitute(getline(line), '.\{-}=\(.*\)', '\1', '') : ''
+      if line
+        call eclim#java#classpath#VariableCreate(a:variable, value)
+      endif
+
+      if substitute(bufname('%'), '\', '/', 'g') =~ prefs
+        close
+        exec winrestore
+      endif
+
+      if line
+        call eclim#util#Echo(a:variable . " classpath variable set to:\n" . value)
+      else
+        call eclim#util#EchoWarning(
+          \ "Unable to locate " . a:variable . " classpath variable.\n" .
+          \ "If it was successful set by maven, you may need to\n" .
+          \ "restart eclipse for the change to take affect.")
+      endif
+    else
+      call eclim#util#EchoWarning(
+        \ "Unable to read:\n" . prefs . "\n" .
+        \ "If the " . a:variable . " classpath variable was successfully set by maven\n" .
+        \ "you may need to restart eclipse for the change to take affect.")
+    endif
+  endif
+endfunction " }}}
+
+function! eclim#java#maven#UpdateClasspath() " {{{
+  " Updates the classpath on the server w/ the changes made to the current pom file.
+
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  " validate the xml first
+  if eclim#xml#validate#Validate(expand('%:p'), 0)
+    return
+  endif
+
+  let name = eclim#project#util#GetCurrentProjectName()
+  let command = s:update_command
+  let command = substitute(command, '<project>', name, '')
+  let command = substitute(command, '<build>', escape(expand('%:p'), '\'), '')
+  let result = eclim#Execute(command)
+
+  if type(result) == g:LIST_TYPE && len(result) > 0
+    let errors = eclim#util#ParseLocationEntries(
+      \ result, g:EclimValidateSortResults)
+    call eclim#util#SetLocationList(errors, 'r')
+    call eclim#util#EchoError(
+      \ "Operation contained errors.  See location list for details (:lopen).")
+  else
+    call eclim#util#ClearLocationList()
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/refactor.vim

@@ -0,0 +1,120 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2012  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Varables {{{
+  let s:command_rename = '-command java_refactor_rename ' .
+    \ '-p "<project>" -f "<file>" -o <offset> -e <encoding> -l <length> -n <name>'
+  let s:command_move = '-command java_refactor_move ' .
+    \ '-p "<project>" -f "<file>" -n <package>'
+" }}}
+
+function! eclim#java#refactor#Rename(name) " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  let element = expand('<cword>')
+  if !eclim#java#util#IsValidIdentifier(element)
+    call eclim#util#EchoError
+      \ ("Element under the cursor is not a valid java identifier.")
+    return
+  endif
+
+  let line = getline('.')
+  let package_pattern = '^\s*package\s\+\(.*\%' . col('.') . 'c\w*\).*;'
+  if line =~ package_pattern
+    let element = substitute(line, package_pattern, '\1', '')
+  endif
+
+  let prompt = printf('Rename "%s" to "%s"', element, a:name)
+  let result = exists('g:EclimRefactorPromptDefault') ?
+    \ g:EclimRefactorPromptDefault : eclim#lang#RefactorPrompt(prompt)
+  if result <= 0
+    return
+  endif
+
+  " update the file before vim makes any changes.
+  call eclim#lang#SilentUpdate()
+  wall
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let position = eclim#util#GetCurrentElementPosition()
+  let offset = substitute(position, '\(.*\);\(.*\)', '\1', '')
+  let length = substitute(position, '\(.*\);\(.*\)', '\2', '')
+
+  let command = s:command_rename
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<offset>', offset, '')
+  let command = substitute(command, '<length>', length, '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+  let command = substitute(command, '<name>', a:name, '')
+  " user chose preview at the prompt
+  if result == 2
+    let command .= ' -v'
+    call eclim#lang#RefactorPreview(command)
+    return
+  endif
+
+  call eclim#lang#Refactor(command)
+endfunction " }}}
+
+function! eclim#java#refactor#Move(package) " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  let line = getline('.')
+  let package_pattern = '^\s*package\s\+\(.*\%' . col('.') . 'c\w*\).*;'
+  if line =~ package_pattern
+    let element = substitute(line, package_pattern, '\1', '')
+  endif
+
+  let name = eclim#java#util#GetClassname()
+  let package = eclim#java#util#GetPackage()
+  let prompt = printf('Move %s from "%s" to "%s"', name, package, a:package)
+  let result = exists('g:EclimRefactorPromptDefault') ?
+    \ g:EclimRefactorPromptDefault : eclim#lang#RefactorPrompt(prompt)
+  if result <= 0
+    return
+  endif
+
+  " update the file before vim makes any changes.
+  call eclim#lang#SilentUpdate()
+  wall
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let command = s:command_move
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<package>', a:package, '')
+  " user chose preview at the prompt
+  if result == 2
+    let command .= ' -v'
+    call eclim#lang#RefactorPreview(command)
+    return
+  endif
+  call eclim#lang#Refactor(command)
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/search.vim

@@ -0,0 +1,409 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Varables {{{
+  let s:search_src = "java_search"
+  let s:search_doc = "java_docsearch"
+  let s:search_element =
+    \ '-command <search> -n "<project>" -f "<file>" ' .
+    \ '-o <offset> -e <encoding> -l <length> <args>'
+  let s:search_pattern = '-command <search>'
+  let s:options_map = {
+      \ '-p': [],
+      \ '-i': [],
+      \ '-a': ['split', 'vsplit', 'edit', 'tabnew', 'lopen'],
+      \ '-s': ['all', 'project'],
+      \ '-x': ['all', 'declarations', 'implementors', 'references'],
+      \ '-t': [
+        \ 'annotation',
+        \ 'class',
+        \ 'classOrEnum',
+        \ 'classOrInterface',
+        \ 'constructor',
+        \ 'enum',
+        \ 'field',
+        \ 'interface',
+        \ 'method',
+        \ 'package',
+        \ 'type',
+      \ ],
+    \ }
+
+  let s:search_alt_all = '\<<element>\>'
+  let s:search_alt_references = s:search_alt_all
+  let s:search_alt_implementors =
+    \ '\(implements\|extends\)\_[0-9A-Za-z,[:space:]]*\<<element>\>\_[0-9A-Za-z,[:space:]]*{'
+" }}}
+
+function! s:Search(command, ...) " {{{
+  " Executes a search.
+  " Usage closely resebles eclim command line client usage.
+  " When doing a non-pattern search the element under the cursor is searched for.
+  "   Search for declarations of element under the cursor
+  "     call s:Search("-x", "declarations")
+  "   Search for references of HashMap
+  "     call s:Search("-p", "HashM*", "-t", "class", "-x", "references")
+  " Or all the arguments can be passed in at once:
+  "   call s:Search("-p 'HashM*' -t class -x references")
+
+  let argline = ""
+  let index = 1
+  while index <= a:0
+    if index != 1
+      let argline = argline . " "
+    endif
+    let argline = argline . a:{index}
+    let index = index + 1
+  endwhile
+
+  " check if pattern supplied without -p.
+  if argline !~ '^\s*-[a-z]' && argline !~ '^\s*$'
+    let argline = '-p ' . argline
+  endif
+
+  let in_project = eclim#project#util#IsCurrentFileInProject(0)
+
+  " element search
+  if argline !~ '-p\>'
+    if &ft != 'java'
+      call eclim#util#EchoWarning
+        \ ("Element searches only supported in java source files.")
+      return 0
+    endif
+
+    if !eclim#java#util#IsValidIdentifier(expand('<cword>'))
+      call eclim#util#EchoError
+        \ ("Element under the cursor is not a valid java identifier.")
+      return 0
+    endif
+
+    if !in_project
+      " build a pattern search and execute it
+      let results = s:SearchAlternate('-p ' . s:BuildPattern() . ' ' . argline, 1)
+      " kind of gross. if there was no alternate result and eclimd is not
+      " running, then make sure a message is echoed to the user so they know
+      " that eclimd not running *may* be the cause of no results.
+      if len(results) == 0 && !eclim#EclimAvailable()
+        return 0
+      endif
+      return results
+    endif
+
+    let project = eclim#project#util#GetCurrentProjectName()
+    let file = eclim#project#util#GetProjectRelativeFilePath()
+    let position = eclim#util#GetCurrentElementPosition()
+    let offset = substitute(position, '\(.*\);\(.*\)', '\1', '')
+    let length = substitute(position, '\(.*\);\(.*\)', '\2', '')
+
+    let search_cmd = s:search_element
+    let search_cmd = substitute(search_cmd, '<project>', project, '')
+    let search_cmd = substitute(search_cmd, '<search>', a:command, '')
+    let search_cmd = substitute(search_cmd, '<file>', file, '')
+    let search_cmd = substitute(search_cmd, '<offset>', offset, '')
+    let search_cmd = substitute(search_cmd, '<encoding>', eclim#util#GetEncoding(), '')
+    let search_cmd = substitute(search_cmd, '<length>', length, '')
+    let search_cmd = substitute(search_cmd, '<args>', argline, '')
+
+    let result = eclim#Execute(search_cmd)
+
+  " pattern search
+  else
+    let project = eclim#project#util#GetCurrentProjectName()
+
+    " pattern search
+    let search_cmd = s:search_pattern
+    let search_cmd = substitute(search_cmd, '<search>', a:command, '')
+    if project != ''
+      let search_cmd .= ' -n "' . project . '"'
+    endif
+    let file = eclim#project#util#GetProjectRelativeFilePath()
+    if file != ''
+      let search_cmd .= ' -f "' . file . '"'
+    endif
+    let search_cmd .= ' ' . argline
+    " quote the search pattern
+    let search_cmd =
+      \ substitute(search_cmd, '\(.*-p\s\+\)\(.\{-}\)\(\s\|$\)\(.*\)', '\1"\2"\3\4', '')
+
+    let result =  eclim#Execute(search_cmd)
+
+    if !in_project && filereadable(expand('%'))
+      return result + s:SearchAlternate(argline, 0)
+    endif
+  endif
+
+  return result
+endfunction " }}}
+
+function! s:SearchAlternate(argline, element) " {{{
+  " Alternate search for non-project src files using vimgrep and &path.
+
+  call eclim#util#EchoInfo("Executing alternate search...")
+  if a:argline =~ '-t'
+    call eclim#util#EchoError
+      \ ("Alternate search doesn't support the type (-t) option yet.")
+    return []
+  endif
+  let search_pattern = ""
+  if a:argline =~ '-x all'
+    let search_pattern = s:search_alt_all
+  elseif a:argline =~ '-x implementors'
+    let search_pattern = s:search_alt_implementors
+  elseif a:argline =~ '-x references'
+    let search_pattern = s:search_alt_references
+  endif
+
+  let pattern = substitute(a:argline, '.*-p\s\+\(.\{-}\)\(\s.*\|$\)', '\1', '')
+  let file_pattern = substitute(pattern, '\.', '/', 'g') . ".java"
+
+  " search relative to the current dir first.
+  let package_path = substitute(eclim#java#util#GetPackage(), '\.', '/', 'g')
+  let path = substitute(expand('%:p:h'), '\', '/', 'g')
+  let path = substitute(path, package_path, '', '')
+  let files = split(eclim#util#Globpath(path, "**/" . file_pattern), '\n')
+
+  " if none found, then search the path.
+  if len(files) == 0
+    let files = eclim#util#FindFileInPath(file_pattern, 1)
+    let path = ""
+  endif
+
+  let results = []
+
+  if len(files) > 0 && search_pattern != ''
+    " narrow down to, hopefully, a distribution path for a narrower search.
+    let response = eclim#util#PromptList(
+      \ "Multiple type matches. Please choose the relevant file.",
+      \ files, g:EclimHighlightInfo)
+    if response == -1
+      return
+    endif
+
+    let file = substitute(get(files, response), '\', '/', 'g')
+    if path == ""
+      let path = eclim#util#GetPathEntry(file)
+    endif
+    let path = escape(path, '/\')
+    let path = substitute(file, '\(' . path . '[/\\]\?.\{-}[/\\]\).*', '\1', '')
+    let pattern = substitute(pattern, '\*', '.\\\\{-}', 'g')
+    let search_pattern = substitute(search_pattern, '<element>', pattern, '')
+    let command = "vimgrep /" . search_pattern . "/gj " . path . "**/*.java"
+    silent! exec command
+
+    let loclist = getloclist(0)
+    for entry in loclist
+      let bufname = bufname(entry.bufnr)
+      let result = {
+          \ 'filename': bufname,
+          \ 'message': entry.text,
+          \ 'line': entry.lnum,
+          \ 'column': entry.col,
+        \ }
+      " when searching for implementors, prevent dupes from the somewhat
+      " greedy pattern search (may need some more updating post conversion to
+      " dict results).
+      if a:argline !~ '-x implementors' || !eclim#util#ListContains(results, result)
+        call add(results, result)
+      endif
+    endfor
+  elseif len(files) > 0
+    for file in files
+      let fully_qualified = eclim#java#util#GetPackage(file) . '.' .
+        \ eclim#java#util#GetClassname(file)
+      " if an element search, filter out results that are not imported.
+      if !a:element || eclim#java#util#IsImported(fully_qualified)
+        call add(results, {
+            \ 'filename': file,
+            \ 'message': fully_qualified,
+            \ 'line': 1,
+            \ 'column': 1,
+          \ })
+      endif
+    endfor
+  endif
+  call eclim#util#Echo(' ')
+  return results
+endfunction " }}}
+
+function! s:BuildPattern() " {{{
+  " Builds a pattern based on the cursors current position in the file.
+
+  let class = expand('<cword>')
+  " see if the classname element selected is fully qualified.
+  let line = getline('.')
+  let package =
+    \ substitute(line, '.*\s\([0-9A-Za-z._]*\)\.' . class . '\>.*', '\1', '')
+
+  " not fully qualified, so attempt to determine package from import.
+  if package == line
+    let package = eclim#java#util#GetPackageFromImport(class)
+
+    " maybe the element is the current class?
+    if package == ""
+      if eclim#java#util#GetClassname() == class
+        let package = eclim#java#util#GetPackage()
+      endif
+    endif
+  endif
+
+  if package != ""
+    return package . "." . class
+  endif
+  return class
+endfunction " }}}
+
+function! eclim#java#search#SearchAndDisplay(type, args) " {{{
+  " Execute a search and displays the results via quickfix.
+
+  " if running from a non java source file, no SilentUpdate needed.
+  if &ft == 'java'
+    call eclim#lang#SilentUpdate()
+  endif
+
+  let argline = a:args
+
+  " check if just a pattern was supplied.
+  if argline =~ '^\s*\w'
+    let argline = '-p ' . argline
+  endif
+
+  " check for user supplied open action
+  let [action_args, argline] = eclim#util#ExtractCmdArgs(argline, '-a:')
+  let action = len(action_args) == 2 ? action_args[1] : g:EclimJavaSearchSingleResult
+
+  let results = s:Search(a:type, argline)
+  if type(results) != g:LIST_TYPE
+    return
+  endif
+  if !empty(results)
+    if a:type == 'java_search'
+      call eclim#util#SetLocationList(eclim#util#ParseLocationEntries(results))
+      let locs = getloclist(0)
+      " if only one result and it's for the current file, just jump to it.
+      " note: on windows the expand result must be escaped
+      if len(results) == 1 && locs[0].bufnr == bufnr('%')
+        if results[0].line != 1 && results[0].column != 1
+          lfirst
+        endif
+
+      " single result in another file
+      elseif len(results) == 1 && action != 'lopen'
+        let entry = getloclist(0)[0]
+        let name = substitute(bufname(entry.bufnr), '\', '/', 'g')
+        call eclim#util#GoToBufferWindowOrOpen(name, action)
+        call eclim#util#SetLocationList(eclim#util#ParseLocationEntries(results))
+        call eclim#display#signs#Update()
+        call cursor(entry.lnum, entry.col)
+
+      " multiple results and user specified an action other than lopen
+      elseif len(results) && len(action_args) && action != 'lopen'
+        let locs = getloclist(0)
+        let files = map(copy(locs),  'printf(' .
+          \ '"%s|%s col %s| %s", ' .
+          \ 'bufname(v:val.bufnr), v:val.lnum, v:val.col, v:val.text)')
+        let response = eclim#util#PromptList(
+          \ 'Please choose the file to ' . action,
+          \ files, g:EclimHighlightInfo)
+        if response == -1
+          return
+        endif
+        let entry = locs[response]
+        let name = substitute(bufname(entry.bufnr), '\', '/', 'g')
+        call eclim#util#GoToBufferWindowOrOpen(name, action)
+        call eclim#display#signs#Update()
+        call cursor(entry.lnum, entry.col)
+
+      else
+        exec 'lopen ' . g:EclimLocationListHeight
+      endif
+    elseif a:type == 'java_docsearch'
+      let window_name = "javadoc_search_results"
+      let filename = expand('%:p')
+      call eclim#util#TempWindowClear(window_name)
+
+      if len(results) == 1 && g:EclimJavaDocSearchSingleResult == 'open'
+        let entry = results[0]
+        call s:ViewDoc(entry)
+      else
+        call eclim#util#TempWindow(
+          \ window_name, results, {'height': g:EclimLocationListHeight})
+
+        nnoremap <silent> <buffer> <cr> :call <SID>ViewDoc()<cr>
+        augroup temp_window
+          autocmd! BufWinLeave <buffer>
+          call eclim#util#GoToBufferWindowRegister(filename)
+        augroup END
+      endif
+    endif
+    return 1
+  else
+    if argline =~ '-p '
+      let searchedFor = substitute(argline, '.*-p \(.\{-}\)\( .*\|$\)', '\1', '')
+      call eclim#util#EchoInfo("Pattern '" . searchedFor . "' not found.")
+    elseif &ft == 'java'
+      if !eclim#java#util#IsValidIdentifier(expand('<cword>'))
+        return
+      endif
+
+      let searchedFor = expand('<cword>')
+      call eclim#util#EchoInfo("No results for '" . searchedFor . "'.")
+    endif
+  endif
+endfunction " }}}
+
+function! s:ViewDoc(...) " {{{
+  " View the supplied file in a browser, or if none proved, the file under the
+  " cursor.
+  let url = a:0 > 0 ? a:1 : substitute(getline('.'), '\(.\{-}\)|.*', '\1', '')
+  call eclim#web#OpenUrl(url)
+endfunction " }}}
+
+function! eclim#java#search#CommandCompleteSearch(argLead, cmdLine, cursorPos) " {{{
+  let options_map = s:options_map
+  " omit the -a args on a javadoc search since those results are opened in a
+  " browser
+  if a:cmdLine =~ '^JavaDocS'
+    let options_map = copy(options_map)
+    unlet options_map['-a']
+  endif
+  return eclim#util#CommandCompleteOptions(
+    \ a:argLead, a:cmdLine, a:cursorPos, options_map)
+endfunction " }}}
+
+function! eclim#java#search#CommandCompleteSearchContext(argLead, cmdLine, cursorPos) " {{{
+  let options_map = {'-a': s:options_map['-a']}
+  return eclim#util#CommandCompleteOptions(
+    \ a:argLead, a:cmdLine, a:cursorPos, options_map)
+endfunction " }}}
+
+function! eclim#java#search#FindClassDeclaration() " {{{
+  " Used by non java source files to find the declaration of a classname under
+  " the cursor.
+  let line = getline('.')
+  let class = substitute(line,
+    \ '.\{-}\([0-9a-zA-Z_.]*\%' . col('.') . 'c[0-9a-zA-Z_.]*\).*', '\1', '')
+  if class != line && class != '' && class =~ '^[a-zA-Z]'
+    call eclim#java#search#SearchAndDisplay(
+      \ 'java_search', '-t classOrInterface -p ' . class)
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/src.vim

@@ -0,0 +1,88 @@
+" Author:  Eric Van Dewoestine
+"
+" License: " {{{
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+  let s:format_command =
+    \ '-command java_format -p "<project>" -f "<file>" ' .
+    \ '-h <hoffset> -t <toffset> -e <encoding>'
+  let s:checkstyle_command = '-command java_checkstyle -p "<project>" -f "<file>"'
+" }}}
+
+function! eclim#java#src#Format(first, last) " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  call eclim#lang#SilentUpdate()
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+
+  let command = s:format_command
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let begin = eclim#util#GetOffset(a:first, 1)
+  let end = eclim#util#GetOffset(a:last, 1) + len(getline(a:last)) - 1
+  let command = substitute(command, '<hoffset>', begin, '')
+  let command = substitute(command, '<toffset>', end, '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+
+  let result = eclim#Execute(command)
+  if result != "0"
+    call eclim#util#Reload({'retab': 1})
+    write
+  endif
+endfunction " }}}
+
+function! eclim#java#src#Checkstyle() " {{{
+  let project = eclim#project#util#GetCurrentProjectName()
+  if project != ""
+    let config =
+      \ eclim#project#util#GetProjectSetting('org.eclim.java.checkstyle.config')
+    if type(config) == g:NUMBER_TYPE
+      return
+    endif
+
+    if config == ''
+      call eclim#util#EchoWarning(
+        \ "Before invoking checkstyle, you must first configure the " .
+        \ "location of your\ncheckstyle config via the setting:  " .
+        \ "'org.eclim.java.checkstyle.config'.")
+      return
+    endif
+
+    let file = eclim#project#util#GetProjectRelativeFilePath()
+    let command = s:checkstyle_command
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+
+    let result = eclim#Execute(command)
+    if type(result) == g:LIST_TYPE && len(result) > 0
+      let errors = eclim#util#ParseLocationEntries(
+        \ result, g:EclimValidateSortResults)
+      call eclim#util#SetLocationList(errors)
+    else
+      call eclim#util#ClearLocationList('checkstyle')
+    endif
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/tools.vim

@@ -0,0 +1,310 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/java/tools.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+  let s:command_src_find = '-command java_src_find -p "<project>" -c "<classname>"'
+
+  let s:entry_match{'junit'} = 'Tests run:'
+  let s:entry_text_replace{'junit'} = '.*[junit] '
+  let s:entry_text_with{'junit'} = ''
+
+  let s:entry_match{'testng'} = 'eclim testng:'
+  let s:entry_text_replace{'testng'} = '.*eclim testng: .\{-}:'
+  let s:entry_text_with{'testng'} = ''
+
+  let s:open_console = 'Open jconsole'
+  let s:view_info = 'View Info'
+  let s:view_stacks = 'View Stacks'
+  let s:view_map = 'View Memory Map'
+  let s:args_main = 'Arguments To Main Method'
+  let s:args_vm = 'Arguments To JVM'
+
+  let s:supported_command = '\(' .
+      \ s:open_console . '\|' .
+      \ s:view_info . '\|' .
+      \ s:view_stacks . '\|' .
+      \ s:view_map .
+    \ '\)'
+
+  hi link JpsArguments Normal
+  hi link JpsViewAdditional Normal
+  hi JpsViewAdditional gui=underline,bold term=underline,bold cterm=underline,bold
+" }}}
+
+function! eclim#java#tools#MakeWithJavaBuildTool(compiler, bang, args) " {{{
+  augroup eclim_make_java_test
+    autocmd!
+    autocmd QuickFixCmdPost make
+      \ call eclim#java#tools#ResolveQuickfixResults(['junit', 'testng'])
+  augroup END
+
+  try
+    call eclim#util#MakeWithCompiler(a:compiler, a:bang, a:args)
+  finally
+    silent! autocmd! eclim_make_java_test
+  endtry
+endfunction " }}}
+
+function! eclim#java#tools#ResolveQuickfixResults(frameworks) " {{{
+  " Invoked after a :make to resolve any junit results in the quickfix entries.
+  let frameworks = type(a:frameworks) == g:LIST_TYPE ? a:frameworks : [a:frameworks]
+  let entries = getqflist()
+  let newentries = []
+  for entry in entries
+    let filename = bufname(entry.bufnr)
+    let text = entry.text
+
+    for framework in frameworks
+      if entry.text =~ s:entry_match{framework}
+        let filename = fnamemodify(filename, ':t')
+        let text = substitute(text,
+          \ s:entry_text_replace{framework}, s:entry_text_with{framework}, '')
+
+        let project = eclim#project#util#GetCurrentProjectName()
+        let command = s:command_src_find
+        let command = substitute(command, '<project>', project, '')
+        let command = substitute(command, '<classname>', filename, '')
+        let filename = eclim#Execute(command)
+        if filename == ''
+          " file not found.
+          continue
+        endif
+      endif
+    endfor
+
+    if !filereadable(filename)
+      continue
+    endif
+
+    let newentry = {
+        \ 'filename': filename,
+        \ 'lnum': entry.lnum,
+        \ 'col': entry.col,
+        \ 'type': entry.type,
+        \ 'text': text
+      \ }
+    call add(newentries, newentry)
+  endfor
+
+  call setqflist(newentries, 'r')
+
+  " vim is finicky about changing the quickfix list during a QuickFixCmdPost
+  " autocmd, so force a delayed reload of the quickfix results
+  call eclim#util#DelayedCommand('call setqflist(getqflist(), "r")')
+endfunction " }}}
+
+function! eclim#java#tools#Jps() " {{{
+  call eclim#util#Echo('Executing...')
+
+  let content = []
+  let processes = eclim#java#tools#GetJavaProcesses()
+  if len(processes) == 1 && string(processes[0]) == '0'
+    return
+  endif
+
+  for process in processes
+    if len(content) > 0
+      call add(content, "")
+    endif
+
+    call add(content, process.id . ' - ' . process.name)
+
+    if executable('jconsole')
+      call add(content, "\t" . s:open_console)
+    endif
+
+    if executable('jinfo')
+      call add(content, "\t" . s:view_info)
+    endif
+
+    if executable('jstack')
+      call add(content, "\t" . s:view_stacks)
+    endif
+
+    if executable('jmap')
+      call add(content, "\t" . s:view_map)
+    endif
+
+    call add(content, "")
+
+    call add(content, "\t" . s:args_main . " {")
+    let args_main = has_key(process, 'args_main') ?
+      \ map(split(process.args_main), '"\t\t" . v:val') : []
+    let content = content + args_main
+    call add(content, "\t}")
+
+    if has_key(process, 'args_vm')
+      call add(content, "")
+      call add(content, "\t" . s:args_vm . " {")
+      let args_vm = map(split(process.args_vm), '"\t\t" . v:val')
+      let content = content + args_vm
+      call add(content, "\t}")
+    endif
+  endfor
+
+  if len(content) == 0
+    call add(content, 'No Running Java Processes Found')
+  endif
+
+  call eclim#util#TempWindow('Java_Processes', content)
+
+  setlocal ft=jps_list
+  setlocal foldmethod=syntax
+  setlocal foldlevel=0
+  setlocal foldtext=getline(v:foldstart)
+
+  exec 'syntax match JpsViewAdditional /' . s:supported_command . '$/'
+  exec 'syntax region JpsArguments start=/' . s:args_main . ' {$/ end=/^\s*}$/ fold'
+  exec 'syntax region JpsArguments start=/' . s:args_vm . ' {$/ end=/^\s*}$/ fold'
+
+  nnoremap <silent> <buffer> <cr> :call <SID>ViewAdditionalInfo()<cr>
+
+  call eclim#util#Echo(' ')
+endfunction " }}}
+
+function! eclim#java#tools#GetJavaProcesses() " {{{
+  let java_processes = []
+  let result = eclim#util#System('jps -vV')
+  if v:shell_error
+    call eclim#util#EchoError('Unable to execute jps - ' . result)
+    return [0]
+  endif
+  let vm_args = split(result, '\n')
+  for process in split(eclim#util#System('jps -lm'), '\n')
+    if process =~ 'sun.tools.jps.Jps' "|| process =~ '^[0-9]\+\s*$'
+      continue
+    endif
+
+    let java_process_info = {}
+    let java_process_info['id'] = substitute(process, '\(.\{-}\) .*', '\1', '')
+    let java_process_info['name'] =
+      \ substitute(process, '.\{-} \(.\{-}\) .*', '\1', '')
+    if process =~ '.\{-} .\{-} \(.*\)'
+      let java_process_info['args_main'] =
+        \ substitute(process, '.\{-} .\{-} \(.*\)', '\1', '')
+    endif
+
+    let index = 0
+    for args in vm_args
+      if args =~ '^' . java_process_info.id . '\>'
+        if args =~ '.\{-} .\{-} \(.*\)'
+          let java_process_info['args_vm'] =
+            \ substitute(args, '.\{-} .\{-} \(.*\)', '\1', '')
+        endif
+        call remove(vm_args, index)
+      endif
+      let index += 1
+    endfor
+
+    call add(java_processes, java_process_info)
+  endfor
+  return java_processes
+endfunction " }}}
+
+function! s:ViewAdditionalInfo() " {{{
+  let line = getline('.')
+  if line =~ '^\s*' . s:supported_command . '$'
+    " get the process id.
+    let lnum = search('^[0-9]\+ - ', 'bn')
+    let id = substitute(getline(lnum), '^\([0-9]\+\) - .*', '\1', '')
+
+    if line =~ '^\s*' . s:open_console . '$'
+      call s:OpenConsole(id)
+    elseif line =~ '^\s*' . s:view_info . '$'
+      call s:ViewInfo(id)
+    elseif line =~ '^\s*' . s:view_stacks . '$'
+      call s:ViewStacks(id)
+    elseif line =~ '^\s*' . s:view_map . '$'
+      call s:ViewMap(id)
+    endif
+  endif
+endfunction " }}}
+
+function! s:OpenConsole(id) " {{{
+  call eclim#util#Echo('Executing...')
+
+  if has('win32') || has('win64')
+    call eclim#util#Exec('silent! !start jconsole ' . a:id)
+  else
+    call eclim#util#Exec('silent! !jconsole ' . a:id . ' &')
+  endif
+  exec "normal! \<c-l>"
+
+  call eclim#util#Echo(' ')
+endfunction " }}}
+
+function! s:ViewInfo(id) " {{{
+  if executable('jinfo')
+    call eclim#util#Echo('Executing...')
+
+    let content = split(eclim#util#System('jinfo ' . a:id), '\n')
+    if v:shell_error
+      call eclim#util#EchoError('Unable to execute jinfo.')
+      return
+    endif
+
+    call eclim#util#TempWindow('Java_Process_Info_' . a:id, content)
+    setlocal ft=jproperties
+
+    call eclim#util#Echo(' ')
+  endif
+endfunction " }}}
+
+function! s:ViewStacks(id) " {{{
+  if executable('jstack')
+    call eclim#util#Echo('Executing...')
+    let content = split(eclim#util#System('jstack ' . a:id), '\n')
+
+    if v:shell_error
+      call eclim#util#EchoError('Unable to execute jstack.')
+      return
+    endif
+
+    call map(content, 'substitute(v:val, "^   \\(\\S\\)", "  \\1", "")')
+    call map(content, 'substitute(v:val, "^\t", "      ", "")')
+
+    call eclim#util#TempWindow('Java_Process_Stacks_' . a:id, content)
+    setlocal ft=java
+
+    call eclim#util#Echo(' ')
+  endif
+endfunction " }}}
+
+function! s:ViewMap(id) " {{{
+  if executable('jmap')
+    call eclim#util#Echo('Executing...')
+    let content = split(eclim#util#System('jmap ' . a:id), '\n')
+
+    if v:shell_error
+      call eclim#util#EchoError('Unable to execute jmap.')
+      return
+    endif
+
+    call eclim#util#TempWindow('Java_Process_Map_' . a:id, content)
+
+    call eclim#util#Echo(' ')
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/java/util.vim

@@ -0,0 +1,355 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   Utility functions for java eclim ftplugins.
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+  let s:keywords = '\(abstract\|assert\|boolean\|case\|catch\|char\|class\|do\|double\|enum\|extends\|final\|finally\|float\|for\|if\|implements\|import\|int\|interface\|long\|new\|null\|package\|private\|protected\|public\|return\|short\|static\|switch\|throw\|throws\|try\|void\|while\)'
+
+  let s:class_declaration = '^\s*\(public\|private\|protected\)\?\(\s\+abstract\)\?\s\+\(class\|interface\|enum\)\s\+[A-Z]'
+
+  let s:command_src_exists = '-command java_src_exists -f "<file>"'
+  let s:command_list_installs = '-command java_list_installs'
+  let s:command_classpath = '-command java_classpath -p "<project>"'
+  let s:command_read_class = '-command java_class_prototype -c <class>'
+  let s:command_complete_package = '-command java_complete_package -p "<project>"'
+
+  let s:import_pattern = '^\s*import\_s\+<import>\_s*;'
+" }}}
+
+function! eclim#java#util#FileExists(name) " {{{
+  let command = substitute(s:command_src_exists, '<file>', a:name, '')
+  let result = eclim#Execute(command)
+  return result =~ '^true$'
+endfunction " }}}
+
+function! eclim#java#util#GetClassname(...) " {{{
+  if a:0 > 0
+    return fnamemodify(a:1, ":t:r")
+  endif
+  return expand("%:t:r")
+endfunction " }}}
+
+function! eclim#java#util#GetClassDeclarationPosition(movecursor) " {{{
+  let pos = getpos('.')
+  call cursor(1,1)
+
+  let position = search(s:class_declaration)
+
+  if !a:movecursor || !position
+    call setpos('.', pos)
+  endif
+
+  return position
+endfunction " }}}
+
+function! eclim#java#util#GetFullyQualifiedClassname(...) " {{{
+  let package = a:0 > 0 ?
+    \ eclim#java#util#GetPackage(a:1) :
+    \ eclim#java#util#GetPackage()
+  let classname = a:0 > 0 ?
+    \ eclim#java#util#GetClassname(a:1) :
+    \ eclim#java#util#GetClassname()
+  return len(package) ? (package . '.' . classname) : classname
+endfunction " }}}
+
+function! eclim#java#util#GetPackage(...) " {{{
+  if a:0 > 0
+    let winreset = winrestcmd()
+    silent exec "sview " . a:1
+  endif
+
+  let pos = getpos('.')
+
+  call cursor(1,1)
+
+  let package = ""
+  let packageLine = search('^\s*\<package\>', 'w')
+  if packageLine > 0
+    let package =
+      \ substitute(getline('.'), '.*\<package\>\s\+\(.\{-\}\)[ ;].*', '\1', '')
+  endif
+
+  if a:0 > 0
+    close
+    silent exec winreset
+
+    " not necessary and may screw up display (see autoload/project.vim)
+    "redraw
+  else
+    call setpos('.', pos)
+  endif
+
+  return package
+endfunction " }}}
+
+function! eclim#java#util#GetPackageFromImport(class) " {{{
+  let pattern = '^\s*import\s\+\([0-9A-Za-z._]*\)\.' . a:class . '\s*;'
+  let found = search(pattern, 'wn')
+  if found
+    return substitute(getline(found), pattern, '\1', '')
+  endif
+  return ""
+endfunction " }}}
+
+function! eclim#java#util#GetSelectedFields(first, last) range " {{{
+  " normalize each field statement into a single line.
+  let selection = ''
+  let index = a:first
+  let blockcomment = 0
+  while index <= a:last
+    let line = getline(index)
+
+    " ignore comment lines
+    if line =~ '^\s*/\*'
+      let blockcomment = 1
+    endif
+    if blockcomment && line =~ '\*/\s*$'
+      let blockcomment = 0
+    endif
+    if line !~ '^\s*//' && !blockcomment
+      " remove quoted values.
+      let line = substitute(line, '".\{-}"', '', 'g')
+      " strip off trailing comments
+      let line = substitute(line, '//.*', '', '')
+      let line = substitute(line, '/\*.*\*/', '', '')
+
+      let selection = selection . line
+    endif
+
+    let index += 1
+  endwhile
+
+  " compact comma separated multi field declarations
+  let selection = substitute(selection, ',\s*', ',', 'g')
+  " break fields back up into their own line.
+  let selection = substitute(selection, ';', ';\n', 'g')
+  " remove the assignment portion of the field.
+  let selection = substitute(selection, '\(.\{-}\)\s*=.\{-};', '\1;', 'g')
+
+  " extract field names
+  let properties = []
+  let lines = split(selection, '\n')
+  for line in lines
+    if line !~ '^\s*\/\/'
+      let fields = substitute(line, '.*\s\(.*\);', '\1', '')
+      if fields =~ '^[a-zA-Z0-9_,]'
+        for field in split(fields, ',')
+          call add(properties, field)
+        endfor
+      endif
+    endif
+  endfor
+
+  return properties
+endfunction " }}}
+
+function! eclim#java#util#IsKeyword(word) " {{{
+  return (a:word =~ '^' . s:keywords . '$\C')
+endfunction " }}}
+
+function! eclim#java#util#IsImported(classname) " {{{
+  " search for fully qualified import
+  let import_search = s:import_pattern
+  let import_search = substitute(import_search, '<import>', a:classname, '')
+  let found = search(import_search, 'wn')
+  if found
+    return 1
+  endif
+
+  " search for package.* import
+  let package = substitute(a:classname, '\(.*\)\..*', '\1', '')
+  let import_search = s:import_pattern
+  let import_search = substitute(import_search, '<import>', package . '\\.\\*', '')
+  let found = search(import_search, 'wn')
+  if found
+    return 1
+  endif
+
+  " check if current file and supplied classname are in the same package
+  if eclim#java#util#GetPackage() == package
+    return 1
+  endif
+
+  " not imported
+  return 0
+endfunction " }}}
+
+function! eclim#java#util#IsValidIdentifier(word) " {{{
+  if a:word == '' || a:word =~ '\W' || a:word =~ '^\d\+$' ||
+   \ eclim#java#util#IsKeyword(a:word)
+    return 0
+  endif
+  return 1
+endfunction " }}}
+
+function! eclim#java#util#Java(classname, args) " {{{
+  let project = eclim#project#util#GetCurrentProjectName()
+  if project == '' && exists('b:project')
+    let project = b:project
+  endif
+
+  if project == ''
+    call eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  let args = eclim#util#ParseArgs(a:args)
+  let classname = a:classname
+  if classname == '' && len(args)
+    let arg1 = args[0]
+    if arg1 == '%'
+      let args = args[1:]
+      let classname = exists('b:filename') ?
+        \ eclim#java#util#GetFullyQualifiedClassname(b:filename) :
+        \ eclim#java#util#GetFullyQualifiedClassname()
+    endif
+  endif
+
+  let command = '-command java -p "' . project . '"'
+  if classname != ''
+    let command .= ' -c ' . classname
+  endif
+
+  if len(args)
+    let command .= ' -a'
+    for arg in args
+      let arg = substitute(arg, '^-', '\\-', '')
+      let command .= ' "' . escape(arg, '"') . '"'
+    endfor
+  endif
+
+  let result = eclim#Execute(command, {'project': project, 'exec': 1, 'raw': 1})
+  let results = split(result, "\n")
+  call eclim#util#TempWindow('[Java Output]', results)
+  let b:project = project
+
+  if exists(":Java") != 2
+    command -buffer -nargs=* Java :call eclim#java#util#Java('', <q-args>)
+  endif
+endfunction " }}}
+
+function! eclim#java#util#Classpath(...) " {{{
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let command = s:command_classpath
+  let command = substitute(command, '<project>', project, '')
+  for arg in a:000
+    if arg == '\n'
+      let arg = "\n"
+    endif
+    let command .= " \"" . arg . "\""
+  endfor
+  let result = eclim#Execute(command)
+  if result == '0'
+    return
+  endif
+  call eclim#util#Echo(result)
+endfunction " }}}
+
+function! eclim#java#util#ListInstalls() " {{{
+  let installs = eclim#Execute(s:command_list_installs)
+  if type(installs) != g:LIST_TYPE
+    return
+  endif
+  if len(installs) == 0
+    call eclim#util#Echo("No jdk/jre installs found.")
+  endif
+
+  let pad = 0
+  for install in installs
+    let name = install.name . ' ' . install.version
+    if install.default
+      let name .= ' (default)'
+    endif
+    let pad = len(name) > pad ? len(name) : pad
+  endfor
+
+  let output = []
+  let type = ''
+  for install in installs
+    if install.type != type
+      let type = install.type
+      call add(output, 'Type: ' . install.type)
+    endif
+    let name = install.name . ' ' . install.version
+    if install.default
+      let name .= ' (default)'
+    endif
+    call add(output, '  ' . eclim#util#Pad(name, pad) . ' - ' . install.dir)
+  endfor
+  call eclim#util#Echo(join(output, "\n"))
+endfunction " }}}
+
+function! eclim#java#util#ReadClassPrototype() " {{{
+  let file = substitute(expand('%:p'), '\', '/', 'g')
+  let command = s:command_read_class
+  let command = substitute(command, '<class>', expand('%:t:r'), '')
+  let command .= ' -f "' . file . '"'
+
+  let file = eclim#Execute(command)
+  if string(file) != '0'
+    let bufnum = bufnr('%')
+    if has('win32unix')
+      let file = eclim#cygwin#CygwinPath(file)
+    endif
+    silent exec "keepjumps edit! " . escape(file, ' ')
+
+    exec 'bdelete ' . bufnum
+
+    silent exec "doautocmd BufReadPre " . file
+    silent exec "doautocmd BufReadPost " . file
+
+    call eclim#util#DelayedCommand('set ft=java')
+    setlocal readonly
+    setlocal nomodifiable
+    setlocal noswapfile
+  endif
+endfunction " }}}
+
+function! eclim#java#util#CommandCompleteProject(argLead, cmdLine, cursorPos) " {{{
+  return eclim#project#util#CommandCompleteProjectByNature(
+    \ a:argLead, a:cmdLine, a:cursorPos, 'java')
+endfunction " }}}
+
+function! eclim#java#util#CommandCompletePackage(argLead, cmdLine, cursorPos) " {{{
+  let cmdTail = strpart(a:cmdLine, a:cursorPos)
+  let argLead = substitute(a:argLead, cmdTail . '$', '', '')
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  if project == ''
+    return []
+  endif
+
+  let command = s:command_complete_package
+  let command = substitute(command, '<project>', project, '')
+  if argLead != ''
+    let command .= ' -n ' . argLead
+  endif
+  let results = eclim#Execute(command)
+  return type(results) == g:LIST_TYPE ? results : []
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/javascript/complete.vim

@@ -0,0 +1,37 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/javascript/complete.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2009  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Varables {{{
+  let s:complete_command =
+    \ '-command javascript_complete ' .
+    \ '-p "<project>" -f "<file>" -o <offset> -e <encoding>'
+" }}}
+
+" CodeComplete(findstart, base) {{{
+" Handles code completion.
+function! eclim#javascript#complete#CodeComplete(findstart, base)
+  return eclim#lang#CodeComplete(s:complete_command, a:findstart, a:base)
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/javascript/util.vim

@@ -0,0 +1,124 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+  let s:warnings = '\(' . join([
+      \ 'imported but unused',
+    \ ], '\|') . '\)'
+" }}}
+
+function! eclim#javascript#util#UpdateSrcFile(on_save) " {{{
+  " Optional arg:
+  "   validate: when 1 force the validation to execute, when 0 prevent it.
+
+  " Disabled until the jsdt matures.
+  "if !a:on_save
+  "  call eclim#lang#UpdateSrcFile('javascript', 1)
+  "else
+  "  call eclim#lang#UpdateSrcFile('javascript')
+  "endif
+
+  let validate = !a:on_save || (
+    \ g:EclimJavascriptValidate &&
+    \ (!exists('g:EclimFileTypeValidate') || g:EclimFileTypeValidate))
+
+  if validate && g:EclimJavascriptLintEnabled
+    call eclim#javascript#util#Jsl()
+  endif
+endfunction " }}}
+
+function! eclim#javascript#util#Jsl() " {{{
+  " Runs jsl (javascript lint) on the current file.
+
+  if eclim#util#WillWrittenBufferClose()
+    return
+  endif
+
+  let result = ''
+
+  if !executable('jsl')
+    if !exists('g:eclim_javascript_jsl_warn')
+      call eclim#util#EchoWarning("Unable to find 'jsl' command.")
+      let g:eclim_javascript_jsl_warn = 1
+    endif
+  else
+    if !exists('g:EclimJavascriptLintVersion')
+      call eclim#util#System('jsl --help')
+      let g:EclimJavascriptLintVersion = v:shell_error == 2 ? 'c' : 'python'
+    endif
+
+    let conf = expand(g:EclimJavascriptLintConf)
+
+    " the c version
+    if g:EclimJavascriptLintVersion == 'c'
+      let command = 'jsl -process "' . expand('%:p') . '"'
+      if filereadable(conf)
+        let command .= ' -conf "' . conf . '"'
+      endif
+
+    " the new python version
+    else
+      let command = 'jsl "' . expand('%:p') . '"'
+      if filereadable(conf)
+        let command .= ' --conf "' . conf . '"'
+      endif
+    endif
+
+    let result = eclim#util#System(command)
+    if v:shell_error == 2 "|| v:shell_error == 4
+      call eclim#util#EchoError('Error running command: ' . command)
+      return
+    endif
+  endif
+
+  if result =~ ':'
+    let results = split(result, '\n')
+    let errors = []
+    for error in results
+      if error =~ '.\{-}(\d\+): .\{-}: .\{-}'
+        let file = substitute(error, '\(.\{-}\)([0-9]\+):.*', '\1', '')
+        let line = substitute(error, '.\{-}(\([0-9]\+\)):.*', '\1', '')
+        let message = substitute(error, '.\{-}([0-9]\+):.\{-}: \(.*\)', '\1', '')
+        let dict = {
+            \ 'filename': eclim#util#Simplify(file),
+            \ 'lnum': line,
+            \ 'text': "[jsl] " . message,
+            \ 'type': error =~ ': \(lint \)\?warning:' ? 'w' : 'e',
+          \ }
+
+        call add(errors, dict)
+      endif
+    endfor
+
+    call eclim#display#signs#SetPlaceholder()
+    call eclim#util#ClearLocationList('jsl')
+    if &ft == 'javascript'
+      call eclim#util#SetLocationList(errors)
+    else
+      call eclim#util#SetLocationList(errors, 'a')
+    endif
+    call eclim#display#signs#RemovePlaceholder()
+  else
+    call eclim#util#ClearLocationList('jsl')
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/lang.vim

@@ -0,0 +1,653 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+  let s:update_command = '-command <lang>_src_update -p "<project>" -f "<file>"'
+  let s:validate_command = '-command <type>_validate -p "<project>" -f "<file>"'
+  let s:undoredo_command = '-command refactor_<operation>'
+" }}}
+
+function! eclim#lang#CodeComplete(command, findstart, base, ...) " {{{
+  " Optional args:
+  "   options: dict containing one or more of the following:
+  "     temp: 1 to use a temp file, 0 otherwise
+  "     regex: regular expression of characters to walk back over to find the
+  "            starting position of the completion.
+  "     layout: passed through to the eclimd completion for languages that
+  "             support this (typically decides how overloaded method names are
+  "             presented in the completion list).
+
+  if !eclim#project#util#IsCurrentFileInProject(0)
+    return a:findstart ? -1 : []
+  endif
+
+  let options = a:0 ? a:1 : {}
+
+  if a:findstart
+    call eclim#lang#SilentUpdate(get(options, 'temp', 1))
+
+    " locate the start of the word
+    let line = getline('.')
+
+    let start = col('.') - 1
+
+    "exceptions that break the rule
+    if line[start] =~ '\.'
+      let start -= 1
+    endif
+
+    let pattern = get(options, 'regex', '\w')
+    while start > 0 && line[start - 1] =~ pattern
+      let start -= 1
+    endwhile
+
+    return start
+  else
+    let offset = eclim#util#GetOffset() + len(a:base)
+    let project = eclim#project#util#GetCurrentProjectName()
+    let file = eclim#lang#SilentUpdate(get(options, 'temp', 1), 0)
+    if file == ''
+      return []
+    endif
+
+    let command = a:command
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+    let command = substitute(command, '<offset>', offset, '')
+    let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+    if has_key(options, 'layout')
+      let command = substitute(command, '<layout>', options.layout, '')
+    endif
+
+    let completions = []
+    let results = eclim#Execute(command)
+    if type(results) != g:LIST_TYPE
+      return
+    endif
+
+    let open_paren = getline('.') =~ '\%' . col('.') . 'c\s*('
+    let close_paren = getline('.') =~ '\%' . col('.') . 'c\s*(\s*)'
+
+    for result in results
+      let word = result.completion
+
+      " strip off close paren if necessary.
+      if word =~ ')$' && close_paren
+        let word = strpart(word, 0, strlen(word) - 1)
+      endif
+
+      " strip off open paren if necessary.
+      if word =~ '($' && open_paren
+        let word = strpart(word, 0, strlen(word) - 1)
+      endif
+
+      let menu = eclim#html#util#HtmlToText(result.menu)
+      let info = has_key(result, 'info') ?
+        \ eclim#html#util#HtmlToText(result.info) : ''
+
+      let dict = {
+          \ 'word': word,
+          \ 'menu': menu,
+          \ 'info': info,
+          \ 'dup': 1
+        \ }
+
+      call add(completions, dict)
+    endfor
+
+    return completions
+  endif
+endfunction " }}}
+
+function! eclim#lang#Search(command, singleResultAction, argline) " {{{
+  let argline = a:argline
+  "if argline == ''
+  "  call eclim#util#EchoError('You must supply a search pattern.')
+  "  return
+  "endif
+
+  " check for user supplied open action
+  let [action_args, argline] = eclim#util#ExtractCmdArgs(argline, '-a:')
+  let action = len(action_args) == 2 ? action_args[1] : a:singleResultAction
+
+  " check if pattern supplied without -p.
+  if argline !~ '^\s*-[a-z]' && argline !~ '^\s*$'
+    let argline = '-p ' . argline
+  endif
+
+  if !eclim#project#util#IsCurrentFileInProject(0)
+    let args = eclim#util#ParseArgs(argline)
+    let index = index(args, '-s') + 1
+    if index && len(args) > index && args[index] != 'all'
+      return
+    endif
+    let argline .= ' -s all'
+  endif
+
+  let search_cmd = a:command
+  let project = eclim#project#util#GetCurrentProjectName()
+  if project != ''
+    let search_cmd .= ' -n "' . project . '"'
+  endif
+
+  " no pattern supplied, use element search.
+  if argline !~ '-p\>'
+    if !eclim#project#util#IsCurrentFileInProject(1)
+      return
+    endif
+    " update the file.
+    call eclim#util#ExecWithoutAutocmds('silent update')
+
+    let file = eclim#project#util#GetProjectRelativeFilePath()
+    let position = eclim#util#GetCurrentElementPosition()
+    let offset = substitute(position, '\(.*\);\(.*\)', '\1', '')
+    let length = substitute(position, '\(.*\);\(.*\)', '\2', '')
+    let encoding = eclim#util#GetEncoding()
+    let search_cmd .= ' -f "' . file . '"' .
+      \ ' -o ' . offset . ' -l ' . length . ' -e ' . encoding
+  else
+    " quote the search pattern
+    let search_cmd = substitute(
+      \ search_cmd, '\(.*-p\s\+\)\(.\{-}\)\(\s\|$\)\(.*\)', '\1"\2"\3\4', '')
+  endif
+
+  let search_cmd .= ' ' . argline
+  let results =  eclim#Execute(search_cmd)
+  if type(results) != g:LIST_TYPE
+    return
+  endif
+
+  if !empty(results)
+    call eclim#util#SetLocationList(eclim#util#ParseLocationEntries(results))
+    let locs = getloclist(0)
+    " if only one result and it's for the current file, just jump to it.
+    " note: on windows the expand result must be escaped
+    if len(results) == 1 && locs[0].bufnr == bufnr('%')
+      if results[0].line != 1 && results[0].column != 1
+        lfirst
+      endif
+
+    " single result in another file.
+    elseif len(results) == 1 && action != "lopen"
+      let entry = getloclist(0)[0]
+      let name = substitute(bufname(entry.bufnr), '\', '/', 'g')
+      call eclim#util#GoToBufferWindowOrOpen(name, action)
+      call eclim#util#SetLocationList(eclim#util#ParseLocationEntries(results))
+      call eclim#display#signs#Update()
+      call cursor(entry.lnum, entry.col)
+
+    " multiple results and user specified an action other than lopen
+    elseif len(results) && len(action_args) && action != 'lopen'
+      let locs = getloclist(0)
+      let files = map(copy(locs),  'printf(' .
+        \ '"%s|%s col %s| %s", ' .
+        \ 'bufname(v:val.bufnr), v:val.lnum, v:val.col, v:val.text)')
+      let response = eclim#util#PromptList(
+        \ 'Please choose the file to ' . action,
+        \ files, g:EclimHighlightInfo)
+      if response == -1
+        return
+      endif
+      let entry = locs[response]
+      let name = substitute(bufname(entry.bufnr), '\', '/', 'g')
+      call eclim#util#GoToBufferWindowOrOpen(name, action)
+      call eclim#display#signs#Update()
+      call cursor(entry.lnum, entry.col)
+
+    else
+      exec 'lopen ' . g:EclimLocationListHeight
+    endif
+    return 1
+  else
+    if argline !~ '-p\>'
+      call eclim#util#EchoInfo("Element not found.")
+    else
+      let searchedFor = substitute(argline, '.*-p \(.\{-}\)\( .*\|$\)', '\1', '')
+      call eclim#util#EchoInfo("Pattern '" . searchedFor . "' not found.")
+    endif
+  endif
+endfunction " }}}
+
+function! eclim#lang#IsFiletypeValidationEnabled(lang) " {{{
+  " global setting
+  if !g:EclimFileTypeValidate
+    return 0
+  endif
+  " per lang setting
+  exec 'let validate = g:Eclim' . toupper(a:lang[0]) . a:lang[1:] . 'Validate'
+  return validate
+endfunction " }}}
+
+function! eclim#lang#DisableSyntasticIfValidationIsEnabled(lang, ...) " {{{
+  "Optional arg:
+  "  syntastic lang: The syntastic lang string if it doesn't match eclim's lang.
+
+  if exists('g:loaded_syntastic_plugin') &&
+   \ eclim#lang#IsFiletypeValidationEnabled(a:lang)
+    let lang = a:0 ? a:1 : a:lang
+    exec 'let syntastic_enabled = ' .
+      \ 'g:Eclim' . toupper(lang[0]) . lang[1:] . 'SyntasticEnabled'
+
+    if !syntastic_enabled
+      if !exists('g:syntastic_mode_map')
+        let g:syntastic_mode_map = {'passive_filetypes': []}
+      elseif !has_key(g:syntastic_mode_map, 'passive_filetypes')
+        let g:syntastic_mode_map.passive_filetypes = []
+      endif
+      if index(g:syntastic_mode_map.passive_filetypes, lang) == -1
+        call add(g:syntastic_mode_map.passive_filetypes, lang)
+      endif
+    endif
+  endif
+endfunction " }}}
+
+function! eclim#lang#UpdateSrcFile(lang, ...) " {{{
+  " Updates the src file on the server w/ the changes made to the current file.
+  " Optional arg:
+  "   validate: when 1 force the validation to execute, when 0 prevent it.
+
+  if !a:0
+    let validate = eclim#lang#IsFiletypeValidationEnabled(a:lang)
+  else
+    " arg override
+    let validate = a:1
+  endif
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  if project != ""
+    let file = eclim#project#util#GetProjectRelativeFilePath()
+    let command = s:update_command
+    let command = substitute(command, '<lang>', a:lang, '')
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+    if validate && !eclim#util#WillWrittenBufferClose()
+      let command = command . ' -v'
+      if eclim#project#problems#IsProblemsList() &&
+       \ g:EclimProjectProblemsUpdateOnSave
+        let command = command . ' -b'
+      endif
+    endif
+
+    let result = eclim#Execute(command)
+
+    if validate && !eclim#util#WillWrittenBufferClose()
+      if type(result) == g:LIST_TYPE && len(result) > 0
+        let errors = eclim#util#ParseLocationEntries(
+          \ result, g:EclimValidateSortResults)
+        call eclim#util#SetLocationList(errors)
+      else
+        call eclim#util#ClearLocationList('global')
+      endif
+    endif
+
+    call eclim#project#problems#ProblemsUpdate('save')
+  elseif validate && expand('<amatch>') == ''
+    call eclim#project#util#IsCurrentFileInProject()
+  endif
+endfunction " }}}
+
+" Validate(type, on_save, [filter]) {{{
+" Validates the current file. Used by languages which are not validated via
+" UpdateSrcFile (pretty much all the xml dialects and wst langs).
+function! eclim#lang#Validate(type, on_save, ...)
+  if eclim#util#WillWrittenBufferClose()
+    return
+  endif
+
+  if !eclim#project#util#IsCurrentFileInProject(!a:on_save)
+    return
+  endif
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let command = s:validate_command
+  let command = substitute(command, '<type>', a:type, '')
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+
+  let result = eclim#Execute(command)
+  if type(result) == g:LIST_TYPE && len(result) > 0
+    let errors = eclim#util#ParseLocationEntries(
+      \ result, g:EclimValidateSortResults)
+    if a:0
+      let errors = function(a:1)(errors)
+    endif
+    call eclim#util#SetLocationList(errors)
+  else
+    call eclim#util#ClearLocationList()
+  endif
+endfunction " }}}
+
+function! eclim#lang#SilentUpdate(...) " {{{
+  " Silently updates the current source file w/out validation.
+  " Optional args:
+  "   temp: construct a temp file path for the current file and return that path
+  "         (default is to not create a temp file)
+  "   temp_write: when constructing a temp file path, whether or not to write
+  "               the current file's contents to that path (default is to do so)
+
+  " i couldn't reproduce the issue, but at least one person experienced the
+  " cursor moving on update and breaking code completion:
+  " http://sourceforge.net/tracker/index.php?func=detail&aid=1995319&group_id=145869&atid=763323
+  let pos = getpos('.')
+  silent let file = eclim#project#util#GetProjectRelativeFilePath()
+  if file != ''
+    try
+      if a:0 && a:1 && g:EclimTempFilesEnable
+        " don't create temp files if no server is available to clean them up.
+        let project = eclim#project#util#GetProject(expand('%:p'))
+        let workspace = len(project) > 0 ? project.workspace : ''
+        if workspace != '' && eclim#PingEclim(0, workspace)
+          let prefix = '__eclim_temp_'
+          let file = fnamemodify(file, ':h') . '/' . prefix . fnamemodify(file, ':t')
+          let tempfile = expand('%:p:h') . '/' . prefix . expand('%:t')
+          if a:0 < 2 || a:2
+            let savepatchmode = &patchmode
+            set patchmode=
+            exec 'silent noautocmd keepalt write! ' . escape(tempfile, ' %')
+            let &patchmode = savepatchmode
+          endif
+        endif
+      else
+        if a:0 < 2 || a:2
+          silent noautocmd update
+        endif
+      endif
+    finally
+      call setpos('.', pos)
+    endtry
+  endif
+  return file
+endfunction " }}}
+
+" Refactor(command) {{{
+" Executes the supplied refactoring command handle error response and
+" reloading files that have changed.
+function! eclim#lang#Refactor(command)
+  let cwd = substitute(getcwd(), '\', '/', 'g')
+  let cwd_return = 1
+
+  try
+    " turn off swap files temporarily to avoid issues with folder/file
+    " renaming.
+    let bufend = bufnr('$')
+    let bufnum = 1
+    while bufnum <= bufend
+      if bufexists(bufnum)
+        call setbufvar(bufnum, 'save_swapfile', getbufvar(bufnum, '&swapfile'))
+        call setbufvar(bufnum, '&swapfile', 0)
+      endif
+      let bufnum = bufnum + 1
+    endwhile
+
+    " cd to the project root to avoid folder renaming issues on windows.
+    exec 'cd ' . escape(eclim#project#util#GetCurrentProjectRoot(), ' ')
+
+    let result = eclim#Execute(a:command)
+    if type(result) != g:LIST_TYPE && type(result) != g:DICT_TYPE
+      return
+    endif
+
+    " error occurred
+    if type(result) == g:DICT_TYPE && has_key(result, 'errors')
+      call eclim#util#EchoError(result.errors)
+      return
+    endif
+
+    " reload affected files.
+    let curwin = winnr()
+    try
+      for info in result
+        let newfile = ''
+        " handle file renames
+        if has_key(info, 'to')
+          let file = info.from
+          let newfile = info.to
+          if has('win32unix')
+            let newfile = eclim#cygwin#CygwinPath(newfile)
+          endif
+        else
+          let file = info.file
+        endif
+
+        if has('win32unix')
+          let file = eclim#cygwin#CygwinPath(file)
+        endif
+
+        " ignore unchanged directories
+        if isdirectory(file)
+          continue
+        endif
+
+        " handle current working directory moved.
+        if newfile != '' && isdirectory(newfile)
+          if file =~ '^' . cwd . '\(/\|$\)'
+            while cwd !~ '^' . file . '\(/\|$\)'
+              let file = fnamemodify(file, ':h')
+              let newfile = fnamemodify(newfile, ':h')
+            endwhile
+          endif
+
+          if cwd =~ '^' . file . '\(/\|$\)'
+            let dir = substitute(cwd, file, newfile, '')
+            exec 'cd ' . escape(dir, ' ')
+            let cwd_return = 0
+          endif
+          continue
+        endif
+
+        let winnr = bufwinnr(file)
+        if winnr > -1
+          exec winnr . 'winc w'
+          if newfile != ''
+            let bufnr = bufnr('%')
+            enew
+            exec 'bdelete ' . bufnr
+            exec 'edit ' . escape(eclim#util#Simplify(newfile), ' ')
+          else
+            call eclim#util#Reload({'retab': 1})
+          endif
+        endif
+      endfor
+    finally
+      exec curwin . 'winc w'
+      if cwd_return
+        exec 'cd ' . escape(cwd, ' ')
+      endif
+    endtry
+  finally
+    " re-enable swap files
+    let bufnum = 1
+    while bufnum <= bufend
+      if bufexists(bufnum)
+        let save_swapfile = getbufvar(bufnum, 'save_swapfile')
+        if save_swapfile != ''
+          call setbufvar(bufnum, '&swapfile', save_swapfile)
+        endif
+      endif
+      let bufnum = bufnum + 1
+    endwhile
+  endtry
+endfunction " }}}
+
+" RefactorPreview(command) {{{
+" Executes the supplied refactor preview command and opens a corresponding
+" window to view that preview.
+function! eclim#lang#RefactorPreview(command)
+  let result = eclim#Execute(a:command)
+  if type(result) != g:DICT_TYPE
+    return
+  endif
+
+  " error occurred
+  if has_key(result, 'errors')
+    call eclim#util#EchoError(result.errors)
+    return
+  endif
+
+  let lines = []
+  for change in result.changes
+    if change.type == 'diff'
+      call add(lines, '|diff|: ' . change.file)
+    else
+      call add(lines, change.type . ': ' . change.message)
+    endif
+  endfor
+
+  call add(lines, '')
+  call add(lines, '|Execute Refactoring|')
+  call eclim#util#TempWindow('[Refactor Preview]', lines)
+  let b:refactor_command = result.apply
+
+  set ft=refactor_preview
+  hi link RefactorLabel Identifier
+  hi link RefactorLink Label
+  syntax match RefactorLabel /^\s*\w\+:/
+  syntax match RefactorLink /|\S.\{-}\S|/
+
+  nnoremap <silent> <buffer> <cr> :call eclim#lang#RefactorPreviewLink()<cr>
+endfunction " }}}
+
+" RefactorPreviewLink() {{{
+" Called when a user hits <cr> on a link in the refactor preview window,
+" issuing a diff for that file.
+function! eclim#lang#RefactorPreviewLink()
+  let line = getline('.')
+  if line =~ '^|'
+    let command = b:refactor_command
+
+    let winend = winnr('$')
+    let winnum = 1
+    while winnum <= winend
+      let bufnr = winbufnr(winnum)
+      if getbufvar(bufnr, 'refactor_preview_diff') != ''
+        exec bufnr . 'bd'
+        continue
+      endif
+      let winnum += 1
+    endwhile
+
+    if line == '|Execute Refactoring|'
+      call eclim#lang#Refactor(command)
+      let winnr = b:winnr
+      close
+      " the filename might change, so we have to use the winnr to get back to
+      " where we were.
+      exec winnr . 'winc w'
+
+    elseif line =~ '^|diff|'
+      let file = substitute(line, '^|diff|:\s*', '', '')
+      let command .= ' -v -d "' . file . '"'
+
+      let diff = eclim#Execute(command)
+      if type(diff) != g:STRING_TYPE
+        return
+      endif
+
+      " split relative to the original window
+      exec b:winnr . 'winc w'
+
+      if has('win32unix')
+        let file = eclim#cygwin#CygwinPath(file)
+      endif
+      let name = fnamemodify(file, ':t:r')
+      let ext = fnamemodify(file, ':e')
+      exec printf('silent below new %s.current.%s', name, ext)
+      silent 1,$delete _ " counter-act any templating plugin
+      exec 'read ' . escape(file, ' ')
+      silent 1,1delete _
+      let winnr = winnr()
+      let b:refactor_preview_diff = 1
+      setlocal readonly nomodifiable
+      setlocal noswapfile nobuflisted
+      setlocal buftype=nofile bufhidden=delete
+      diffthis
+
+      let orien = g:EclimRefactorDiffOrientation == 'horizontal' ? '' : 'vertical'
+      exec printf('silent below %s split %s.new.%s', orien, name, ext)
+      silent 1,$delete _ " counter-act any templating plugin
+      call append(1, split(diff, "\n"))
+      let b:refactor_preview_diff = 1
+      silent 1,1delete _
+      setlocal readonly nomodifiable
+      setlocal noswapfile nobuflisted
+      setlocal buftype=nofile bufhidden=delete
+      diffthis
+      exec winnr . 'winc w'
+    endif
+  endif
+endfunction " }}}
+
+" RefactorPrompt(prompt) {{{
+" Issues the standard prompt for language refactorings.
+function! eclim#lang#RefactorPrompt(prompt)
+  exec "echohl " . g:EclimHighlightInfo
+  try
+    " clear any previous messages
+    redraw
+    echo a:prompt . "\n"
+    let response = input("([e]xecute / [p]review / [c]ancel): ")
+    while response != '' &&
+        \ response !~ '^\c\s*\(e\(xecute\)\?\|p\(review\)\?\|c\(ancel\)\?\)\s*$'
+      let response = input("You must choose either e, p, or c. (Ctrl-C to cancel): ")
+    endwhile
+  finally
+    echohl None
+  endtry
+
+  if response == ''
+    return -1
+  endif
+
+  if response =~ '\c\s*\(c\(ancel\)\?\)\s*'
+    return 0
+  endif
+
+  return response =~ '\c\s*\(e\(execute\)\?\)\s*' ? 1 : 2 " preview
+endfunction " }}}
+
+" UndoRedo(operation, peek) {{{
+" Performs an undo or redo (operation  = 'undo' or 'redo') for the last
+" executed refactoring.
+function! eclim#lang#UndoRedo(operation, peek)
+  if !eclim#project#util#IsCurrentFileInProject()
+    return
+  endif
+
+  " update the file before vim makes any changes.
+  call eclim#lang#SilentUpdate()
+  wall
+
+  let command = s:undoredo_command
+  let command = substitute(command, '<operation>', a:operation, '')
+  if a:peek
+    let command .= ' -p'
+    let result = eclim#Execute(command)
+    if type(result) == g:STRING_TYPE
+      call eclim#util#Echo(result)
+    endif
+    return
+  endif
+
+  call eclim#lang#Refactor(command)
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/lang/hierarchy.vim

@@ -0,0 +1,139 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+  let s:call_hierarchy =
+    \ '-command <lang>_callhierarchy -p "<project>" -f "<file>" ' .
+    \ '-o <offset> -l <length> -e <encoding>'
+" }}}
+
+function! eclim#lang#hierarchy#CallHierarchy(lang, default_action, bang) " {{{
+  if !eclim#project#util#IsCurrentFileInProject(1)
+    return
+  endif
+
+  call eclim#lang#SilentUpdate()
+
+  let project = eclim#project#util#GetCurrentProjectName()
+  let file = eclim#project#util#GetProjectRelativeFilePath()
+  let position = eclim#util#GetCurrentElementPosition()
+  let offset = substitute(position, '\(.*\);\(.*\)', '\1', '')
+  let length = substitute(position, '\(.*\);\(.*\)', '\2', '')
+  let command = s:call_hierarchy
+  let command = substitute(command, '<lang>', a:lang, '')
+  let command = substitute(command, '<project>', project, '')
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<offset>', offset, '')
+  let command = substitute(command, '<length>', length, '')
+  let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+  " return callees
+  if a:bang != ''
+    let command .= ' -c'
+  endif
+
+  let result = eclim#Execute(command)
+  if type(result) != g:DICT_TYPE
+    return
+  endif
+
+  if len(result) == 0
+    call eclim#util#Echo('No results found.')
+    return
+  endif
+
+  let lines = []
+  let info = []
+  let key = a:bang != '' ? 'callees' : 'callers'
+  call s:CallHierarchyFormat(result, key, lines, info, '')
+
+  call eclim#util#TempWindow('[Call Hierarchy]', lines)
+  exec 'set ft=' . a:lang
+  " fold function calls into their parent
+  setlocal foldmethod=expr
+  setlocal foldexpr='>'.len(substitute(getline(v:lnum),'^\\(\\s*\\).*','\\1',''))/2
+  setlocal foldtext=substitute(getline(v:foldstart),'^\\(\\s*\\)\\s\\s','\\1+\ ','').':\ '.(v:foldend-v:foldstart+1).'\ lines'
+
+  setlocal modifiable noreadonly
+  call append(line('$'), ['', '" use ? to view help'])
+  setlocal nomodifiable readonly
+  syntax match Comment /^".*/
+
+  let b:hierarchy_info = info
+
+  exec 'nnoremap <buffer> <silent> <cr> ' .
+    \ ':call <SID>Open("' . a:default_action . '")<cr>'
+  nnoremap <buffer> <silent> E :call <SID>Open('edit')<cr>
+  nnoremap <buffer> <silent> S :call <SID>Open('split')<cr>
+  nnoremap <buffer> <silent> T :call <SID>Open("tablast \| tabnew")<cr>
+
+  " assign to buffer var to get around weird vim issue passing list containing
+  " a string w/ a '<' in it on execution of mapping.
+  let b:hierarchy_help = [
+      \ '<cr> - open file with default action',
+      \ 'E - open with :edit',
+      \ 'S - open in a new split window',
+      \ 'T - open in a new tab',
+    \ ]
+  nnoremap <buffer> <silent> ?
+    \ :call eclim#help#BufferHelp(b:hierarchy_help, 'vertical', 40)<cr>
+endfunction " }}}
+
+function! s:CallHierarchyFormat(result, key, lines, info, indent) " {{{
+  if has_key(a:result, 'position')
+    call add(a:info, {
+        \ 'file': a:result.position.filename,
+        \ 'line': a:result.position.line,
+        \ 'col': a:result.position.column
+      \ })
+    call add(a:lines, a:indent . a:result.name)
+  else
+    call add(a:info, {'file': '', 'line': -1, 'col': -1})
+    call add(a:lines, a:indent . a:result.name)
+  endif
+
+  for call in get(a:result, a:key, [])
+    call s:CallHierarchyFormat(call, a:key, a:lines, a:info, a:indent . "\t")
+  endfor
+endfunction " }}}
+
+function! s:Open(action) " {{{
+  let line = line('.')
+  if line > len(b:hierarchy_info)
+    return
+  endif
+
+  let info = b:hierarchy_info[line - 1]
+  if info.file != ''
+    " go to the buffer that initiated the hierarchy
+    exec b:winnr . 'winc w'
+
+    let action = a:action
+    call eclim#util#GoToBufferWindowOrOpen(info.file, action)
+    call cursor(info.line, info.col)
+
+   " force any previous messge from else below to be cleared
+    echo ''
+  else
+    call eclim#util#Echo('No associated file was found.')
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/project/problems.vim

@@ -0,0 +1,125 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script variables {{{
+  let s:problems_command = '-command problems -p "<project>"'
+" }}}
+
+function! eclim#project#problems#Problems(project, open, bang) " {{{
+  let project = a:project
+  if project == ''
+    let project = eclim#project#util#GetCurrentProjectName()
+  endif
+  if project == ''
+    call eclim#project#util#UnableToDetermineProject()
+    return
+  endif
+
+  let command = s:problems_command
+  let command = substitute(command, '<project>', project, '')
+  if a:bang != ""
+    let command .= ' -e'
+  endif
+  let result = eclim#Execute(command)
+  let errors = []
+  if type(result) == g:LIST_TYPE && len(result) > 0
+    let errors = eclim#util#ParseLocationEntries(
+      \ result, g:EclimValidateSortResults)
+  endif
+
+  let action = eclim#project#problems#IsProblemsList() ? 'r' : ' '
+  call eclim#util#SetQuickfixList(errors, action)
+
+  " generate a 'signature' to distinguish the problems list from other qf
+  " lists.
+  let s:eclim_problems_sig = s:QuickfixSignature()
+  let s:eclim_problems_bang = a:bang
+
+  if a:open
+    exec g:EclimProjectProblemsQuickFixOpen
+  endif
+endfunction " }}}
+
+function! eclim#project#problems#ProblemsUpdate(action) " {{{
+  if a:action == 'save' && !g:EclimProjectProblemsUpdateOnSave
+    return
+  endif
+
+  if a:action == 'build' && !g:EclimProjectProblemsUpdateOnBuild
+    return
+  endif
+
+  if !eclim#project#problems#IsProblemsList()
+    return
+  endif
+
+  " preserve the cursor position in the quickfix window
+  let qf_winnr = 0
+  let index = 1
+  while index <= winnr('$')
+    if getbufvar(winbufnr(index), '&ft') == 'qf'
+      let cur = winnr()
+      let qf_winnr = index
+      exec qf_winnr . 'winc w'
+      let pos = getpos('.')
+      exec cur . 'winc w'
+      break
+    endif
+    let index += 1
+  endwhile
+
+  let bang = exists('s:eclim_problems_bang') ? s:eclim_problems_bang : ''
+  call eclim#project#problems#Problems('', 0, bang)
+
+  " restore the cursor position
+  if qf_winnr
+    let cur = winnr()
+    exec qf_winnr . 'winc w'
+    call setpos('.', pos)
+    redraw
+    exec cur . 'winc w'
+  endif
+endfunction " }}}
+
+function! eclim#project#problems#IsProblemsList() " {{{
+  " if available, compare the problems signature against the signature of
+  " the current list to see if we are now on the problems list, probably via
+  " :colder or :cnewer.
+  if exists('s:eclim_problems_sig')
+    return s:QuickfixSignature() == s:eclim_problems_sig
+  endif
+  if exists('s:eclim_problems_bang')
+    unlet s:eclim_problems_bang
+  endif
+  return 0
+endfunction " }}}
+
+function! s:QuickfixSignature() " {{{
+  let qflist = getqflist()
+  let len = len(qflist)
+  return {
+      \ 'len': len,
+      \ 'first': len > 0 ? (qflist[0]['bufnr'] . ':' . qflist[0]['text']) : '',
+      \ 'last': len > 0 ? (qflist[-1]['bufnr'] . ':' . qflist[-1]['text']) : ''
+    \ }
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/project/tree.vim

@@ -0,0 +1,517 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Global Variables {{{
+  if !exists('g:EclimProjectTreeActions')
+    let g:EclimProjectTreeActions = [
+        \ {'pattern': '.*', 'name': 'Split', 'action': 'split'},
+        \ {'pattern': '.*', 'name': 'VSplit', 'action': 'vsplit'},
+        \ {'pattern': '.*', 'name': 'Tab', 'action': 'tablast | tabnew'},
+        \ {'pattern': '.*', 'name': 'Edit', 'action': 'edit'},
+      \ ]
+  endif
+" }}}
+
+" Script Variables {{{
+  let s:project_tree_ids = 0
+  let s:shared_instances_by_buffer = {}
+  let s:shared_instances_by_names = {}
+" }}}
+
+function! eclim#project#tree#ProjectTree(...) " {{{
+  " Open a tree view of the current or specified projects.
+
+  " no project dirs supplied, use current project
+  if len(a:000) == 0
+    let name = eclim#project#util#GetCurrentProjectName()
+    let names = [name]
+    if name == ''
+      if exists('t:cwd')
+        let names = [t:cwd]
+      else
+        call eclim#project#util#UnableToDetermineProject()
+        return
+      endif
+    endif
+
+  " list of project names supplied
+  elseif type(a:000[0]) == g:LIST_TYPE
+    let names = a:000[0]
+    if len(names) == 1 && (names[0] == '0' || names[0] == '')
+      return
+    endif
+
+  " list or project names
+  else
+    let names = a:000
+  endif
+
+  let dirs = []
+  let index = 0
+  let names_copy = copy(names)
+  for name in names
+    if name == 'CURRENT'
+      let name = eclim#project#util#GetCurrentProjectName()
+      let names_copy[index] = name
+    endif
+
+    let dir = eclim#project#util#GetProjectRoot(name)
+    if dir == ''
+      let dir = expand(name, ':p')
+      if !isdirectory(dir)
+        if eclim#EclimAvailable(0)
+          call eclim#util#EchoWarning('Project not found: ' . name)
+        endif
+        call remove(names_copy, index)
+        continue
+      endif
+      let names_copy[index] = fnamemodify(substitute(dir, '/$', '', ''), ':t')
+    endif
+    call add(dirs, dir)
+    let index += 1
+  endfor
+  let names = names_copy
+
+  if len(dirs) == 0
+    return
+  endif
+
+  " for session reload
+  let g:Eclim_project_tree_names = join(names, '|')
+
+  let display = len(names) == 1 ?
+    \ 'Project: ' . names[0] :
+    \ 'Projects: ' . join(names, ', ')
+
+  call eclim#project#tree#ProjectTreeClose()
+  call eclim#project#tree#ProjectTreeOpen(display, names, dirs)
+endfunction " }}}
+
+function! eclim#project#tree#ProjectTreeToggle() " {{{
+  let title = s:GetTreeTitle()
+  let bufnum = bufnr(title)
+  let winnum = bufwinnr(title)
+  if bufnum == -1 || winnum == -1
+    call eclim#project#tree#ProjectTree()
+  else
+    exec winnum . 'winc w'
+    close
+    winc p
+  endif
+endfunction " }}}
+
+function! eclim#project#tree#ProjectTreeOpen(display, names, dirs) " {{{
+  let expand = len(a:dirs) == 1
+  let expandDir = ''
+  if expand && g:EclimProjectTreeExpandPathOnOpen
+    let expandDir = substitute(expand('%:p:h'), '\', '/', 'g')
+  endif
+
+  " see if we should just use a shared tree
+  let shared = s:GetSharedTreeBuffer(a:names)
+  if shared != -1 && bufloaded(shared)
+    call eclim#display#window#VerticalToolWindowOpen(bufname(shared), 9)
+    "exec 'buffer ' . shared
+    if line('$') > 1 || getline(1) !~ '^\s*$'
+      setlocal nowrap nonumber
+      setlocal foldmethod=manual foldtext=getline(v:foldstart)
+      exec 'setlocal statusline=' . escape(a:display, ' ')
+      if !exists('t:project_tree_name')
+        exec 'let t:project_tree_id = ' .
+          \ substitute(bufname(shared), g:EclimProjectTreeTitle . '\(\d\+\)', '\1', '')
+      endif
+
+      if expand && expandDir != ''
+        call eclim#tree#ExpandPath(s:GetTreeTitle(), expandDir)
+      endif
+
+      return
+    endif
+  endif
+
+  " clear the project tree id if we are replacing a shared tree instance
+  if g:EclimProjectTreeSharedInstance && exists('t:project_tree_id')
+    unlet t:project_tree_id
+  endif
+
+  call eclim#display#window#VerticalToolWindowOpen(s:GetTreeTitle(), 9)
+
+  " command used to navigate to a content window before executing a command.
+  if !exists('g:EclimProjectTreeContentWincmd')
+    if g:VerticalToolWindowSide == 'right'
+      let g:EclimProjectTreeContentWincmd = 'winc h'
+    else
+      let g:EclimProjectTreeContentWincmd = 'winc l'
+    endif
+  endif
+
+  if exists('g:TreeSettingsFunction')
+    let s:TreeSettingsFunction = g:TreeSettingsFunction
+  endif
+  let g:TreeSettingsFunction = 'eclim#project#tree#ProjectTreeSettings'
+
+  try
+    call eclim#tree#Tree(s:GetTreeTitle(), a:dirs, a:names, expand, [])
+  finally
+    if exists('s:TreeSettingsFunction')
+      let g:TreeSettingsFunction = s:TreeSettingsFunction
+    else
+      unlet g:TreeSettingsFunction
+    endif
+  endtry
+
+  setlocal bufhidden=hide
+  exec 'setlocal statusline=' . escape(a:display, ' ')
+
+  if expand && expandDir != ''
+    call eclim#util#DelayedCommand(
+      \ 'call eclim#tree#ExpandPath("' . s:GetTreeTitle() . '", "' . expandDir . '")')
+  endif
+
+  normal! zs
+
+  let instance_names = join(a:names, '_')
+  let instance_names = substitute(instance_names, '\W', '_', 'g')
+
+  " remove the old associated tree value if one exists
+  silent! unlet s:shared_instances_by_names[s:shared_instances_by_buffer[bufnr('%')]]
+
+  let s:shared_instances_by_buffer[bufnr('%')] = instance_names
+  let s:shared_instances_by_names[instance_names] = bufnr('%')
+
+  call s:Mappings()
+  setlocal modifiable
+  call append(line('$'), ['', '" use ? to view help'])
+  call s:InfoLine()
+  setlocal nomodifiable
+endfunction " }}}
+
+function! eclim#project#tree#ProjectTreeClose() " {{{
+  if exists('t:project_tree_name') || exists('t:project_tree_id')
+    let winnr = bufwinnr(s:GetTreeTitle())
+    if winnr != -1
+      exec winnr . 'winc w'
+      close
+    endif
+  endif
+endfunction " }}}
+
+function! eclim#project#tree#Restore() " {{{
+  if exists('t:project_tree_restoring')
+    return
+  endif
+  let t:project_tree_restoring = 1
+
+  " prevent auto open from firing after session is loaded.
+  augroup project_tree_autoopen
+    autocmd!
+  augroup END
+
+  let title = s:GetTreeTitle()
+  let winnum = bufwinnr(title)
+  if winnum != -1
+    if exists('g:Eclim_project_tree_names')
+      let projects = split(g:Eclim_project_tree_names, '|')
+      call map(projects, 'escape(v:val, " ")')
+      let names = join(projects, ' ')
+      call eclim#util#DelayedCommand(
+        \ 'let bufnum = bufnr("%") | ' .
+        \ 'exec "ProjectTree ' . names . '" | ' .
+        \ 'exec bufwinnr(bufnum) . "winc w" | ' .
+        \ 'unlet t:project_tree_restoring')
+    else
+      exec 'bd ' . bufnr(title)
+    endif
+  endif
+endfunction " }}}
+
+function! s:GetTreeTitle() " {{{
+  " support a custom name from an external plugin
+  if exists('t:project_tree_name')
+    return t:project_tree_name
+  endif
+
+  if !exists('t:project_tree_id')
+    let t:project_tree_id = s:project_tree_ids + 1
+    let s:project_tree_ids += 1
+  endif
+  return g:EclimProjectTreeTitle . t:project_tree_id
+endfunction " }}}
+
+function! s:GetSharedTreeBuffer(names) " {{{
+  let instance_names = join(a:names, '_')
+  let instance_names = substitute(instance_names, '\W', '_', 'g')
+  if g:EclimProjectTreeSharedInstance &&
+   \ has_key(s:shared_instances_by_names, instance_names)
+    return s:shared_instances_by_names[instance_names]
+  endif
+  return -1
+endfunction " }}}
+
+function! s:Mappings() " {{{
+  nnoremap <buffer> <silent> E :call <SID>OpenFile('edit')<cr>
+  nnoremap <buffer> <silent> S :call <SID>OpenFile('split')<cr>
+  nnoremap <buffer> <silent> \| :call <SID>OpenFile('vsplit')<cr>
+  nnoremap <buffer> <silent> T :call <SID>OpenFile('tablast \| tabnew')<cr>
+  nnoremap <buffer> <silent> F :call <SID>OpenFileName()<cr>
+  nnoremap <buffer> <silent> Y :call <SID>YankFileName()<cr>
+
+  " assign to buffer var to get around weird vim issue passing list containing
+  " a string w/ a '<' in it on execution of mapping.
+  let b:project_tree_help = [
+      \ '<cr> - open/close dir, open file',
+      \ 'o - toggle dir fold, choose file open action',
+      \ 'E - open with :edit',
+      \ 'S - open in a new split window',
+      \ '| (pipe) - open in a new vertical split window',
+      \ 'T - open in a new tab',
+      \ 'R - refresh directory',
+      \ 'i - view file info',
+      \ 's - open shell at directory',
+      \ 'p - move cursor to parent dir',
+      \ 'P - move cursor to last child of dir',
+      \ 'C - set root to dir under the cursor',
+      \ 'B - set root up one dir',
+      \ '~ - set root to home dir',
+      \ 'K - set root to top most dir',
+      \ 'F - open/create a file by name',
+      \ 'D - create a new directory',
+      \ 'Y - yank current file/dir path to the clipboard',
+      \ 'A - toggle hide/view hidden files',
+      \ ':CD <dir> - set the root to <dir>',
+    \ ]
+  nnoremap <buffer> <silent> ?
+    \ :call eclim#help#BufferHelp(b:project_tree_help, 'horizontal', 10)<cr>
+endfunction " }}}
+
+function! s:InfoLine() " {{{
+  setlocal modifiable
+  let pos = getpos('.')
+  if len(b:roots) == 1
+    let lnum = line('$') - 1
+    if getline(lnum) =~ '^"'
+      exec lnum . ',' . lnum . 'delete _'
+    endif
+
+    let info = ''
+    try
+      let info = function('vcs#util#GetInfo')(b:roots[0])
+    catch /E\(117\|700\)/
+      " fall back to fugitive
+      try
+        " fugitive calls a User autocmd, so stop if that one is triggering
+        " this one to prevent a recursive loop
+        if exists('b:eclim_fugative_autocmd')
+          return
+        endif
+
+        " make sure fugitive has the git dir for the current project
+        if !exists('b:git_dir') || (b:git_dir !~ '^\M' . b:roots[0])
+          let cwd = ''
+          if getcwd() . '/' != b:roots[0]
+            let cwd = getcwd()
+            exec 'lcd ' . escape(b:roots[0], ' ')
+          endif
+
+          if exists('b:git_dir')
+            unlet b:git_dir
+          endif
+
+          " slight hack to prevent recursive autocmd loop with fugitive
+          let b:eclim_fugative_autocmd = 1
+
+          silent! doautocmd fugitive BufReadPost %
+
+          if cwd != ''
+            exec 'lcd ' . escape(cwd, ' ')
+          endif
+        endif
+
+        let info = function('fugitive#statusline')()
+        if info != ''
+          let branch = substitute(info, '^\[\Git(\(.*\))\]$', '\1', 'g')
+          if branch != info
+            let info = 'git:' . branch
+          endif
+        endif
+      catch /E\(117\|700\)/
+        " noop if the neither function was found
+      finally
+          silent! unlet b:eclim_fugative_autocmd
+      endtry
+    endtry
+
+    " &modifiable check for silly side effect of fugitive autocmd
+    if info != '' && &modifiable
+      call append(line('$') - 1, '" ' . info)
+    endif
+  endif
+  call setpos('.', pos)
+  setlocal nomodifiable
+endfunction " }}}
+
+function! s:PathEcho() " {{{
+  if mode() != 'n'
+    return
+  endif
+
+  let path = eclim#tree#GetPath()
+  let path = substitute(path, eclim#tree#GetRoot(), '', '')
+  if path !~ '^"'
+    call eclim#util#WideMessage('echo', path)
+  else
+    call eclim#util#WideMessage('echo', '')
+  endif
+endfunction " }}}
+
+function! s:OpenFile(action) " {{{
+  let path = eclim#tree#GetPath()
+  if path !~ '/$'
+    if !filereadable(path)
+      echo "File is not readable or has been deleted."
+      return
+    endif
+
+    call eclim#tree#ExecuteAction(path,
+      \ "call eclim#project#tree#OpenProjectFile('" . a:action . "', '<file>')")
+  endif
+endfunction " }}}
+
+function! s:OpenFileName() " {{{
+  let path = eclim#tree#GetPath()
+  if !isdirectory(path)
+    let path = fnamemodify(path, ':h') . '/'
+  endif
+
+  let response = input('file: ', path, 'file')
+  if response != ''
+    let actions = eclim#tree#GetFileActions(response)
+    call eclim#tree#ExecuteAction(response, actions[0].action)
+  endif
+endfunction " }}}
+
+function! s:YankFileName() " {{{
+  let path = eclim#tree#GetPath()
+  let [@*, @+, @"] = [path, path, path]
+  call eclim#util#Echo('Copied path to clipboard: ' . path)
+endfunction " }}}
+
+function! eclim#project#tree#ProjectTreeSettings() " {{{
+  for action in g:EclimProjectTreeActions
+    call eclim#tree#RegisterFileAction(action.pattern, action.name,
+      \ "call eclim#project#tree#OpenProjectFile('" . action.action . "', '<file>')")
+  endfor
+
+  call eclim#tree#RegisterDirAction(function('eclim#project#tree#InjectLinkedResources'))
+
+  if exists('s:TreeSettingsFunction')
+    let l:Settings = function(s:TreeSettingsFunction)
+    call l:Settings()
+  endif
+
+  augroup eclim_tree
+    autocmd User <buffer> call <SID>InfoLine()
+    if g:EclimProjectTreePathEcho
+      autocmd CursorMoved <buffer> call <SID>PathEcho()
+    endif
+  augroup END
+endfunction " }}}
+
+function! eclim#project#tree#OpenProjectFile(cmd, file) " {{{
+  " Execute the supplied command in one of the main content windows.
+  if eclim#util#GoToBufferWindow(a:file)
+    return
+  endif
+
+  let file = a:file
+  let cmd = a:cmd
+  let cwd = getcwd()
+
+  exec g:EclimProjectTreeContentWincmd
+
+  " if the buffer is a no name and action is split, use edit instead.
+  if cmd =~ 'split' && expand('%') == '' &&
+   \ !&modified && line('$') == 1 && getline(1) == ''
+    let cmd = 'edit'
+  endif
+
+  " current file doesn't share same cwd as the project tree
+  let lcwd = getcwd()
+  if lcwd != cwd && !filereadable(file)
+    let file = escape(substitute(cwd, '\', '/', 'g'), ' &') . '/' . file
+  endif
+
+  try
+    exec cmd . ' ' file
+  catch /E325/
+    " ignore attention error since the user should be prompted to handle it.
+  finally
+    if lcwd != cwd
+      exec 'lcd ' . escape(cwd, ' ')
+    endif
+  endtry
+endfunction " }}}
+
+function! eclim#project#tree#InjectLinkedResources(dir, contents) " {{{
+  let project = eclim#project#util#GetProject(a:dir)
+  if len(project) == 0
+    return
+  endif
+
+  " listing the project root, so inject our project links
+  if len(get(project, 'links', {})) &&
+   \ substitute(a:dir, '/$', '', '') == project.path
+    if !exists('b:links')
+      let b:links = {}
+    endif
+    call extend(b:links, project.links)
+
+    let links = keys(project.links)
+    call sort(links)
+
+    let index = 0
+    for entry in copy(a:contents)
+      if !len(links)
+        break
+      endif
+
+      while len(links) && links[0] < fnamemodify(entry, ':h:t')
+        call insert(a:contents, a:dir . remove(links, 0) . '/', index)
+      endwhile
+      let index += 1
+    endfor
+
+    for link in links
+      call add(a:contents, a:dir . link . '/')
+    endfor
+  endif
+endfunction " }}}
+
+function! eclim#project#tree#HorizontalContentWindow() " {{{
+  " Command for g:EclimProjectTreeContentWincmd used when relative to a
+  " horizontal taglist window.
+  winc k
+  if exists('g:TagList_title') && bufname(bufnr('%')) == g:TagList_title
+    winc k
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/taglisttoo/lang/commonsvalidator.vim

@@ -0,0 +1,33 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2011  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Parse(file, settings) {{{
+function! eclim#taglisttoo#lang#commonsvalidator#Parse(file, settings)
+  return taglisttoo#util#Parse(a:file, a:settings, [
+      \ ['c', '<constant-name\s*>\s*(.*?)\s*</constant-name\s*>', 1],
+      \ ['f', "<form\\s+[^>]*?name=['\"](.*?)['\"]", 1],
+      \ ['v', "<validator\\s+[^>]*?name=['\"](.*?)['\"]", 1],
+    \ ])
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/taglisttoo/lang/eclimhelp.vim

@@ -0,0 +1,32 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2011  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Parse(file, settings) {{{
+function! eclim#taglisttoo#lang#eclimhelp#Parse(file, settings)
+  return taglisttoo#util#Parse(a:file, a:settings, [
+      \ ['a', '\*([^ *]+)\*', 1],
+      \ ['s', '\n([^\n]+)\n[=^-]{4,}', 1],
+    \ ])
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/taglisttoo/lang/forrest.vim

@@ -0,0 +1,39 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2011  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" ParseDocument(file, settings) {{{
+function! eclim#taglisttoo#lang#forrest#ParseDocument(file, settings)
+  return taglisttoo#util#Parse(a:file, a:settings, [
+      \ ['s', "<section\\s+[^>]*?id=['\"](.*?)['\"]", 1],
+    \ ])
+endfunction " }}}
+
+" ParseStatus(file, settings) {{{
+function! eclim#taglisttoo#lang#forrest#ParseStatus(file, settings)
+  return taglisttoo#util#Parse(a:file, a:settings, [
+      \ ['t', "<actions\\s+[^>]*?priority=['\"](.*?)['\"]", 1],
+      \ ['r', "<release\\s+[^>]*?version=['\"](.*?)['\"]", 1],
+    \ ])
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/taglisttoo/lang/gant.vim

@@ -0,0 +1,33 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2010  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Parse(file, settings) {{{
+function! eclim#taglisttoo#lang#gant#Parse(file, settings)
+  return taglisttoo#util#Parse(a:file, a:settings, [
+      \ ['t', "\\s*target\\s*\\(\\s*(?:name\\s*:)?\\s*['\"]?([^'\",: ]+)", 1],
+      \ ['f', "\\s*def\\s+(\\w+)\\s*\\(", 1],
+      \ ['f', "\\s*(?:final|def)?\\s*(\\w+)\\s*=\\s*\\{", 1],
+    \ ])
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/taglisttoo/lang/hibernate.vim

@@ -0,0 +1,37 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2011  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Parse(file, settings) {{{
+function! eclim#taglisttoo#lang#hibernate#Parse(file, settings)
+  return taglisttoo#util#Parse(a:file, a:settings, [
+      \ ['c', "<class\\s+[^>]*?name=['\"](.*?)['\"]", 1],
+      \ ['j', "<joined-subclass\\s+[^>]*?name=['\"](.*?)['\"]", 1],
+      \ ['t', "<typedef\\s+[^>]*?name=['\"](.*?)['\"]", 1],
+      \ ['f', "<filter-def\\s+[^>]*?name=['\"](.*?)['\"]", 1],
+      \ ['i', "<import\\s+[^>]*?class=['\"](.*?)['\"]", 1],
+      \ ['q', "<query\\s+[^>]*?name=['\"](.*?)['\"]", 1],
+      \ ['s', "<sql-query\\s+[^>]*?name=['\"](.*?)['\"]", 1],
+    \ ])
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/taglisttoo/lang/junit.vim

@@ -0,0 +1,33 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2011  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Parse(file, settings) {{{
+function! eclim#taglisttoo#lang#junit#Parse(file, settings)
+  return taglisttoo#util#Parse(a:file, a:settings, [
+      \ ['t', "<testcase\\s+[^>]*?\\bname=['\"](.*?)['\"]", 1],
+      \ ['f', "<testcase\\s+[^>]*?\\bname=['\"]([^'\"]+?)['\"]\\s+[^>]*?>\\s*<failure\\b", 1],
+      \ ['o', '<system-(out|err)\s*>', 1],
+    \ ])
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/taglisttoo/lang/spring.vim

@@ -0,0 +1,33 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2011  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Parse(file, settings) {{{
+function! eclim#taglisttoo#lang#spring#Parse(file, settings)
+  return taglisttoo#util#Parse(a:file, a:settings, [
+      \ ['b', "<bean\\s+[^>]*?(?:name|id)=['\"](.*?)['\"]", 1],
+      \ ['i', "<import\\s+[^>]*?resource=['\"](.*?)['\"]", 1],
+      \ ['a', "<alias\\s+[^>]*?alias=['\"](.*?)['\"]", 1],
+    \ ])
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/taglisttoo/lang/webxml.vim

@@ -0,0 +1,43 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"
+" License:
+"
+" Copyright (C) 2005 - 2010  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" ParseWebXml(file, settings) {{{
+function! eclim#taglisttoo#lang#webxml#ParseWebXml(file, settings)
+  return taglisttoo#util#Parse(a:file, a:settings, [
+      \ ['p', '<context-param\s*>\s*<param-name\s*>\s*(.*?)\s*</param-name\s*>', 1],
+      \ ['f', '<filter\s*>\s*<filter-name\s*>\s*(.*?)\s*</filter-name\s*>', 1],
+      \ ['i', '<filter-mapping\s*>\s*<filter-name\s*>\s*(.*?)\s*</filter-name\s*>', 1],
+      \ ['l', '<listener\s*>\s*<listener-class\s*>\s*(.*?)\s*</listener-class\s*>', 1],
+      \ ['s', '<servlet\s*>\s*<servlet-name\s*>\s*(.*?)\s*</servlet-name\s*>', 1],
+      \ ['v', '<servlet-mapping\s*>\s*<servlet-name\s*>\s*(.*?)\s*</servlet-name\s*>', 1],
+    \ ])
+endfunction " }}}
+
+" ParseTld(file, settings) {{{
+function! eclim#taglisttoo#lang#webxml#ParseTld(file, settings)
+  return taglisttoo#util#Parse(a:file, a:settings, [
+      \ ['t', '<tag\s*>\s*<name\s*>\s*(.*?)\s*</name\s*>', 1],
+    \ ])
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/taglisttoo/lang/wsdl.vim

@@ -0,0 +1,48 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"   Copyright (c) 2005 - 2011, Eric Van Dewoestine
+"   All rights reserved.
+"
+"   Redistribution and use of this software in source and binary forms, with
+"   or without modification, are permitted provided that the following
+"   conditions are met:
+"
+"   * Redistributions of source code must retain the above
+"     copyright notice, this list of conditions and the
+"     following disclaimer.
+"
+"   * Redistributions in binary form must reproduce the above
+"     copyright notice, this list of conditions and the
+"     following disclaimer in the documentation and/or other
+"     materials provided with the distribution.
+"
+"   * Neither the name of Eric Van Dewoestine nor the names of its
+"     contributors may be used to endorse or promote products derived from
+"     this software without specific prior written permission of
+"     Eric Van Dewoestine.
+"
+"   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+"   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+"   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+"   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+"   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+"   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+"   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+"   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+"   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+"   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+"   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+" }}}
+
+" Parse(file, settings) {{{
+function! eclim#taglisttoo#lang#wsdl#Parse(file, settings)
+  return taglisttoo#util#Parse(a:file, a:settings, [
+      \ ['t', "<xsd:complexType\\s+[^>]*?name=['\"](.*?)['\"]", 1],
+      \ ['m', "<message\\s+[^>]*?name=['\"](.*?)['\"]", 1],
+      \ ['p', "<operation\\s+[^>]*?name=['\"](.*?)['\"]>\\s*<input", 1],
+      \ ['b', "<operation\\s+[^>]*?name=['\"]([^\n]*?)['\"]>\\s*<soap:operation", 1],
+    \ ])
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/vimplugin.vim

@@ -0,0 +1,82 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   Contains any global vim side code for embedding gvim in eclipse.
+"
+" License:
+"
+" Copyright (C) 2005 - 2011  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" BufferWritten() {{{
+" Invoked when a buffer opened from eclipse is saved, to notify eclipse of the
+" save.
+function eclim#vimplugin#BufferWritten()
+  if has('netbeans_enabled') && exists('g:vimplugin_running')
+    if exists('b:eclim_file_modified')
+      unlet b:eclim_file_modified
+    endif
+    nbkey unmodified
+  endif
+endfunction " }}}
+
+" BufferModified() {{{
+" Invoked on cursor hold to check if a previously modified buffer is now
+" unmodified, and vice versa, so that eclipse can be notified.
+function eclim#vimplugin#BufferModified()
+  if has('netbeans_enabled') && exists('g:vimplugin_running')
+    if !exists('b:eclim_file_modified')
+      let b:eclim_file_modified = &modified
+    endif
+
+    if &modified != b:eclim_file_modified
+      unlet b:eclim_file_modified
+      exec 'nbkey ' . (&modified ? 'modified' : 'unmodified')
+    endif
+    let b:eclim_file_modified = &modified
+  endif
+endfunction " }}}
+
+" BufferClosed() {{{
+" Invoked when a buffer is removed from a window to signal that eclipse should
+" close the associated editor tab. This is only needed for external vim +
+" tabbed mode.
+function eclim#vimplugin#BufferClosed()
+  if has('netbeans_enabled') && exists('g:vimplugin_tabbed')
+    exec 'nbkey fileClosed ' . expand('<afile>:p')
+  endif
+endfunction " }}}
+
+" BufferEnter() {{{
+" Invoked when switching buffers so we can update the eclipse tab title.
+function eclim#vimplugin#BufferEnter()
+  if has('netbeans_enabled') && exists('g:vimplugin_running')
+    exec 'nbkey bufferEnter ' . expand('<afile>:p')
+  endif
+endfunction " }}}
+
+" FeedKeys(keys, [refocusGvim]) {{{
+" Feeds eclipse compatible key string to eclipse if current gvim instance is
+" attached via the netbeans protocol.
+function eclim#vimplugin#FeedKeys(keys, ...)
+  if has('netbeans_enabled') && exists('g:vimplugin_running')
+    let refocus = a:0 > 0 && a:1 ? ',refocus' : ''
+    silent exec 'nbkey feedkeys ' . a:keys . refocus
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/web.vim

@@ -0,0 +1,232 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/common/web.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Global Variables {{{
+if !exists("g:EclimOpenUrlInVimPatterns")
+  let g:EclimOpenUrlInVimPatterns = []
+endif
+if !exists("g:EclimOpenUrlInVimAction")
+  let g:EclimOpenUrlInVimAction = g:EclimDefaultFileOpenAction
+endif
+" }}}
+
+" Script Variables {{{
+  let s:win_browsers = [
+      \ 'C:/Program Files/Opera/Opera.exe',
+      \ 'C:/Program Files/Mozilla Firefox/firefox.exe',
+      \ 'C:/Program Files/Internet Explorer/iexplore.exe'
+    \ ]
+
+  let s:browsers = [
+      \ 'xdg-open', 'chromium', 'opera', 'firefox', 'konqueror',
+      \ 'epiphany', 'mozilla', 'netscape', 'iexplore'
+    \ ]
+" }}}
+
+function! eclim#web#OpenUrl(url, ...) " {{{
+  " Opens the supplied url in a web browser or opens the url under the cursor.
+
+  if !exists('s:browser') || s:browser == ''
+    let s:browser = s:DetermineBrowser()
+
+    " slight hack for IE which doesn't like the url to be quoted.
+    if s:browser =~ 'iexplore' && !has('win32unix')
+      let s:browser = substitute(s:browser, '"', '', 'g')
+    endif
+  endif
+
+  if s:browser == ''
+    return
+  endif
+
+  let url = a:url
+  if url == ''
+    if len(a:000) > 2
+      let start = a:000[1]
+      let end = a:000[2]
+      while start <= end
+        call eclim#web#OpenUrl(eclim#util#GrabUri(start, col('.')), a:000[0])
+        let start += 1
+      endwhile
+      return
+    else
+      let url = eclim#util#GrabUri()
+    endif
+  endif
+
+  if url == ''
+    call eclim#util#EchoError(
+      \ 'No url supplied at command line or found under the cursor.')
+    return
+  endif
+
+  " prepend http:// or file:// if no protocol defined.
+  if url !~ '^\(https\?\|file\):'
+    " absolute file on windows or unix
+    if url =~ '^\([a-zA-Z]:[/\\]\|/\)'
+      let url = 'file://' . url
+
+    " everything else
+    else
+      let url = 'http://' . url
+    endif
+  endif
+
+  if len(a:000) == 0 || a:000[0] == ''
+    for pattern in g:EclimOpenUrlInVimPatterns
+      if url =~ pattern
+        exec g:EclimOpenUrlInVimAction . ' ' . url
+        return
+      endif
+    endfor
+  endif
+
+  let url = substitute(url, '\', '/', 'g')
+  let url = escape(url, '&%!')
+  let url = escape(url, '%!')
+  let command = escape(substitute(s:browser, '<url>', url, ''), '#')
+  silent call eclim#util#Exec(command)
+  redraw!
+
+  if v:shell_error
+    call eclim#util#EchoError("Unable to open browser:\n" . s:browser .
+      \ "\nCheck that the browser executable is in your PATH " .
+      \ "or that you have properly configured g:EclimBrowser")
+  endif
+endfunction " }}}
+
+function! eclim#web#SearchEngine(url, args, line1, line2) " {{{
+  " Function to use a search engine to search for a word or phrase.
+
+  let search_string = a:args
+  if search_string == ''
+    let search_string = eclim#util#GetVisualSelection(a:line1, a:line2, 0)
+    if search_string == ''
+      let search_string = expand('<cword>')
+    endif
+  endif
+
+  let search_string = eclim#html#util#UrlEncode(search_string)
+  let url = substitute(a:url, '<query>', search_string, '')
+
+  call eclim#web#OpenUrl(url)
+endfunction " }}}
+
+function! eclim#web#WordLookup(url, word) " {{{
+  " Function to lookup a word on an online dictionary, thesaurus, etc.
+
+  let word = a:word
+  if word == ''
+    let word = expand('<cword>')
+  endif
+
+  let url = substitute(a:url, '<query>', word, '')
+
+  call eclim#web#OpenUrl(url)
+endfunction " }}}
+
+function! s:DetermineBrowser() " {{{
+  let browser = ''
+
+  " user specified a browser, we just need to fill in any gaps if necessary.
+  if exists("g:EclimBrowser")
+    let browser = g:EclimBrowser
+    " add "<url>" if necessary
+    if browser !~ '<url>'
+      let browser = substitute(browser,
+        \ '^\([[:alnum:][:blank:]-/\\_.:"]\+\)\(.*\)$',
+        \ '\1 "<url>" \2', '')
+    endif
+
+    if has("win32") || has("win64")
+      " add 'start' to run process in background if necessary.
+      if browser !~ '^[!]\?start'
+        let browser = 'start ' . browser
+      endif
+    else
+      " add '&' to run process in background if necessary.
+      if browser !~ '&\s*$' &&
+       \ browser !~ '^\(/[/a-zA-Z0-9]\+/\)\?\<\(links\|lynx\|elinks\|w3m\)\>'
+        let browser = browser . ' &'
+      endif
+
+      " add redirect of std out and error if necessary.
+      if browser !~ '/dev/null'
+        let browser = substitute(browser, '\s*&\s*$', '&> /dev/null &', '')
+      endif
+    endif
+
+    if browser !~ '^\s*!'
+      let browser = '!' . browser
+    endif
+
+  " user did not specify a browser, so attempt to find a suitable one.
+  else
+    if has('win32') || has('win64') || has('win32unix')
+      " Note: this version may not like .html suffixes on windows 2000
+      if executable('rundll32')
+        let browser = 'rundll32 url.dll,FileProtocolHandler <url>'
+      endif
+      " this doesn't handle local files very well or '&' in the url.
+      "let browser = '!cmd /c start <url>'
+      if browser == ''
+        for name in s:win_browsers
+          if has('win32unix')
+            let name = eclim#cygwin#CygwinPath(name)
+          endif
+          if executable(name)
+            let browser = name
+            if has('win32unix')
+              let browser = '"' . browser . '"'
+            endif
+            break
+          endif
+        endfor
+      endif
+    elseif has('mac')
+      let browser = '!open "<url>"'
+    else
+      for name in s:browsers
+        if executable(name)
+          let browser = name
+          break
+        endif
+      endfor
+    endif
+
+    if browser != ''
+      let g:EclimBrowser = browser
+      let browser = s:DetermineBrowser()
+    endif
+  endif
+
+  if browser == ''
+    call eclim#util#EchoError("Unable to determine browser.  " .
+      \ "Please set g:EclimBrowser to your preferred browser.")
+  endif
+
+  return browser
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/xml/complete.vim

@@ -0,0 +1,89 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/xml/complete.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Varables {{{
+  let s:complete_command =
+    \ '-command xml_complete -p "<project>" -f "<file>" ' .
+    \ '-o <offset> -e <encoding>'
+" }}}
+
+" CodeComplete(findstart, base) {{{
+" Handles xml code completion.
+function! eclim#xml#complete#CodeComplete(findstart, base)
+  if !eclim#project#util#IsCurrentFileInProject(0)
+    return a:findstart ? -1 : []
+  endif
+
+  if a:findstart
+    call eclim#lang#SilentUpdate(1)
+
+    " locate the start of the word
+    let line = getline('.')
+
+    let start = col('.') - 1
+
+    while start > 0 && line[start - 1] =~ '[[:alnum:]_-]'
+      let start -= 1
+    endwhile
+
+    return start
+  else
+    let offset = eclim#util#GetOffset() + len(a:base)
+    let project = eclim#project#util#GetCurrentProjectName()
+    let file = eclim#lang#SilentUpdate(1, 0)
+    if file == ''
+      return []
+    endif
+
+    let command = s:complete_command
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+    let command = substitute(command, '<offset>', offset, '')
+    let command = substitute(command, '<encoding>', eclim#util#GetEncoding(), '')
+
+    let completions = []
+    let results = eclim#Execute(command)
+    if type(results) != g:LIST_TYPE
+      return
+    endif
+
+    for result in results
+      let word = result.completion
+      if getline('.') =~ '\w:\w*\%' . col('.') . 'c'
+        let word = substitute(word, '^\w\+:', '', '')
+      endif
+
+      let menu = eclim#html#util#HtmlToText(result.menu)
+      let info = eclim#html#util#HtmlToText(result.info)
+
+      let dict = {'word': word, 'menu': menu, 'info': info}
+
+      call add(completions, dict)
+    endfor
+
+    return completions
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/xml/definition.vim

@@ -0,0 +1,79 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/xml/definition.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2009  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+let s:element_def{'dtd'} = '<!ELEMENT\s\+<name>\>\(\s\|(\|$\)'
+let s:element_def{'xsd'} =
+    \ '<\s*\(.\{-}:\)\?element\>\_[^>]*name\s*=\s*' .
+    \ g:EclimQuote . '<name>' . g:EclimQuote
+" }}}
+
+" DtdDefinition(element) {{{
+" Opens the current xml file's dtd definition and optionally jumps to an
+" element if an element name supplied.
+function! eclim#xml#definition#DtdDefinition(element)
+  let dtd = eclim#xml#util#GetDtd()
+  let element = a:element == '' ? eclim#xml#util#GetElementName() : a:element
+  call s:OpenDefinition(dtd, element, 'dtd')
+endfunction " }}}
+
+" XsdDefinition(element) {{{
+" Opens the current xml file's xsd definition and optionally jumps to an
+" element if an element name supplied.
+function! eclim#xml#definition#XsdDefinition(element)
+  let element = a:element == '' ? eclim#xml#util#GetElementName() : a:element
+  if element =~ ':'
+    let namespace = substitute(element, ':.*', '', '')
+    let element = substitute(element, '.*:', '', '')
+    let xsd = eclim#xml#util#GetXsd(namespace)
+  else
+    let xsd = eclim#xml#util#GetXsd()
+  endif
+  call s:OpenDefinition(xsd, element, 'xsd')
+endfunction " }}}
+
+" OpenDefinition(file, element, type) {{{
+" Open the supplied definition file and jump to the element if supplied.
+function! s:OpenDefinition(file, element, type)
+  if a:file == ''
+    call eclim#util#EchoWarning('Unable to locate ' . a:type . ' in current file.')
+    return
+  endif
+
+  " see if file is already open.
+  let winnr = bufwinnr(a:file)
+  if winnr != -1
+    exec winnr . 'winc w'
+  else
+    exec 'split ' . a:file
+  endif
+
+  " jump to element definition if supplied
+  if a:element != ''
+    let search = substitute(s:element_def{a:type}, '<name>', a:element, 'g')
+    call search(search, 'w')
+  endif
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/xml/format.vim

@@ -0,0 +1,109 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   see http://eclim.org/vim/xml/format.html
+"
+" License:
+"
+" Copyright (C) 2005 - 2013  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+  let s:command_format =
+    \ '-command xml_format -f "<file>" -w <width> -i <indent> -m <ff>'
+" }}}
+
+function! eclim#xml#format#Format() " {{{
+  call eclim#util#ExecWithoutAutocmds('update')
+  let file = substitute(expand('%:p'), '\', '/', 'g')
+  if has('win32unix')
+    let file = eclim#cygwin#WindowsPath(file)
+  endif
+
+  let command = s:command_format
+  let command = substitute(command, '<file>', file, '')
+  let command = substitute(command, '<width>', &textwidth, '')
+  let command = substitute(command, '<indent>', &shiftwidth, '')
+  let command = substitute(command, '<ff>', &ff, '')
+
+  let result = eclim#Execute(command)
+  if result != '0'
+    silent! 1,$delete _
+    silent put =result
+    silent! 1,1delete _
+  endif
+endfunction " }}}
+
+function! s:SelectOuterTag(count) " {{{
+  let pos = getpos('.')
+
+  exec 'silent! normal! v' . a:count . 'atv'
+  call setpos('.', pos)
+
+  return s:VisualSelectionMap()
+endfunction " }}}
+
+function! s:SelectInnerTag() " {{{
+  silent! normal! vit
+  normal! v
+  call cursor(line("'<"), col("'<"))
+
+  return s:VisualSelectionMap()
+endfunction " }}}
+
+function! s:VisualSelectionMap() " {{{
+  let lstart = line("'<")
+  let cstart = col("'<")
+  let lend = line("'>")
+  let cend = col("'>")
+
+  if cstart > len(getline(lstart))
+    let lstart += 1
+    let cstart = 1
+  endif
+
+  if strpart(getline(lend), 0, cend) =~ '^\s*$'
+    let lend -= 1
+    let cend = len(getline(lend))
+  endif
+
+  return {'lstart': lstart, 'cstart': cstart, 'lend': lend, 'cend': cend}
+endfunction " }}}
+
+function! s:InsertCr(line, col) " {{{
+  call cursor(a:line, a:col)
+  exec "normal! i\<cr>\<esc>"
+endfunction " }}}
+
+function! s:GetRootLine() " {{{
+  let pos = getpos('.')
+
+  let line = 1
+  call cursor(1, 1)
+  while getline('.') !~ '<\w'
+    let line = line('.') + 1
+    if line > line('$')
+      break
+    endif
+    call cursor(line, 1)
+  endwhile
+
+  call setpos('.', pos)
+  return line
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/xml/util.vim

@@ -0,0 +1,137 @@
+" Author:  Eric Van Dewoestine
+"
+" Description: {{{
+"   Utility functions for xml plugins.
+"
+"   This plugin contains shared functions that can be used regardless of the
+"   current file type being edited.
+"
+" License:
+"
+" Copyright (C) 2005 - 2009  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+let s:dtd = '.*' . g:EclimQuote . '\(.*\)' . g:EclimQuote . '\s*>.*'
+let s:xsd = '.\{-}<ns>:schemaLocation\s*=\s*' .
+  \ g:EclimQuote . '\(.\{-}\)' . g:EclimQuote . '.*'
+let s:element = '.\{-}<\([a-zA-Z].\{-}\)\(\s\|>\|$\).*'
+" }}}
+
+" GetDtd() {{{
+" Get the dtd defined in the current file.
+function! eclim#xml#util#GetDtd()
+  let linenum = search('<!DOCTYPE\s\+\_.\{-}>', 'bcnw')
+  if linenum > 0
+    let line = ''
+    while getline(linenum) !~ '>'
+      let line = line . getline(linenum)
+      let linenum += 1
+    endwhile
+    let line = line . getline(linenum)
+
+    let dtd = substitute(line, s:dtd, '\1', '')
+    if dtd != line
+      return dtd
+    endif
+  endif
+  return ''
+endfunction " }}}
+
+" GetXsd() {{{
+" Get the schema defined in the current file, for the optionally provided
+" namespace prefix, or the default namespace.
+function! eclim#xml#util#GetXsd(...)
+  let namespace = ''
+  if len(a:000) > 0
+    let namespace = a:000[0]
+  endif
+
+  " if no namespace given, try 'xsi' as that is a common default.
+  if namespace == ''
+    let xsd = eclim#xml#util#GetXsd('xsi')
+    if xsd != ''
+      return xsd
+    endif
+  endif
+
+  let linenum = search(namespace . ':schemaLocation\>', 'bcnw')
+  if linenum > 0
+    let line = ''
+    while getline(linenum) !~ '>'
+      let line = line . getline(linenum)
+      let linenum += 1
+    endwhile
+    let line = line . getline(linenum)
+
+    let pattern = substitute(s:xsd, '<ns>', namespace, '')
+    let xsd = substitute(line, pattern, '\1', '')
+    if xsd != line
+      " last http definition is the schema
+      return strpart(xsd, strridx(xsd, 'http://'))
+    endif
+  endif
+  return ''
+endfunction " }}}
+
+" GetElementName() {{{
+" Get name of the element that the cursor is currently on.
+function! eclim#xml#util#GetElementName()
+  let line = getline('.')
+  let cnum = col('.')
+  if line[cnum - 1] == '<'
+    let cnum += 1
+  endif
+  if line[cnum - 1] == '>'
+    let cnum -= 1
+  endif
+
+  let name = substitute(line,
+    \ '.*</\?\s*\(.*\%' . cnum . 'c.\{-}\)\(\s.*\|\s*/\?>.*\|$\)', '\1', '')
+
+  if name == line || name =~ '<\|>' || name =~ '\S\s\S'
+    return ''
+  endif
+
+  let name = substitute(name, '\s\|/', '', 'g')
+
+  return name
+endfunction " }}}
+
+" GetParentElementName() {{{
+" Get the parent element name relative to the current cursor position.
+" Depends on 'at' visual selection ability.
+function! eclim#xml#util#GetParentElementName()
+  let pos = getpos('.')
+
+  " select tags (best solution I can think of).
+  silent! normal! v2at
+  normal! v
+
+  call cursor(line("'<"), col("'<"))
+  let parent = eclim#xml#util#GetElementName()
+
+  call setpos('.', pos)
+
+  if eclim#xml#util#GetElementName() == parent
+    return ''
+  endif
+
+  return parent
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker

vim/bundle/eclim/autoload/eclim/xml/validate.vim

@@ -0,0 +1,75 @@
+" Author:  Eric Van Dewoestine
+"
+" License: {{{
+"
+" Copyright (C) 2005 - 2014  Eric Van Dewoestine
+"
+" This program is free software: you can redistribute it and/or modify
+" it under the terms of the GNU General Public License as published by
+" the Free Software Foundation, either version 3 of the License, or
+" (at your option) any later version.
+"
+" This program is distributed in the hope that it will be useful,
+" but WITHOUT ANY WARRANTY; without even the implied warranty of
+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+" GNU General Public License for more details.
+"
+" You should have received a copy of the GNU General Public License
+" along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"
+" }}}
+
+" Script Variables {{{
+let s:command_validate = '-command xml_validate -p "<project>" -f "<file>"'
+" }}}
+
+function! eclim#xml#validate#Validate(on_save, ...) " {{{
+  " Optional args:
+  "   bang: '!' or '', where '!' indicates that we should not jump to the
+  "         first error.
+  if a:on_save && (!g:EclimXmlValidate || eclim#util#WillWrittenBufferClose())
+    return
+  endif
+
+  if eclim#EclimAvailable(0)
+    if !eclim#project#util#IsCurrentFileInProject()
+      return
+    endif
+
+    let project = eclim#project#util#GetCurrentProjectName()
+    let file = eclim#project#util#GetProjectRelativeFilePath()
+    let command = s:command_validate
+    let command = substitute(command, '<project>', project, '')
+    let command = substitute(command, '<file>', file, '')
+    if search('xsi:schemaLocation', 'cnw')
+      let command .= ' -s'
+    endif
+
+    let result = eclim#Execute(command)
+    if type(result) == g:LIST_TYPE && len(result) > 0
+      let errors = eclim#util#ParseLocationEntries(
+        \ result, g:EclimValidateSortResults)
+      call eclim#util#SetLocationList(errors)
+      " bang arg supplied, but no bang, so jump to first error.
+      if len(a:000) > 0 && a:000[0] == ''
+        lfirst
+      endif
+      return 1
+    else
+      call eclim#util#ClearLocationList()
+      return 0
+    endif
+  else
+    " alternative method via xmllint
+    if !a:on_save && executable('xmllint')
+      let file = substitute(expand('%:p'), '\', '/', 'g')
+      call eclim#util#MakeWithCompiler('eclim_xmllint', '', file)
+      call eclim#display#signs#Update()
+    elseif !a:on_save
+      call eclim#util#EchoWarning("eclimd not running.")
+    endif
+  endif
+  return 0
+endfunction " }}}
+
+" vim:ft=vim:fdm=marker