diff --git a/.gitmodules b/.gitmodules index 401b810..693fc2f 100644 --- a/.gitmodules +++ b/.gitmodules @@ -7,9 +7,6 @@ [submodule "vim/bundle/vim-tmux-navigator"] path = vim/bundle/vim-tmux-navigator url = git@github.com:christoomey/vim-tmux-navigator.git -[submodule "vim/bundle/YouCompleteMe"] - path = vim/bundle/YouCompleteMe - url = git@github.com:Valloric/YouCompleteMe [submodule "vim/bundle/bufexplorer"] path = vim/bundle/bufexplorer url = git@github.com:jlanzarotta/bufexplorer.git diff --git a/vim/bundle/YouCompleteMe b/vim/bundle/YouCompleteMe deleted file mode 160000 index af0fdef..0000000 --- a/vim/bundle/YouCompleteMe +++ /dev/null @@ -1 +0,0 @@ -Subproject commit af0fdef1b91717d74e11718eb0ce9a49b061348a diff --git a/vim/bundle/eclim/autoload/eclim.vim b/vim/bundle/eclim/autoload/eclim.vim new file mode 100644 index 0000000..08d5632 --- /dev/null +++ b/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 . +" +" }}} + +" 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 ""' + 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('') == '' || &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, "\$", '', '') + 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\+\ ' || + \ result =~ '^[^\n]*ResourceException(.\{-})\[[0-9]\+\]:[^\n]*\n\s\+\ ' + 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('') == '' || &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('') == '' || &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('') == '' + 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, '', a:project, '') + let command = substitute(command, '', 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 + exec 'autocmd BufWriteCmd ' . + \ '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 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 :call VimSettingHelp() + + augroup eclim_settings + autocmd! BufWriteCmd + autocmd BufWriteCmd 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 diff --git a/vim/bundle/eclim/autoload/eclim/client/nailgun.vim b/vim/bundle/eclim/autoload/eclim/client/nailgun.vim new file mode 100644 index 0000000..a97da4d --- /dev/null +++ b/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 . +" +" }}} + +" 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 diff --git a/vim/bundle/eclim/autoload/eclim/client/python/nailgun.py b/vim/bundle/eclim/autoload/eclim/client/python/nailgun.py new file mode 100644 index 0000000..4abaa76 --- /dev/null +++ b/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 . + +@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 diff --git a/vim/bundle/eclim/autoload/eclim/client/python/nailgun.vim b/vim/bundle/eclim/autoload/eclim/client/python/nailgun.vim new file mode 100644 index 0000000..81cfa31 --- /dev/null +++ b/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 . +" +" }}} + +" Script Variables {{{ + let s:python_dir = expand(":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 diff --git a/vim/bundle/eclim/autoload/eclim/common/buffers.vim b/vim/bundle/eclim/autoload/eclim/common/buffers.vim new file mode 100644 index 0000000..672a2e7 --- /dev/null +++ b/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 . +" +" }}} + +" 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 :call BufferOpen(g:EclimBuffersDefaultAction) + nnoremap E :call BufferOpen('edit') + nnoremap S :call BufferOpen('split') + nnoremap V :call BufferOpen('vsplit') + nnoremap T :call BufferOpen('tablast \| tabnew') + nnoremap D :call BufferDelete() + nnoremap R :Buffers + + " 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 = [ + \ ' - 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 ? + \ :call eclim#help#BufferHelp(b:buffers_help, 'vertical', 40) + + "augroup eclim_buffers + " autocmd! + " autocmd BufAdd,BufWinEnter,BufDelete,BufWinLeave * + " \ call eclim#common#buffers#BuffersUpdate() + " autocmd BufUnload 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 diff --git a/vim/bundle/eclim/autoload/eclim/common/history.vim b/vim/bundle/eclim/autoload/eclim/common/history.vim new file mode 100644 index 0000000..404047d --- /dev/null +++ b/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 . +" +" }}} + +" Script Variables {{{ +let s:command_add = '-command history_add -p "" -f ""' +let s:command_list = '-command history_list -p "" -f ""' +let s:command_revision = + \ '-command history_revision -p "" -f "" -r ' +let s:command_clear = '-command history_clear -p "" -f ""' +" }}} + +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, '') + let command = substitute(command, '', 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, '') + let command = substitute(command, '', 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, ) + command! -count=1 HistoryDiffPrev call s:DiffNextPrev(-1, ) + augroup eclim_history_window + autocmd! BufWinLeave + autocmd BufWinLeave + \ delcommand HistoryDiffNext | + \ delcommand HistoryDiffPrev + augroup END + noremap :call View() + noremap d :call Diff() + noremap r :call Revert() + noremap c :call Clear(1) + + " 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 = [ + \ ' - 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 ? + \ :call eclim#help#BufferHelp(b:history_help, 'vertical', 50) +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, '') + let command = substitute(command, '', file, '') + let command = substitute(command, '', 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 + call eclim#util#GoToBufferWindowRegister(current) + autocmd BufWinLeave 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, '') + let command = substitute(command, '', file, '') + let command = substitute(command, '', 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, '') + let command = substitute(command, '', 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 diff --git a/vim/bundle/eclim/autoload/eclim/common/largefile.vim b/vim/bundle/eclim/autoload/eclim/common/largefile.vim new file mode 100644 index 0000000..cd3cfc6 --- /dev/null +++ b/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 . +" +" }}} + +" Script Settings {{{ +let s:file_size = g:EclimLargeFileSize * 1024 * 1024 +let s:events = ['BufRead', 'CursorHold', 'FileType'] +" }}} + +function! eclim#common#largefile#InitSettings() " {{{ + let file = expand("") + 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 call ApplySettings() + autocmd eclim_largefile BufLeave,BufWinLeave call 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 diff --git a/vim/bundle/eclim/autoload/eclim/common/license.vim b/vim/bundle/eclim/autoload/eclim/common/license.vim new file mode 100644 index 0000000..4fa954d --- /dev/null +++ b/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 . +" +" }}} + +" 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 diff --git a/vim/bundle/eclim/autoload/eclim/common/locate.vim b/vim/bundle/eclim/autoload/eclim/common/locate.vim new file mode 100644 index 0000000..5ca60e8 --- /dev/null +++ b/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 . +" +" }}} + +" 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 ""' +let s:scopes = [ + \ 'project', + \ 'workspace', + \ 'buffers', + \ 'quickfix', + \ ] + +let s:help = [ + \ ' - close the locate prompt + results', + \ ', - select the next file', + \ ', - select the previous file', + \ ' - open selected file w/ default action', + \ ' - open with :edit', + \ ' - open in a split window', + \ ' - open in a new tab', + \ ' - choose search scope', + \ ' - 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), + " '' (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 == '' + 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 nested startinsert! | let &updatetime = 300 + autocmd BufLeave \[Locate*\] + \ call eclim#util#DelayedCommand('call eclim#common#locate#LocateFileClose()') + exec 'autocmd InsertLeave ' . + \ '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 ' + \ 'exec bufwinnr(' . bufnr('%') . ') "winc w"' + augroup END + + " enable completion after user starts typing + call s:LocateFileCompletionAutocmdDeferred() + + imap =LocateFileSelection("n") + imap =LocateFileSelection("n") + imap =LocateFileSelection("n") + imap =LocateFileSelection("p") + imap =LocateFileSelection("p") + imap =LocateFileSelection("p") + exec 'imap ' . + \ '=LocateFileSelect("' . a:action . '")' + imap =LocateFileSelect('edit') + imap =LocateFileSelect('split') + imap =LocateFileSelect("tablast \| tabnew") + imap =LocateFileChangeScope() + imap =LocateFileHelp() + + startinsert! +endfunction " }}} + +function! s:LocateFileCompletionAutocmd() " {{{ + augroup locate_file + autocmd! + autocmd CursorHoldI call eclim#common#locate#LocateFileCompletion() + augroup END +endfunction " }}} + +function! s:LocateFileCompletionAutocmdDeferred() " {{{ + augroup locate_file + autocmd! + autocmd CursorMovedI call 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 call 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("\", '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('$'), + \ ['', '" - select a scope', '" , , or q - cancel']) + syntax match Comment /^".*/ + setlocal nomodifiable + setlocal winfixheight + setlocal nonumber + setlocal nolist + setlocal noswapfile nobuflisted + setlocal buftype=nofile bufhidden=delete + + nnoremap :call ChooseScope() + nnoremap q :call CloseScopeChooser() + nnoremap :call CloseScopeChooser() + nnoremap :call CloseScopeChooser() + + autocmd BufLeave call 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), '', '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), '', '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), '', '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 diff --git a/vim/bundle/eclim/autoload/eclim/common/template.vim b/vim/bundle/eclim/autoload/eclim/common/template.vim new file mode 100644 index 0000000..c569928 --- /dev/null +++ b/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 . +" +" }}} + +" 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 = + \ '' +let s:tagname_regex = '.\{-} 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, + \ '.\{-}.*', + \ '\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 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 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 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, '', result) +endfunction " }}} + +" s:Process_include(line) {{{ +" Process 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 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, '', 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 diff --git a/vim/bundle/eclim/autoload/eclim/common/util.vim b/vim/bundle/eclim/autoload/eclim/common/util.vim new file mode 100644 index 0000000..ce903c4 --- /dev/null +++ b/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 . +" +" }}} + +" Script Variables {{{ +let s:command_read = '-command archive_read -f ""' +" }}} + +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 + autocmd BufUnload :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! \" + + " restore the last search pattern + let @/ = save_search + + silent! call repeat#set(":call eclim#common#util#SwapWords()\", 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) . ")\", 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 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, '', 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 diff --git a/vim/bundle/eclim/autoload/eclim/css/complete.vim b/vim/bundle/eclim/autoload/eclim/css/complete.vim new file mode 100644 index 0000000..15873d1 --- /dev/null +++ b/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 . +" +" }}} + +" Script Varables {{{ + let s:complete_command = + \ '-command css_complete -p "" -f "" -o -e ' +" }}} + +" 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, '') + let command = substitute(command, '', file, '') + let command = substitute(command, '', offset, '') + let command = substitute(command, '', 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 diff --git a/vim/bundle/eclim/autoload/eclim/css/validate.vim b/vim/bundle/eclim/autoload/eclim/css/validate.vim new file mode 100644 index 0000000..81ec611 --- /dev/null +++ b/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 . +" +" }}} + +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 diff --git a/vim/bundle/eclim/autoload/eclim/cygwin.vim b/vim/bundle/eclim/autoload/eclim/cygwin.vim new file mode 100644 index 0000000..b313c7d --- /dev/null +++ b/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 . +" +" }}} + +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 diff --git a/vim/bundle/eclim/autoload/eclim/display/menu.vim b/vim/bundle/eclim/autoload/eclim/display/menu.vim new file mode 100644 index 0000000..add50f8 --- /dev/null +++ b/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 . +" +" }}} + +" 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 = '\. +" +" }}} + +" 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 :call JumpToSign() + + " Store filename so that plugins can use it if necessary. + let b:filename = filename + augroup temp_window + autocmd! BufWinLeave + 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('') == '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 diff --git a/vim/bundle/eclim/autoload/eclim/display/window.vim b/vim/bundle/eclim/autoload/eclim/display/window.vim new file mode 100644 index 0000000..7564ead --- /dev/null +++ b/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 . +" +" }}} + +" 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 ' . + \ 'silent! call remove(g:VerticalToolBuffers, ' . bufnum . ') | ' . + \ 'autocmd! eclim_vertical_tool_windows_buffer * ' + 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('')) + 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 diff --git a/vim/bundle/eclim/autoload/eclim/help.vim b/vim/bundle/eclim/autoload/eclim/help.vim new file mode 100644 index 0000000..5d2dc1b --- /dev/null +++ b/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 . +" +" }}} + +" 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 ? :bd + nnoremap q :bd + + 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 + autocmd BufWinLeave nested autocmd! eclim_help_buffer * + exec 'autocmd BufWinLeave nested ' . + \ 'autocmd! eclim_help_buffer * ' + exec 'autocmd! BufWinLeave ' + exec 'autocmd BufWinLeave 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 diff --git a/vim/bundle/eclim/autoload/eclim/html/complete.vim b/vim/bundle/eclim/autoload/eclim/html/complete.vim new file mode 100644 index 0000000..af31ee6 --- /dev/null +++ b/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 . +" +" }}} + +" Script Varables {{{ + let s:complete_command = + \ '-command html_complete -p "" -f "" -o -e ' +" }}} + +" 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 diff --git a/vim/bundle/eclim/autoload/eclim/html/util.vim b/vim/bundle/eclim/autoload/eclim/html/util.vim new file mode 100644 index 0000000..251ab0c --- /dev/null +++ b/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 . +" +" }}} + +" HtmlToText() {{{ +" Converts the supplied basic html to text. +function! eclim#html#util#HtmlToText(html) + let text = a:html + let text = substitute(text, '
\c', '\n', 'g') + let text = substitute(text, '\c', '', 'g') + let text = substitute(text, '\c', '', 'g') + let text = substitute(text, '
  • \c', '- ', 'g') + let text = substitute(text, '
  • \c', '', 'g') + let text = substitute(text, '\c', '', 'g') + let text = substitute(text, '\c', '', 'g') + let text = substitute(text, '\c', '', 'g') + let text = substitute(text, '\c', '', 'g') + let text = substitute(text, '', '', 'g') + let text = substitute(text, '"\c', '"', 'g') + let text = substitute(text, '&\c', '&', 'g') + let text = substitute(text, '<\c', '<', 'g') + let text = substitute(text, '>\c', '>', 'g') + + return text +endfunction " }}} + +" InCssBlock() {{{ +" Determines if the cusor is inside of