Updated plugins
This commit is contained in:
Amir Salihefendic
parent
2f164fee9b
commit
cc997dc3d0
99 changed files with 1572 additions and 1151 deletions
sources_non_forked
ale
ale_linters
asciidoc
awk
cpp
cs
cuda
dart
elm
erlang
fuse
glsl
go
help
html
java
javascript
kotlin
llvm
markdown
nasm
nroff
php
po
pod
puppet
python
rst
ruby
rust
scala
sh
tex
texinfo
text
thrift
typescript
verilog
vue
xhtml
xml
autoload
ale.vim
ale
doc
ale-development.txtale-kotlin.txtale-markdown.txtale-puppet.txtale-python.txtale-scala.txtale-vue.txtale.txt
plugin
lightline.vim
vim-commentary
vim-fugitive
vim-gitgutter
vim-go
vim-multiple-cursors
vim-snippets
|
|
@ -15,9 +15,9 @@ function! ale_linters#awk#gawk#GetCommand(buffer) abort
|
|||
" note the --source 'BEGIN ...' is to prevent
|
||||
" gawk from attempting to execute the body of the script
|
||||
" it is linting.
|
||||
return ale_linters#awk#gawk#GetExecutable(a:buffer)
|
||||
return ale#Escape(ale_linters#awk#gawk#GetExecutable(a:buffer))
|
||||
\ . " --source 'BEGIN { exit } END { exit 1 }'"
|
||||
\ . ' ' . ale#Var(a:buffer, 'awk_gawk_options')
|
||||
\ . ale#Pad(ale#Var(a:buffer, 'awk_gawk_options'))
|
||||
\ . ' ' . '-f %t --lint /dev/null'
|
||||
endfunction
|
||||
|
||||
|
|
|
|||
|
|
@ -30,5 +30,4 @@ call ale#linter#Define('cpp', {
|
|||
\ 'command_callback': 'ale_linters#cpp#cquery#GetCommand',
|
||||
\ 'project_root_callback': 'ale_linters#cpp#cquery#GetProjectRoot',
|
||||
\ 'initialization_options_callback': 'ale_linters#cpp#cquery#GetInitializationOptions',
|
||||
\ 'language': 'cpp',
|
||||
\})
|
||||
|
|
|
|||
|
|
@ -1,7 +1,11 @@
|
|||
let g:ale_cs_mcs_options = get(g:, 'ale_cs_mcs_options', '')
|
||||
|
||||
function! ale_linters#cs#mcs#GetCommand(buffer) abort
|
||||
return 'mcs -unsafe --parse ' . ale#Var(a:buffer, 'cs_mcs_options') . ' %t'
|
||||
let l:options = ale#Var(a:buffer, 'cs_mcs_options')
|
||||
|
||||
return 'mcs -unsafe --parse'
|
||||
\ . (!empty(l:options) ? ' ' . l:options : '')
|
||||
\ . ' %t'
|
||||
endfunction
|
||||
|
||||
function! ale_linters#cs#mcs#Handle(buffer, lines) abort
|
||||
|
|
|
|||
|
|
@ -29,16 +29,16 @@ function! ale_linters#cs#mcsc#GetCommand(buffer) abort
|
|||
\ : ''
|
||||
|
||||
" register temporary module target file with ale
|
||||
let l:out = tempname()
|
||||
call ale#engine#ManageFile(a:buffer, l:out)
|
||||
" register temporary module target file with ALE.
|
||||
let l:out = ale#engine#CreateFile(a:buffer)
|
||||
|
||||
" The code is compiled as a module and the output is redirected to a
|
||||
" temporary file.
|
||||
return ale#path#CdString(s:GetWorkingDirectory(a:buffer))
|
||||
\ . 'mcs -unsafe'
|
||||
\ . ' ' . ale#Var(a:buffer, 'cs_mcsc_options')
|
||||
\ . ' ' . l:lib_option
|
||||
\ . ' ' . l:r_option
|
||||
\ . ale#Pad(ale#Var(a:buffer, 'cs_mcsc_options'))
|
||||
\ . ale#Pad(l:lib_option)
|
||||
\ . ale#Pad(l:r_option)
|
||||
\ . ' -out:' . l:out
|
||||
\ . ' -t:module'
|
||||
\ . ' -recurse:' . ale#Escape('*.cs')
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ endfunction
|
|||
|
||||
function! ale_linters#cuda#nvcc#GetCommand(buffer) abort
|
||||
" Unused: use ale#util#nul_file
|
||||
" let l:output_file = tempname() . '.ii'
|
||||
" let l:output_file = ale#util#Tempname() . '.ii'
|
||||
" call ale#engine#ManageFile(a:buffer, l:output_file)
|
||||
|
||||
return ale#Escape(ale_linters#cuda#nvcc#GetExecutable(a:buffer))
|
||||
|
|
|
|||
|
|
@ -20,6 +20,5 @@ call ale#linter#Define('dart', {
|
|||
\ 'lsp': 'stdio',
|
||||
\ 'executable_callback': 'ale_linters#dart#language_server#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#dart#language_server#GetExecutable',
|
||||
\ 'language': 'dart',
|
||||
\ 'project_root_callback': 'ale_linters#dart#language_server#GetProjectRoot',
|
||||
\})
|
||||
|
|
|
|||
|
|
@ -128,14 +128,7 @@ function! ale_linters#elm#make#HandleElm018Line(line, output) abort
|
|||
endfunction
|
||||
|
||||
function! ale_linters#elm#make#FileIsBuffer(path) abort
|
||||
let l:is_windows = has('win32')
|
||||
let l:temp_dir = l:is_windows ? $TMP : $TMPDIR
|
||||
|
||||
if has('win32')
|
||||
return a:path[0:len(l:temp_dir) - 1] is? l:temp_dir
|
||||
else
|
||||
return a:path[0:len(l:temp_dir) - 1] is# l:temp_dir
|
||||
endif
|
||||
return ale#path#IsTempName(a:path)
|
||||
endfunction
|
||||
|
||||
function! ale_linters#elm#make#ParseMessage(message) abort
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
let g:ale_erlang_erlc_options = get(g:, 'ale_erlang_erlc_options', '')
|
||||
|
||||
function! ale_linters#erlang#erlc#GetCommand(buffer) abort
|
||||
let l:output_file = tempname()
|
||||
let l:output_file = ale#util#Tempname()
|
||||
call ale#engine#ManageFile(a:buffer, l:output_file)
|
||||
|
||||
return 'erlc -o ' . ale#Escape(l:output_file)
|
||||
|
|
|
|||
|
|
@ -1,11 +1,8 @@
|
|||
" Author: RyanSquared <vandor2012@gmail.com>
|
||||
" Description: `fusion-lint` linter for FusionScript files
|
||||
|
||||
let g:ale_fuse_fusionlint_executable =
|
||||
\ get(g:, 'ale_fuse_fusionlint_executable', 'fusion-lint')
|
||||
|
||||
let g:ale_fuse_fusionlint_options =
|
||||
\ get(g:, 'ale_fuse_fusionlint_options', '')
|
||||
call ale#Set('fuse_fusionlint_executable', 'fusion-lint')
|
||||
call ale#Set('fuse_fusionlint_options', '')
|
||||
|
||||
function! ale_linters#fuse#fusionlint#GetExecutable(buffer) abort
|
||||
return ale#Var(a:buffer, 'fuse_fusionlint_executable')
|
||||
|
|
@ -13,7 +10,7 @@ endfunction
|
|||
|
||||
function! ale_linters#fuse#fusionlint#GetCommand(buffer) abort
|
||||
return ale#Escape(ale_linters#fuse#fusionlint#GetExecutable(a:buffer))
|
||||
\ . ' ' . ale#Var(a:buffer, 'fuse_fusionlint_options')
|
||||
\ . ale#Pad(ale#Var(a:buffer, 'fuse_fusionlint_options'))
|
||||
\ . ' --filename %s -i'
|
||||
endfunction
|
||||
|
||||
|
|
|
|||
|
|
@ -14,9 +14,9 @@ function! ale_linters#glsl#glslang#GetExecutable(buffer) abort
|
|||
endfunction
|
||||
|
||||
function! ale_linters#glsl#glslang#GetCommand(buffer) abort
|
||||
return ale_linters#glsl#glslang#GetExecutable(a:buffer)
|
||||
\ . ' ' . ale#Var(a:buffer, 'glsl_glslang_options')
|
||||
\ . ' ' . '-C %t'
|
||||
return ale#Escape(ale_linters#glsl#glslang#GetExecutable(a:buffer))
|
||||
\ . ale#Pad(ale#Var(a:buffer, 'glsl_glslang_options'))
|
||||
\ . ' -C %t'
|
||||
endfunction
|
||||
|
||||
function! ale_linters#glsl#glslang#Handle(buffer, lines) abort
|
||||
|
|
|
|||
|
|
@ -29,6 +29,5 @@ call ale#linter#Define('glsl', {
|
|||
\ 'lsp': 'stdio',
|
||||
\ 'executable_callback': 'ale_linters#glsl#glslls#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#glsl#glslls#GetCommand',
|
||||
\ 'language': 'glsl',
|
||||
\ 'project_root_callback': 'ale_linters#glsl#glslls#GetProjectRoot',
|
||||
\})
|
||||
|
|
|
|||
|
|
@ -3,10 +3,9 @@
|
|||
|
||||
function! ale_linters#go#gotype#GetCommand(buffer) abort
|
||||
if expand('#' . a:buffer . ':p') =~# '_test\.go$'
|
||||
return
|
||||
return ''
|
||||
endif
|
||||
|
||||
|
||||
return ale#path#BufferCdString(a:buffer) . ' gotype .'
|
||||
endfunction
|
||||
|
||||
|
|
|
|||
|
|
@ -84,10 +84,10 @@ function! ale_linters#java#javac#GetCommand(buffer, import_paths) abort
|
|||
return ale#path#BufferCdString(a:buffer)
|
||||
\ . ale#Escape(l:executable)
|
||||
\ . ' -Xlint'
|
||||
\ . ' ' . l:cp_option
|
||||
\ . ' ' . l:sp_option
|
||||
\ . ale#Pad(l:cp_option)
|
||||
\ . ale#Pad(l:sp_option)
|
||||
\ . ' -d ' . ale#Escape(l:class_file_directory)
|
||||
\ . ' ' . ale#Var(a:buffer, 'java_javac_options')
|
||||
\ . ale#Pad(ale#Var(a:buffer, 'java_javac_options'))
|
||||
\ . ' %t'
|
||||
endfunction
|
||||
|
||||
|
|
|
|||
38
sources_non_forked/ale/ale_linters/javascript/flow_ls.vim
Normal file
38
sources_non_forked/ale/ale_linters/javascript/flow_ls.vim
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
" Author: t_t <jamestthompson3@gmail.com>
|
||||
" Description: Integrate ALE with flow-language-server.
|
||||
|
||||
call ale#Set('javascript_flow_ls_executable', 'flow')
|
||||
call ale#Set('javascript_flow_ls_use_global',
|
||||
\ get(g:, 'ale_use_global_executables', 0)
|
||||
\)
|
||||
|
||||
function! ale_linters#javascript#flow_ls#GetExecutable(buffer) abort
|
||||
return ale#node#FindExecutable(a:buffer, 'javascript_flow_ls', [
|
||||
\ 'node_modules/.bin/flow',
|
||||
\])
|
||||
endfunction
|
||||
|
||||
function! ale_linters#javascript#flow_ls#GetCommand(buffer) abort
|
||||
let l:executable = ale_linters#javascript#flow_ls#GetExecutable(a:buffer)
|
||||
|
||||
return ale#Escape(l:executable) . ' lsp --from ale-lsp'
|
||||
endfunction
|
||||
|
||||
function! ale_linters#javascript#flow_ls#FindProjectRoot(buffer) abort
|
||||
let l:flow_config = ale#path#FindNearestFile(a:buffer, '.flowconfig')
|
||||
|
||||
if !empty(l:flow_config)
|
||||
return fnamemodify(l:flow_config, ':h')
|
||||
endif
|
||||
|
||||
return ''
|
||||
endfunction
|
||||
|
||||
call ale#linter#Define('javascript', {
|
||||
\ 'name': 'flow-language-server',
|
||||
\ 'lsp': 'stdio',
|
||||
\ 'executable_callback': 'ale_linters#javascript#flow_ls#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#javascript#flow_ls#GetCommand',
|
||||
\ 'project_root_callback': 'ale_linters#javascript#flow_ls#FindProjectRoot',
|
||||
\ 'language': 'javascript',
|
||||
\})
|
||||
38
sources_non_forked/ale/ale_linters/kotlin/languageserver.vim
Normal file
38
sources_non_forked/ale/ale_linters/kotlin/languageserver.vim
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
" Author: MTDL9 <https://github.com/MTDL9>
|
||||
" Description: Support for the Kotlin language server https://github.com/fwcd/KotlinLanguageServer
|
||||
|
||||
call ale#Set('kotlin_languageserver_executable', 'kotlin-language-server')
|
||||
|
||||
function! ale_linters#kotlin#languageserver#GetExecutable(buffer) abort
|
||||
return ale#Var(a:buffer, 'kotlin_languageserver_executable')
|
||||
endfunction
|
||||
|
||||
function! ale_linters#kotlin#languageserver#GetCommand(buffer) abort
|
||||
let l:executable = ale_linters#kotlin#languageserver#GetExecutable(a:buffer)
|
||||
return ale#Escape(l:executable)
|
||||
endfunction
|
||||
|
||||
function! ale_linters#kotlin#languageserver#GetProjectRoot(buffer) abort
|
||||
let l:gradle_root = ale#gradle#FindProjectRoot(a:buffer)
|
||||
|
||||
if !empty(l:gradle_root)
|
||||
return l:gradle_root
|
||||
endif
|
||||
|
||||
let l:maven_pom_file = ale#path#FindNearestFile(a:buffer, 'pom.xml')
|
||||
|
||||
if !empty(l:maven_pom_file)
|
||||
return fnamemodify(l:maven_pom_file, ':h')
|
||||
endif
|
||||
|
||||
return ''
|
||||
endfunction
|
||||
|
||||
call ale#linter#Define('kotlin', {
|
||||
\ 'name': 'languageserver',
|
||||
\ 'lsp': 'stdio',
|
||||
\ 'executable_callback': 'ale_linters#kotlin#languageserver#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#kotlin#languageserver#GetCommand',
|
||||
\ 'language': 'kotlin',
|
||||
\ 'project_root_callback': 'ale_linters#kotlin#languageserver#GetProjectRoot',
|
||||
\})
|
||||
|
|
@ -9,8 +9,7 @@ endfunction
|
|||
|
||||
function! ale_linters#llvm#llc#GetCommand(buffer) abort
|
||||
return ale#Escape(ale_linters#llvm#llc#GetExecutable(a:buffer))
|
||||
\ . ' -filetype=null -o='
|
||||
\ . ale#Escape(g:ale#util#nul_file)
|
||||
\ . ' -filetype=null -o=' . g:ale#util#nul_file
|
||||
endfunction
|
||||
|
||||
function! ale_linters#llvm#llc#HandleErrors(buffer, lines) abort
|
||||
|
|
|
|||
|
|
@ -1,5 +1,23 @@
|
|||
" Author rhysd https://rhysd.github.io/, Dirk Roorda (dirkroorda), Adrián González Rus (@adrigzr)
|
||||
" Description: remark-lint for Markdown files
|
||||
call ale#Set('markdown_remark_lint_executable', 'remark')
|
||||
call ale#Set('markdown_remark_lint_use_global', get(g:, 'ale_use_global_executables', 0))
|
||||
call ale#Set('markdown_remark_lint_options', '')
|
||||
|
||||
function! ale_linters#markdown#remark_lint#GetExecutable(buffer) abort
|
||||
return ale#node#FindExecutable(a:buffer, 'markdown_remark_lint', [
|
||||
\ 'node_modules/.bin/remark',
|
||||
\])
|
||||
endfunction
|
||||
|
||||
function! ale_linters#markdown#remark_lint#GetCommand(buffer) abort
|
||||
let l:executable = ale_linters#markdown#remark_lint#GetExecutable(a:buffer)
|
||||
let l:options = ale#Var(a:buffer, 'markdown_remark_lint_options')
|
||||
|
||||
return ale#node#Executable(a:buffer, l:executable)
|
||||
\ . (!empty(l:options) ? ' ' . l:options : '')
|
||||
\ . ' --no-stdout --no-color'
|
||||
endfunction
|
||||
|
||||
function! ale_linters#markdown#remark_lint#Handle(buffer, lines) abort
|
||||
" matches: ' 1:4 warning Incorrect list-item indent: add 1 space list-item-indent remark-lint'
|
||||
|
|
@ -26,9 +44,8 @@ endfunction
|
|||
|
||||
call ale#linter#Define('markdown', {
|
||||
\ 'name': 'remark-lint',
|
||||
\ 'executable': 'remark',
|
||||
\ 'command': 'remark --no-stdout --no-color %s',
|
||||
\ 'executable_callback': 'ale_linters#markdown#remark_lint#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#markdown#remark_lint#GetCommand',
|
||||
\ 'callback': 'ale_linters#markdown#remark_lint#Handle',
|
||||
\ 'lint_file': 1,
|
||||
\ 'output_stream': 'stderr',
|
||||
\})
|
||||
|
|
|
|||
|
|
@ -42,9 +42,9 @@ endfunction
|
|||
|
||||
call ale#linter#Define('nasm', {
|
||||
\ 'name': 'nasm',
|
||||
\ 'executable': 'nasm',
|
||||
\ 'output_stream': 'stderr',
|
||||
\ 'lint_file': 1,
|
||||
\ 'executable_callback': 'ale_linters#nasm#nasm#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#nasm#nasm#GetCommand',
|
||||
\ 'callback': 'ale_linters#nasm#nasm#Handle',
|
||||
\})
|
||||
|
|
|
|||
|
|
@ -25,6 +25,5 @@ call ale#linter#Define('php', {
|
|||
\ 'lsp': 'stdio',
|
||||
\ 'executable_callback': 'ale_linters#php#langserver#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#php#langserver#GetCommand',
|
||||
\ 'language': 'php',
|
||||
\ 'project_root_callback': 'ale_linters#php#langserver#GetProjectRoot',
|
||||
\})
|
||||
|
|
|
|||
45
sources_non_forked/ale/ale_linters/puppet/languageserver.vim
Normal file
45
sources_non_forked/ale/ale_linters/puppet/languageserver.vim
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
" Author: Alexander Olofsson <alexander.olofsson@liu.se>
|
||||
" Description: Puppet Language Server integration for ALE
|
||||
|
||||
call ale#Set('puppet_languageserver_executable', 'puppet-languageserver')
|
||||
|
||||
function! ale_linters#puppet#languageserver#GetExecutable(buffer) abort
|
||||
return ale#Var(a:buffer, 'puppet_languageserver_executable')
|
||||
endfunction
|
||||
|
||||
function! ale_linters#puppet#languageserver#GetCommand(buffer) abort
|
||||
let l:exe = ale#Escape(ale_linters#puppet#languageserver#GetExecutable(a:buffer))
|
||||
|
||||
return l:exe . ' --stdio'
|
||||
endfunction
|
||||
|
||||
function! ale_linters#puppet#languageserver#GetProjectRoot(buffer) abort
|
||||
" Note: The metadata.json file is recommended for Puppet 4+ modules, but
|
||||
" there's no requirement to have it, so fall back to the other possible
|
||||
" Puppet module directories
|
||||
let l:root_path = ale#path#FindNearestFile(a:buffer, 'metadata.json')
|
||||
if !empty(l:root_path)
|
||||
return fnamemodify(l:root_path, ':h')
|
||||
endif
|
||||
|
||||
for l:test_path in [
|
||||
\ 'manifests',
|
||||
\ 'templates',
|
||||
\]
|
||||
let l:root_path = ale#path#FindNearestDirectory(a:buffer, l:test_path)
|
||||
if !empty(l:root_path)
|
||||
return fnamemodify(l:root_path, ':h:h')
|
||||
endif
|
||||
endfor
|
||||
|
||||
return ''
|
||||
endfunction
|
||||
|
||||
call ale#linter#Define('puppet', {
|
||||
\ 'name': 'languageserver',
|
||||
\ 'lsp': 'stdio',
|
||||
\ 'executable_callback': 'ale_linters#puppet#languageserver#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#puppet#languageserver#GetCommand',
|
||||
\ 'language': 'puppet',
|
||||
\ 'project_root_callback': 'ale_linters#puppet#languageserver#GetProjectRoot',
|
||||
\})
|
||||
|
|
@ -23,7 +23,6 @@ call ale#linter#Define('python', {
|
|||
\ 'lsp': 'stdio',
|
||||
\ 'executable_callback': 'ale_linters#python#pyls#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#python#pyls#GetCommand',
|
||||
\ 'language': 'python',
|
||||
\ 'project_root_callback': 'ale#python#FindProjectRoot',
|
||||
\ 'completion_filter': 'ale#completion#python#CompletionItemFilter',
|
||||
\})
|
||||
|
|
|
|||
|
|
@ -23,7 +23,6 @@ call ale#linter#Define('python', {
|
|||
\ 'lsp': 'stdio',
|
||||
\ 'executable_callback': 'ale_linters#python#pyre#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#python#pyre#GetCommand',
|
||||
\ 'language': 'python',
|
||||
\ 'project_root_callback': 'ale#python#FindProjectRoot',
|
||||
\ 'completion_filter': 'ale#completion#python#CompletionItemFilter',
|
||||
\})
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
" Author: Eddie Lebow https://github.com/elebow
|
||||
" Description: rails_best_practices, a code metric tool for rails projects
|
||||
|
||||
let g:ale_ruby_rails_best_practices_options =
|
||||
\ get(g:, 'ale_ruby_rails_best_practices_options', '')
|
||||
call ale#Set('ruby_rails_best_practices_options', '')
|
||||
call ale#Set('ruby_rails_best_practices_executable', 'rails_best_practices')
|
||||
|
||||
function! ale_linters#ruby#rails_best_practices#Handle(buffer, lines) abort
|
||||
let l:output = []
|
||||
|
|
@ -22,8 +22,12 @@ function! ale_linters#ruby#rails_best_practices#Handle(buffer, lines) abort
|
|||
return l:output
|
||||
endfunction
|
||||
|
||||
function! ale_linters#ruby#rails_best_practices#GetExecutable(buffer) abort
|
||||
return ale#Var(a:buffer, 'ruby_rails_best_practices_executable')
|
||||
endfunction
|
||||
|
||||
function! ale_linters#ruby#rails_best_practices#GetCommand(buffer) abort
|
||||
let l:executable = ale#handlers#rails_best_practices#GetExecutable(a:buffer)
|
||||
let l:executable = ale_linters#ruby#rails_best_practices#GetExecutable(a:buffer)
|
||||
let l:exec_args = l:executable =~? 'bundle$'
|
||||
\ ? ' exec rails_best_practices'
|
||||
\ : ''
|
||||
|
|
@ -46,7 +50,7 @@ endfunction
|
|||
|
||||
call ale#linter#Define('ruby', {
|
||||
\ 'name': 'rails_best_practices',
|
||||
\ 'executable_callback': 'ale#handlers#rails_best_practices#GetExecutable',
|
||||
\ 'executable_callback': 'ale_linters#ruby#rails_best_practices#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#ruby#rails_best_practices#GetCommand',
|
||||
\ 'callback': 'ale_linters#ruby#rails_best_practices#Handle',
|
||||
\ 'lint_file': 1,
|
||||
|
|
|
|||
|
|
@ -30,6 +30,5 @@ call ale#linter#Define('rust', {
|
|||
\ 'lsp': 'stdio',
|
||||
\ 'executable_callback': 'ale_linters#rust#rls#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#rust#rls#GetCommand',
|
||||
\ 'language': 'rust',
|
||||
\ 'project_root_callback': 'ale_linters#rust#rls#GetProjectRoot',
|
||||
\})
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
" Author: Kevin Kays - https://github.com/okkays
|
||||
" Description: Support for the scalastyle checker.
|
||||
|
||||
let g:ale_scala_scalastyle_options =
|
||||
\ get(g:, 'ale_scala_scalastyle_options', '')
|
||||
|
||||
let g:ale_scalastyle_config_loc =
|
||||
call ale#Set('scala_scalastyle_options', '')
|
||||
" TODO: Remove support for the old option name in ALE 3.0.
|
||||
call ale#Set('scala_scalastyle_config',
|
||||
\ get(g:, 'ale_scalastyle_config_loc', '')
|
||||
\)
|
||||
|
||||
function! ale_linters#scala#scalastyle#Handle(buffer, lines) abort
|
||||
" Look for help output from scalastyle first, which indicates that no
|
||||
|
|
@ -66,23 +66,13 @@ function! ale_linters#scala#scalastyle#GetCommand(buffer) abort
|
|||
|
||||
" If all else fails, try the global config.
|
||||
if empty(l:scalastyle_config)
|
||||
let l:scalastyle_config = get(g:, 'ale_scalastyle_config_loc', '')
|
||||
let l:scalastyle_config = ale#Var(a:buffer, 'scala_scalastyle_config')
|
||||
endif
|
||||
|
||||
" Build the command using the config file and additional options.
|
||||
let l:command = 'scalastyle'
|
||||
|
||||
if !empty(l:scalastyle_config)
|
||||
let l:command .= ' --config ' . ale#Escape(l:scalastyle_config)
|
||||
endif
|
||||
|
||||
if !empty(g:ale_scala_scalastyle_options)
|
||||
let l:command .= ' ' . g:ale_scala_scalastyle_options
|
||||
endif
|
||||
|
||||
let l:command .= ' %t'
|
||||
|
||||
return l:command
|
||||
return 'scalastyle'
|
||||
\ . (!empty(l:scalastyle_config) ? ' --config ' . ale#Escape(l:scalastyle_config) : '')
|
||||
\ . ale#Pad(ale#Var(a:buffer, 'scala_scalastyle_options'))
|
||||
\ . ' %t'
|
||||
endfunction
|
||||
|
||||
call ale#linter#Define('scala', {
|
||||
|
|
|
|||
|
|
@ -28,6 +28,5 @@ call ale#linter#Define('sh', {
|
|||
\ 'lsp': 'stdio',
|
||||
\ 'executable_callback': 'ale_linters#sh#language_server#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#sh#language_server#GetCommand',
|
||||
\ 'language': 'sh',
|
||||
\ 'project_root_callback': 'ale_linters#sh#language_server#GetProjectRoot',
|
||||
\})
|
||||
|
|
|
|||
|
|
@ -20,14 +20,12 @@ function! ale_linters#thrift#thrift#GetCommand(buffer) abort
|
|||
let l:generators = ['cpp']
|
||||
endif
|
||||
|
||||
let l:output_dir = tempname()
|
||||
call mkdir(l:output_dir)
|
||||
call ale#engine#ManageDirectory(a:buffer, l:output_dir)
|
||||
let l:output_dir = ale#engine#CreateDirectory(a:buffer)
|
||||
|
||||
return ale#Escape(ale_linters#thrift#thrift#GetExecutable(a:buffer))
|
||||
\ . ' ' . join(map(copy(l:generators), "'--gen ' . v:val"))
|
||||
\ . ' ' . join(map(copy(l:includes), "'-I ' . v:val"))
|
||||
\ . ' ' . ale#Var(a:buffer, 'thrift_thrift_options')
|
||||
\ . ale#Pad(join(map(copy(l:generators), "'--gen ' . v:val")))
|
||||
\ . ale#Pad(join(map(copy(l:includes), "'-I ' . v:val")))
|
||||
\ . ale#Pad(ale#Var(a:buffer, 'thrift_thrift_options'))
|
||||
\ . ' -out ' . ale#Escape(l:output_dir)
|
||||
\ . ' %t'
|
||||
endfunction
|
||||
|
|
|
|||
|
|
@ -1,17 +1,7 @@
|
|||
" Author: Prashanth Chandra <https://github.com/prashcr>, Jonathan Clem <https://jclem.net>
|
||||
" Description: tslint for TypeScript files
|
||||
|
||||
call ale#Set('typescript_tslint_executable', 'tslint')
|
||||
call ale#Set('typescript_tslint_config_path', '')
|
||||
call ale#Set('typescript_tslint_rules_dir', '')
|
||||
call ale#Set('typescript_tslint_use_global', get(g:, 'ale_use_global_executables', 0))
|
||||
call ale#Set('typescript_tslint_ignore_empty_files', 0)
|
||||
|
||||
function! ale_linters#typescript#tslint#GetExecutable(buffer) abort
|
||||
return ale#node#FindExecutable(a:buffer, 'typescript_tslint', [
|
||||
\ 'node_modules/.bin/tslint',
|
||||
\])
|
||||
endfunction
|
||||
call ale#handlers#tslint#InitVariables()
|
||||
|
||||
function! ale_linters#typescript#tslint#Handle(buffer, lines) abort
|
||||
" Do not output any errors for empty files if the option is on.
|
||||
|
|
@ -70,7 +60,7 @@ function! ale_linters#typescript#tslint#GetCommand(buffer) abort
|
|||
\ : ''
|
||||
|
||||
return ale#path#BufferCdString(a:buffer)
|
||||
\ . ale#Escape(ale_linters#typescript#tslint#GetExecutable(a:buffer))
|
||||
\ . ale#Escape(ale#handlers#tslint#GetExecutable(a:buffer))
|
||||
\ . ' --format json'
|
||||
\ . l:tslint_config_option
|
||||
\ . l:tslint_rules_option
|
||||
|
|
@ -79,7 +69,7 @@ endfunction
|
|||
|
||||
call ale#linter#Define('typescript', {
|
||||
\ 'name': 'tslint',
|
||||
\ 'executable_callback': 'ale_linters#typescript#tslint#GetExecutable',
|
||||
\ 'executable_callback': 'ale#handlers#tslint#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#typescript#tslint#GetCommand',
|
||||
\ 'callback': 'ale_linters#typescript#tslint#Handle',
|
||||
\})
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ if !exists('g:ale_verilog_verilator_options')
|
|||
endif
|
||||
|
||||
function! ale_linters#verilog#verilator#GetCommand(buffer) abort
|
||||
let l:filename = tempname() . '_verilator_linted.v'
|
||||
let l:filename = ale#util#Tempname() . '_verilator_linted.v'
|
||||
|
||||
" Create a special filename, so we can detect it in the handler.
|
||||
call ale#engine#ManageFile(a:buffer, l:filename)
|
||||
|
|
|
|||
32
sources_non_forked/ale/ale_linters/vue/vls.vim
Normal file
32
sources_non_forked/ale/ale_linters/vue/vls.vim
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
" Author: Alexander Olofsson <alexander.olofsson@liu.se>
|
||||
" Description: Vue vls Language Server integration for ALE
|
||||
|
||||
call ale#Set('vue_vls_executable', 'vls')
|
||||
call ale#Set('vue_vls_use_global', get(g:, 'ale_use_global_executables', 0))
|
||||
|
||||
function! ale_linters#vue#vls#GetExecutable(buffer) abort
|
||||
return ale#node#FindExecutable(a:buffer, 'vue_vls', [
|
||||
\ 'node_modules/.bin/vls',
|
||||
\])
|
||||
endfunction
|
||||
|
||||
function! ale_linters#vue#vls#GetCommand(buffer) abort
|
||||
let l:exe = ale#Escape(ale_linters#vue#vls#GetExecutable(a:buffer))
|
||||
|
||||
return l:exe . ' --stdio'
|
||||
endfunction
|
||||
|
||||
function! ale_linters#vue#vls#GetProjectRoot(buffer) abort
|
||||
let l:package_path = ale#path#FindNearestFile(a:buffer, 'package.json')
|
||||
|
||||
return !empty(l:package_path) ? fnamemodify(l:package_path, ':h') : ''
|
||||
endfunction
|
||||
|
||||
call ale#linter#Define('vue', {
|
||||
\ 'name': 'vls',
|
||||
\ 'lsp': 'stdio',
|
||||
\ 'executable_callback': 'ale_linters#vue#vls#GetExecutable',
|
||||
\ 'command_callback': 'ale_linters#vue#vls#GetCommand',
|
||||
\ 'language': 'vue',
|
||||
\ 'project_root_callback': 'ale_linters#vue#vls#GetProjectRoot',
|
||||
\})
|
||||
|
|
@ -11,7 +11,7 @@ endfunction
|
|||
|
||||
function! ale_linters#xml#xmllint#GetCommand(buffer) abort
|
||||
return ale#Escape(ale_linters#xml#xmllint#GetExecutable(a:buffer))
|
||||
\ . ' ' . ale#Var(a:buffer, 'xml_xmllint_options')
|
||||
\ . ale#Pad(ale#Var(a:buffer, 'xml_xmllint_options'))
|
||||
\ . ' --noout -'
|
||||
endfunction
|
||||
|
||||
|
|
|
|||
|
|
@ -191,15 +191,12 @@ endfunction
|
|||
"
|
||||
" Every variable name will be prefixed with 'ale_'.
|
||||
function! ale#Var(buffer, variable_name) abort
|
||||
let l:nr = str2nr(a:buffer)
|
||||
let l:full_name = 'ale_' . a:variable_name
|
||||
let l:vars = getbufvar(str2nr(a:buffer), '', 0)
|
||||
|
||||
if bufexists(l:nr)
|
||||
let l:vars = getbufvar(l:nr, '')
|
||||
elseif has_key(g:, 'ale_fix_buffer_data')
|
||||
let l:vars = get(g:ale_fix_buffer_data, l:nr, {'vars': {}}).vars
|
||||
else
|
||||
let l:vars = {}
|
||||
if l:vars is 0
|
||||
" Look for variables from deleted buffers, saved from :ALEFix
|
||||
let l:vars = get(get(g:ale_fix_buffer_data, a:buffer, {}), 'vars', {})
|
||||
endif
|
||||
|
||||
return get(l:vars, l:full_name, g:[l:full_name])
|
||||
|
|
@ -210,10 +207,29 @@ endfunction
|
|||
" Every variable name will be prefixed with 'ale_'.
|
||||
function! ale#Set(variable_name, default) abort
|
||||
let l:full_name = 'ale_' . a:variable_name
|
||||
let l:value = get(g:, l:full_name, a:default)
|
||||
let g:[l:full_name] = l:value
|
||||
|
||||
return l:value
|
||||
if !has_key(g:, l:full_name)
|
||||
let g:[l:full_name] = a:default
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" Given a string for adding to a command, return the string padded with a
|
||||
" space on the left if it is not empty. Otherwise return an empty string.
|
||||
"
|
||||
" This can be used for making command strings cleaner and easier to test.
|
||||
function! ale#Pad(string) abort
|
||||
return !empty(a:string) ? ' ' . a:string : ''
|
||||
endfunction
|
||||
|
||||
" Given a environment variable name and a value, produce part of a command for
|
||||
" setting an environment variable before running a command. The syntax will be
|
||||
" valid for cmd on Windows, or most shells on Unix.
|
||||
function! ale#Env(variable_name, value) abort
|
||||
if has('win32')
|
||||
return 'set ' . a:variable_name . '=' . ale#Escape(a:value) . ' && '
|
||||
endif
|
||||
|
||||
return a:variable_name . '=' . ale#Escape(a:value) . ' '
|
||||
endfunction
|
||||
|
||||
" Escape a string suitably for each platform.
|
||||
|
|
|
|||
159
sources_non_forked/ale/autoload/ale/assert.vim
Normal file
159
sources_non_forked/ale/autoload/ale/assert.vim
Normal file
|
|
@ -0,0 +1,159 @@
|
|||
let s:chain_results = []
|
||||
|
||||
function! ale#assert#WithChainResults(...) abort
|
||||
let s:chain_results = a:000
|
||||
endfunction
|
||||
|
||||
function! s:GetLinter() abort
|
||||
let l:linters = ale#linter#GetLintersLoaded()
|
||||
let l:filetype_linters = get(values(l:linters), 0, [])
|
||||
|
||||
if len(l:linters) is 0 || len(l:filetype_linters) is 0
|
||||
throw 'No linters were loaded'
|
||||
endif
|
||||
|
||||
if len(l:linters) > 1 || len(l:filetype_linters) > 1
|
||||
throw 'More than one linter was loaded'
|
||||
endif
|
||||
|
||||
return l:filetype_linters[0]
|
||||
endfunction
|
||||
|
||||
" Load the currently loaded linter for a test case, and check that the command
|
||||
" matches the given string.
|
||||
function! ale#assert#Linter(expected_executable, expected_command) abort
|
||||
let l:buffer = bufnr('')
|
||||
let l:linter = s:GetLinter()
|
||||
let l:executable = ale#linter#GetExecutable(l:buffer, l:linter)
|
||||
|
||||
if has_key(l:linter, 'command_chain')
|
||||
let l:callbacks = map(copy(l:linter.command_chain), 'v:val.callback')
|
||||
|
||||
" If the expected command is a string, just check the last one.
|
||||
if type(a:expected_command) is type('')
|
||||
if len(l:callbacks) is 1
|
||||
let l:command = call(l:callbacks[0], [l:buffer])
|
||||
else
|
||||
let l:input = get(s:chain_results, len(l:callbacks) - 2, [])
|
||||
let l:command = call(l:callbacks[-1], [l:buffer, l:input])
|
||||
endif
|
||||
else
|
||||
let l:command = []
|
||||
let l:chain_index = 0
|
||||
|
||||
for l:Callback in l:callbacks
|
||||
if l:chain_index is 0
|
||||
call add(l:command, call(l:Callback, [l:buffer]))
|
||||
else
|
||||
let l:input = get(s:chain_results, l:chain_index - 1, [])
|
||||
call add(l:command, call(l:Callback, [l:buffer, l:input]))
|
||||
endif
|
||||
|
||||
let l:chain_index += 1
|
||||
endfor
|
||||
endif
|
||||
else
|
||||
let l:command = ale#linter#GetCommand(l:buffer, l:linter)
|
||||
" Replace %e with the escaped executable, so tests keep passing after
|
||||
" linters are changed to use %e.
|
||||
let l:command = substitute(l:command, '%e', '\=ale#Escape(l:executable)', 'g')
|
||||
endif
|
||||
|
||||
AssertEqual
|
||||
\ [a:expected_executable, a:expected_command],
|
||||
\ [l:executable, l:command]
|
||||
endfunction
|
||||
|
||||
function! ale#assert#LinterNotExecuted() abort
|
||||
let l:buffer = bufnr('')
|
||||
let l:linter = s:GetLinter()
|
||||
let l:executable = ale#linter#GetExecutable(l:buffer, l:linter)
|
||||
|
||||
Assert empty(l:executable), "The linter will be executed when it shouldn't be"
|
||||
endfunction
|
||||
|
||||
function! ale#assert#LSPOptions(expected_options) abort
|
||||
let l:buffer = bufnr('')
|
||||
let l:linter = s:GetLinter()
|
||||
let l:initialization_options = ale#lsp_linter#GetOptions(l:buffer, l:linter)
|
||||
|
||||
AssertEqual a:expected_options, l:initialization_options
|
||||
endfunction
|
||||
|
||||
function! ale#assert#LSPLanguage(expected_language) abort
|
||||
let l:buffer = bufnr('')
|
||||
let l:linter = s:GetLinter()
|
||||
let l:language = ale#util#GetFunction(l:linter.language_callback)(l:buffer)
|
||||
|
||||
AssertEqual a:expected_language, l:language
|
||||
endfunction
|
||||
|
||||
function! ale#assert#LSPProject(expected_root) abort
|
||||
let l:buffer = bufnr('')
|
||||
let l:linter = s:GetLinter()
|
||||
let l:root = ale#util#GetFunction(l:linter.project_root_callback)(l:buffer)
|
||||
|
||||
AssertEqual a:expected_root, l:root
|
||||
endfunction
|
||||
|
||||
" A dummy function for making sure this module is loaded.
|
||||
function! ale#assert#SetUpLinterTest(filetype, name) abort
|
||||
" Set up a marker so ALE doesn't create real random temporary filenames.
|
||||
let g:ale_create_dummy_temporary_file = 1
|
||||
|
||||
" Remove current linters.
|
||||
call ale#linter#Reset()
|
||||
call ale#linter#PreventLoading(a:filetype)
|
||||
|
||||
let l:prefix = 'ale_' . a:filetype . '_' . a:name
|
||||
let b:filter_expr = 'v:val[: len(l:prefix) - 1] is# l:prefix'
|
||||
|
||||
Save g:ale_c_build_dir
|
||||
unlet! g:ale_c_build_dir
|
||||
|
||||
" Save and clear linter variables.
|
||||
" We'll load the runtime file to reset them to defaults.
|
||||
for l:key in filter(keys(g:), b:filter_expr)
|
||||
execute 'Save g:' . l:key
|
||||
unlet g:[l:key]
|
||||
endfor
|
||||
|
||||
unlet! b:ale_c_build_dir
|
||||
|
||||
for l:key in filter(keys(b:), b:filter_expr)
|
||||
unlet b:[l:key]
|
||||
endfor
|
||||
|
||||
execute 'runtime ale_linters/' . a:filetype . '/' . a:name . '.vim'
|
||||
|
||||
call ale#test#SetDirectory('/testplugin/test/command_callback')
|
||||
|
||||
command! -nargs=+ WithChainResults :call ale#assert#WithChainResults(<args>)
|
||||
command! -nargs=+ AssertLinter :call ale#assert#Linter(<args>)
|
||||
command! -nargs=0 AssertLinterNotExecuted :call ale#assert#LinterNotExecuted()
|
||||
command! -nargs=+ AssertLSPOptions :call ale#assert#LSPOptions(<args>)
|
||||
command! -nargs=+ AssertLSPLanguage :call ale#assert#LSPLanguage(<args>)
|
||||
command! -nargs=+ AssertLSPProject :call ale#assert#LSPProject(<args>)
|
||||
endfunction
|
||||
|
||||
function! ale#assert#TearDownLinterTest() abort
|
||||
unlet! g:ale_create_dummy_temporary_file
|
||||
let s:chain_results = []
|
||||
|
||||
delcommand WithChainResults
|
||||
delcommand AssertLinter
|
||||
delcommand AssertLinterNotExecuted
|
||||
delcommand AssertLSPOptions
|
||||
delcommand AssertLSPLanguage
|
||||
delcommand AssertLSPProject
|
||||
|
||||
call ale#test#RestoreDirectory()
|
||||
|
||||
Restore
|
||||
|
||||
call ale#linter#Reset()
|
||||
|
||||
if exists('*ale#semver#ResetVersionCache')
|
||||
call ale#semver#ResetVersionCache()
|
||||
endif
|
||||
endfunction
|
||||
|
|
@ -13,14 +13,14 @@ function! s:TemporaryFilename(buffer) abort
|
|||
|
||||
" Create a temporary filename, <temp_dir>/<original_basename>
|
||||
" The file itself will not be created by this function.
|
||||
return tempname() . (has('win32') ? '\' : '/') . l:filename
|
||||
return ale#util#Tempname() . (has('win32') ? '\' : '/') . l:filename
|
||||
endfunction
|
||||
|
||||
" Given a command string, replace every...
|
||||
" %s -> with the current filename
|
||||
" %t -> with the name of an unused file in a temporary directory
|
||||
" %% -> with a literal %
|
||||
function! ale#command#FormatCommand(buffer, command, pipe_file_if_needed) abort
|
||||
function! ale#command#FormatCommand(buffer, executable, command, pipe_file_if_needed) abort
|
||||
let l:temporary_file = ''
|
||||
let l:command = a:command
|
||||
|
||||
|
|
@ -28,6 +28,11 @@ function! ale#command#FormatCommand(buffer, command, pipe_file_if_needed) abort
|
|||
" with an ugly string.
|
||||
let l:command = substitute(l:command, '%%', '<<PERCENTS>>', 'g')
|
||||
|
||||
" Replace %e with the escaped executable, if available.
|
||||
if !empty(a:executable) && l:command =~# '%e'
|
||||
let l:command = substitute(l:command, '%e', '\=ale#Escape(a:executable)', 'g')
|
||||
endif
|
||||
|
||||
" Replace all %s occurrences in the string with the name of the current
|
||||
" file.
|
||||
if l:command =~# '%s'
|
||||
|
|
|
|||
|
|
@ -1,6 +1,17 @@
|
|||
" Author: w0rp <devw0rp@gmail.com>
|
||||
" Description: Completion support for LSP linters
|
||||
|
||||
" The omnicompletion menu is shown through a special Plug mapping which is
|
||||
" only valid in Insert mode. This way, feedkeys() won't send these keys if you
|
||||
" quit Insert mode quickly enough.
|
||||
inoremap <silent> <Plug>(ale_show_completion_menu) <C-x><C-o>
|
||||
" If we hit the key sequence in normal mode, then we won't show the menu, so
|
||||
" we should restore the old settings right away.
|
||||
nnoremap <silent> <Plug>(ale_show_completion_menu) :call ale#completion#RestoreCompletionOptions()<CR>
|
||||
cnoremap <silent> <Plug>(ale_show_completion_menu) <Nop>
|
||||
vnoremap <silent> <Plug>(ale_show_completion_menu) <Nop>
|
||||
onoremap <silent> <Plug>(ale_show_completion_menu) <Nop>
|
||||
|
||||
let g:ale_completion_delay = get(g:, 'ale_completion_delay', 100)
|
||||
let g:ale_completion_excluded_words = get(g:, 'ale_completion_excluded_words', [])
|
||||
let g:ale_completion_max_suggestions = get(g:, 'ale_completion_max_suggestions', 50)
|
||||
|
|
@ -129,7 +140,16 @@ function! ale#completion#Filter(buffer, suggestions, prefix) abort
|
|||
return l:filtered_suggestions
|
||||
endfunction
|
||||
|
||||
function! s:ReplaceCompleteopt() abort
|
||||
function! s:ReplaceCompletionOptions() abort
|
||||
" Remember the old omnifunc value, if there is one.
|
||||
" If we don't store an old one, we'll just never reset the option.
|
||||
" This will stop some random exceptions from appearing.
|
||||
if !exists('b:ale_old_omnifunc') && !empty(&l:omnifunc)
|
||||
let b:ale_old_omnifunc = &l:omnifunc
|
||||
endif
|
||||
|
||||
let &l:omnifunc = 'ale#completion#OmniFunc'
|
||||
|
||||
if !exists('b:ale_old_completopt')
|
||||
let b:ale_old_completopt = &l:completeopt
|
||||
endif
|
||||
|
|
@ -141,6 +161,22 @@ function! s:ReplaceCompleteopt() abort
|
|||
endif
|
||||
endfunction
|
||||
|
||||
function! ale#completion#RestoreCompletionOptions() abort
|
||||
" Reset settings when completion is done.
|
||||
if exists('b:ale_old_omnifunc')
|
||||
if b:ale_old_omnifunc isnot# 'pythoncomplete#Complete'
|
||||
let &l:omnifunc = b:ale_old_omnifunc
|
||||
endif
|
||||
|
||||
unlet b:ale_old_omnifunc
|
||||
endif
|
||||
|
||||
if exists('b:ale_old_completopt')
|
||||
let &l:completeopt = b:ale_old_completopt
|
||||
unlet b:ale_old_completopt
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! ale#completion#OmniFunc(findstart, base) abort
|
||||
if a:findstart
|
||||
let l:line = b:ale_completion_info.line
|
||||
|
|
@ -163,33 +199,30 @@ function! ale#completion#OmniFunc(findstart, base) abort
|
|||
let b:ale_completion_result = function(l:parser)(l:response)
|
||||
endif
|
||||
|
||||
call s:ReplaceCompleteopt()
|
||||
call s:ReplaceCompletionOptions()
|
||||
|
||||
return get(b:, 'ale_completion_result', [])
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! ale#completion#Show(response, completion_parser) abort
|
||||
" Remember the old omnifunc value, if there is one.
|
||||
" If we don't store an old one, we'll just never reset the option.
|
||||
" This will stop some random exceptions from appearing.
|
||||
if !exists('b:ale_old_omnifunc') && !empty(&l:omnifunc)
|
||||
let b:ale_old_omnifunc = &l:omnifunc
|
||||
if ale#util#Mode() isnot# 'i'
|
||||
return
|
||||
endif
|
||||
|
||||
" Set the list in the buffer, temporarily replace omnifunc with our
|
||||
" function, and then start omni-completion.
|
||||
let b:ale_completion_response = a:response
|
||||
let b:ale_completion_parser = a:completion_parser
|
||||
let &l:omnifunc = 'ale#completion#OmniFunc'
|
||||
call s:ReplaceCompleteopt()
|
||||
call ale#util#FeedKeys("\<C-x>\<C-o>", 'n')
|
||||
call s:ReplaceCompletionOptions()
|
||||
call ale#util#FeedKeys("\<Plug>(ale_show_completion_menu)")
|
||||
endfunction
|
||||
|
||||
function! s:CompletionStillValid(request_id) abort
|
||||
let [l:line, l:column] = getcurpos()[1:2]
|
||||
|
||||
return has_key(b:, 'ale_completion_info')
|
||||
return ale#util#Mode() is# 'i'
|
||||
\&& has_key(b:, 'ale_completion_info')
|
||||
\&& b:ale_completion_info.request_id == a:request_id
|
||||
\&& b:ale_completion_info.line == l:line
|
||||
\&& b:ale_completion_info.column == l:column
|
||||
|
|
@ -477,7 +510,7 @@ function! s:TimerHandler(...) abort
|
|||
|
||||
" When running the timer callback, we have to be sure that the cursor
|
||||
" hasn't moved from where it was when we requested completions by typing.
|
||||
if s:timer_pos == [l:line, l:column]
|
||||
if s:timer_pos == [l:line, l:column] && ale#util#Mode() is# 'i'
|
||||
call ale#completion#GetCompletions()
|
||||
endif
|
||||
endfunction
|
||||
|
|
@ -518,19 +551,7 @@ endfunction
|
|||
function! ale#completion#Done() abort
|
||||
silent! pclose
|
||||
|
||||
" Reset settings when completion is done.
|
||||
if exists('b:ale_old_omnifunc')
|
||||
if b:ale_old_omnifunc isnot# 'pythoncomplete#Complete'
|
||||
let &l:omnifunc = b:ale_old_omnifunc
|
||||
endif
|
||||
|
||||
unlet b:ale_old_omnifunc
|
||||
endif
|
||||
|
||||
if exists('b:ale_old_completopt')
|
||||
let &l:completeopt = b:ale_old_completopt
|
||||
unlet b:ale_old_completopt
|
||||
endif
|
||||
call ale#completion#RestoreCompletionOptions()
|
||||
|
||||
let s:last_done_pos = getcurpos()[1:2]
|
||||
endfunction
|
||||
|
|
|
|||
|
|
@ -96,9 +96,26 @@ function! ale#engine#ManageDirectory(buffer, directory) abort
|
|||
call add(g:ale_buffer_info[a:buffer].temporary_directory_list, a:directory)
|
||||
endfunction
|
||||
|
||||
function! ale#engine#CreateFile(buffer) abort
|
||||
" This variable can be set to 1 in tests to stub this out.
|
||||
if get(g:, 'ale_create_dummy_temporary_file')
|
||||
return 'TEMP'
|
||||
endif
|
||||
|
||||
let l:temporary_file = ale#util#Tempname()
|
||||
call ale#engine#ManageFile(a:buffer, l:temporary_file)
|
||||
|
||||
return l:temporary_file
|
||||
endfunction
|
||||
|
||||
" Create a new temporary directory and manage it in one go.
|
||||
function! ale#engine#CreateDirectory(buffer) abort
|
||||
let l:temporary_directory = tempname()
|
||||
" This variable can be set to 1 in tests to stub this out.
|
||||
if get(g:, 'ale_create_dummy_temporary_file')
|
||||
return 'TEMP_DIR'
|
||||
endif
|
||||
|
||||
let l:temporary_directory = ale#util#Tempname()
|
||||
" Create the temporary directory for the file, unreadable by 'other'
|
||||
" users.
|
||||
call mkdir(l:temporary_directory, '', 0750)
|
||||
|
|
@ -189,6 +206,7 @@ function! s:HandleExit(job_id, exit_code) abort
|
|||
let l:linter = l:job_info.linter
|
||||
let l:output = l:job_info.output
|
||||
let l:buffer = l:job_info.buffer
|
||||
let l:executable = l:job_info.executable
|
||||
let l:next_chain_index = l:job_info.next_chain_index
|
||||
|
||||
if g:ale_history_enabled
|
||||
|
|
@ -212,7 +230,7 @@ function! s:HandleExit(job_id, exit_code) abort
|
|||
endif
|
||||
|
||||
if l:next_chain_index < len(get(l:linter, 'command_chain', []))
|
||||
call s:InvokeChain(l:buffer, l:linter, l:next_chain_index, l:output)
|
||||
call s:InvokeChain(l:buffer, l:executable, l:linter, l:next_chain_index, l:output)
|
||||
return
|
||||
endif
|
||||
|
||||
|
|
@ -221,7 +239,12 @@ function! s:HandleExit(job_id, exit_code) abort
|
|||
call ale#history#RememberOutput(l:buffer, a:job_id, l:output[:])
|
||||
endif
|
||||
|
||||
let l:loclist = ale#util#GetFunction(l:linter.callback)(l:buffer, l:output)
|
||||
try
|
||||
let l:loclist = ale#util#GetFunction(l:linter.callback)(l:buffer, l:output)
|
||||
" Handle the function being unknown, or being deleted.
|
||||
catch /E700/
|
||||
let l:loclist = []
|
||||
endtry
|
||||
|
||||
call ale#engine#HandleLoclist(l:linter.name, l:buffer, l:loclist)
|
||||
endfunction
|
||||
|
|
@ -440,6 +463,12 @@ endfunction
|
|||
" Returns 1 when the job was started successfully.
|
||||
function! s:RunJob(options) abort
|
||||
let l:command = a:options.command
|
||||
|
||||
if empty(l:command)
|
||||
return 0
|
||||
endif
|
||||
|
||||
let l:executable = a:options.executable
|
||||
let l:buffer = a:options.buffer
|
||||
let l:linter = a:options.linter
|
||||
let l:output_stream = a:options.output_stream
|
||||
|
|
@ -447,11 +476,12 @@ function! s:RunJob(options) abort
|
|||
let l:read_buffer = a:options.read_buffer
|
||||
let l:info = g:ale_buffer_info[l:buffer]
|
||||
|
||||
if empty(l:command)
|
||||
return 0
|
||||
endif
|
||||
|
||||
let [l:temporary_file, l:command] = ale#command#FormatCommand(l:buffer, l:command, l:read_buffer)
|
||||
let [l:temporary_file, l:command] = ale#command#FormatCommand(
|
||||
\ l:buffer,
|
||||
\ l:executable,
|
||||
\ l:command,
|
||||
\ l:read_buffer,
|
||||
\)
|
||||
|
||||
if s:CreateTemporaryFileForJob(l:buffer, l:temporary_file)
|
||||
" If a temporary filename has been formatted in to the command, then
|
||||
|
|
@ -512,6 +542,7 @@ function! s:RunJob(options) abort
|
|||
let s:job_info_map[l:job_id] = {
|
||||
\ 'linter': l:linter,
|
||||
\ 'buffer': l:buffer,
|
||||
\ 'executable': l:executable,
|
||||
\ 'output': [],
|
||||
\ 'next_chain_index': l:next_chain_index,
|
||||
\}
|
||||
|
|
@ -604,8 +635,9 @@ function! ale#engine#ProcessChain(buffer, linter, chain_index, input) abort
|
|||
\}
|
||||
endfunction
|
||||
|
||||
function! s:InvokeChain(buffer, linter, chain_index, input) abort
|
||||
function! s:InvokeChain(buffer, executable, linter, chain_index, input) abort
|
||||
let l:options = ale#engine#ProcessChain(a:buffer, a:linter, a:chain_index, a:input)
|
||||
let l:options.executable = a:executable
|
||||
|
||||
return s:RunJob(l:options)
|
||||
endfunction
|
||||
|
|
@ -699,7 +731,7 @@ function! s:RunLinter(buffer, linter) abort
|
|||
let l:executable = ale#linter#GetExecutable(a:buffer, a:linter)
|
||||
|
||||
if ale#engine#IsExecutable(a:buffer, l:executable)
|
||||
return s:InvokeChain(a:buffer, a:linter, 0, [])
|
||||
return s:InvokeChain(a:buffer, l:executable, a:linter, 0, [])
|
||||
endif
|
||||
endif
|
||||
|
||||
|
|
|
|||
|
|
@ -39,35 +39,48 @@ function! ale#events#SaveEvent(buffer) abort
|
|||
endif
|
||||
endfunction
|
||||
|
||||
function! s:LintOnEnter(buffer) abort
|
||||
if ale#Var(a:buffer, 'enabled')
|
||||
\&& g:ale_lint_on_enter
|
||||
\&& has_key(b:, 'ale_file_changed')
|
||||
call remove(b:, 'ale_file_changed')
|
||||
function! ale#events#LintOnEnter(buffer) abort
|
||||
" Unmark a file as being changed outside of Vim after we try to check it.
|
||||
call setbufvar(a:buffer, 'ale_file_changed', 0)
|
||||
|
||||
if ale#Var(a:buffer, 'enabled') && g:ale_lint_on_enter
|
||||
call ale#Queue(0, 'lint_file', a:buffer)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! ale#events#EnterEvent(buffer) abort
|
||||
function! ale#events#ReadOrEnterEvent(buffer) abort
|
||||
" Apply pattern options if the variable is set.
|
||||
if get(g:, 'ale_pattern_options_enabled', 1)
|
||||
\&& !empty(get(g:, 'ale_pattern_options'))
|
||||
call ale#pattern_options#SetOptions(a:buffer)
|
||||
endif
|
||||
|
||||
" When entering a buffer, we are no longer quitting it.
|
||||
call setbufvar(a:buffer, 'ale_quitting', 0)
|
||||
let l:filetype = getbufvar(a:buffer, '&filetype')
|
||||
call setbufvar(a:buffer, 'ale_original_filetype', l:filetype)
|
||||
|
||||
call s:LintOnEnter(a:buffer)
|
||||
" If the file changed outside of Vim, check it on BufEnter,BufRead
|
||||
if getbufvar(a:buffer, 'ale_file_changed')
|
||||
call ale#events#LintOnEnter(a:buffer)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! ale#events#FileTypeEvent(buffer, new_filetype) abort
|
||||
let l:filetype = getbufvar(a:buffer, 'ale_original_filetype', '')
|
||||
" The old filetype will be set to an empty string by the BuFEnter event,
|
||||
" and not linting when the old filetype hasn't been set yet prevents
|
||||
" buffers being checked when you enter them when linting on enter is off.
|
||||
let l:old_filetype = getbufvar(a:buffer, 'ale_original_filetype', v:null)
|
||||
|
||||
" If we're setting the filetype for the first time after it was blank,
|
||||
" and the option for linting on enter is off, then we should set this
|
||||
" filetype as the original filetype. Otherwise ALE will still appear to
|
||||
" lint files because of the BufEnter event, etc.
|
||||
if empty(l:filetype) && !ale#Var(a:buffer, 'lint_on_enter')
|
||||
if l:old_filetype isnot v:null
|
||||
\&& !empty(a:new_filetype)
|
||||
\&& a:new_filetype isnot# l:old_filetype
|
||||
" Remember what the new filetype is.
|
||||
call setbufvar(a:buffer, 'ale_original_filetype', a:new_filetype)
|
||||
elseif a:new_filetype isnot# l:filetype
|
||||
call ale#Queue(300, 'lint_file', a:buffer)
|
||||
|
||||
if g:ale_lint_on_filetype_changed
|
||||
call ale#Queue(300, 'lint_file', a:buffer)
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
||||
|
|
@ -75,7 +88,7 @@ function! ale#events#FileChangedEvent(buffer) abort
|
|||
call setbufvar(a:buffer, 'ale_file_changed', 1)
|
||||
|
||||
if bufnr('') == a:buffer
|
||||
call s:LintOnEnter(a:buffer)
|
||||
call ale#events#LintOnEnter(a:buffer)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
|
|
@ -87,7 +100,7 @@ function! ale#events#Init() abort
|
|||
autocmd!
|
||||
|
||||
" These events always need to be set up.
|
||||
autocmd BufEnter,BufRead * call ale#pattern_options#SetOptions(str2nr(expand('<abuf>')))
|
||||
autocmd BufEnter,BufRead * call ale#events#ReadOrEnterEvent(str2nr(expand('<abuf>')))
|
||||
autocmd BufWritePost * call ale#events#SaveEvent(str2nr(expand('<abuf>')))
|
||||
|
||||
if g:ale_enabled
|
||||
|
|
@ -99,11 +112,8 @@ function! ale#events#Init() abort
|
|||
autocmd TextChangedI * call ale#Queue(g:ale_lint_delay)
|
||||
endif
|
||||
|
||||
" Handle everything that needs to happen when buffers are entered.
|
||||
autocmd BufEnter * call ale#events#EnterEvent(str2nr(expand('<abuf>')))
|
||||
|
||||
if g:ale_lint_on_enter
|
||||
autocmd BufWinEnter,BufRead * call ale#Queue(0, 'lint_file', str2nr(expand('<abuf>')))
|
||||
autocmd BufWinEnter * call ale#events#LintOnEnter(str2nr(expand('<abuf>')))
|
||||
" Track when the file is changed outside of Vim.
|
||||
autocmd FileChangedShellPost * call ale#events#FileChangedEvent(str2nr(expand('<abuf>')))
|
||||
endif
|
||||
|
|
|
|||
|
|
@ -1,10 +1,3 @@
|
|||
" This global Dictionary tracks the ALE fix data for jobs, etc.
|
||||
" This Dictionary should not be accessed outside of the plugin. It is only
|
||||
" global so it can be modified in Vader tests.
|
||||
if !has_key(g:, 'ale_fix_buffer_data')
|
||||
let g:ale_fix_buffer_data = {}
|
||||
endif
|
||||
|
||||
if !has_key(s:, 'job_info_map')
|
||||
let s:job_info_map = {}
|
||||
endif
|
||||
|
|
@ -219,6 +212,7 @@ function! s:RunJob(options) abort
|
|||
|
||||
let [l:temporary_file, l:command] = ale#command#FormatCommand(
|
||||
\ l:buffer,
|
||||
\ '',
|
||||
\ l:command,
|
||||
\ l:read_buffer,
|
||||
\)
|
||||
|
|
|
|||
|
|
@ -242,6 +242,9 @@ endfunction
|
|||
" Add a function for fixing problems to the registry.
|
||||
" (name, func, filetypes, desc, aliases)
|
||||
function! ale#fix#registry#Add(name, func, filetypes, desc, ...) abort
|
||||
" This command will throw from the sandbox.
|
||||
let &equalprg=&equalprg
|
||||
|
||||
if type(a:name) != type('')
|
||||
throw '''name'' must be a String'
|
||||
endif
|
||||
|
|
|
|||
|
|
@ -2,9 +2,12 @@
|
|||
" Description: Fixing Python imports with isort.
|
||||
|
||||
call ale#Set('python_isort_executable', 'isort')
|
||||
call ale#Set('python_isort_options', '')
|
||||
call ale#Set('python_isort_use_global', get(g:, 'ale_use_global_executables', 0))
|
||||
|
||||
function! ale#fixers#isort#Fix(buffer) abort
|
||||
let l:options = ale#Var(a:buffer, 'python_isort_options')
|
||||
|
||||
let l:executable = ale#python#FindExecutable(
|
||||
\ a:buffer,
|
||||
\ 'python_isort',
|
||||
|
|
@ -17,6 +20,6 @@ function! ale#fixers#isort#Fix(buffer) abort
|
|||
|
||||
return {
|
||||
\ 'command': ale#path#BufferCdString(a:buffer)
|
||||
\ . ale#Escape(l:executable) . ' -',
|
||||
\ . ale#Escape(l:executable) . (!empty(l:options) ? ' ' . l:options : '') . ' -',
|
||||
\}
|
||||
endfunction
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
" Description: Fixing files with tslint.
|
||||
|
||||
function! ale#fixers#tslint#Fix(buffer) abort
|
||||
let l:executable = ale_linters#typescript#tslint#GetExecutable(a:buffer)
|
||||
let l:executable = ale#handlers#tslint#GetExecutable(a:buffer)
|
||||
|
||||
let l:tslint_config_path = ale#path#ResolveLocalPath(
|
||||
\ a:buffer,
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
" Description: Error handling for the format GHC outputs.
|
||||
|
||||
" Remember the directory used for temporary files for Vim.
|
||||
let s:temp_dir = fnamemodify(tempname(), ':h')
|
||||
let s:temp_dir = fnamemodify(ale#util#Tempname(), ':h')
|
||||
" Build part of a regular expression for matching ALE temporary filenames.
|
||||
let s:temp_regex_prefix =
|
||||
\ '\M'
|
||||
|
|
|
|||
|
|
@ -1,6 +0,0 @@
|
|||
call ale#Set('ruby_rails_best_practices_options', '')
|
||||
call ale#Set('ruby_rails_best_practices_executable', 'rails_best_practices')
|
||||
|
||||
function! ale#handlers#rails_best_practices#GetExecutable(buffer) abort
|
||||
return ale#Var(a:buffer, 'ruby_rails_best_practices_executable')
|
||||
endfunction
|
||||
13
sources_non_forked/ale/autoload/ale/handlers/tslint.vim
Normal file
13
sources_non_forked/ale/autoload/ale/handlers/tslint.vim
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
function! ale#handlers#tslint#InitVariables() abort
|
||||
call ale#Set('typescript_tslint_executable', 'tslint')
|
||||
call ale#Set('typescript_tslint_config_path', '')
|
||||
call ale#Set('typescript_tslint_rules_dir', '')
|
||||
call ale#Set('typescript_tslint_use_global', get(g:, 'ale_use_global_executables', 0))
|
||||
call ale#Set('typescript_tslint_ignore_empty_files', 0)
|
||||
endfunction
|
||||
|
||||
function! ale#handlers#tslint#GetExecutable(buffer) abort
|
||||
return ale#node#FindExecutable(a:buffer, 'typescript_tslint', [
|
||||
\ 'node_modules/.bin/tslint',
|
||||
\])
|
||||
endfunction
|
||||
|
|
@ -1,4 +1,3 @@
|
|||
call ale#Set('wrap_command_as_one_argument', 0)
|
||||
" Author: w0rp <devw0rp@gmail.com>
|
||||
" Description: Linter registration and lazy-loading
|
||||
" Retrieves linters as requested by the engine, loading them if needed.
|
||||
|
|
@ -47,6 +46,16 @@ function! ale#linter#Reset() abort
|
|||
let s:linters = {}
|
||||
endfunction
|
||||
|
||||
" Return a reference to the linters loaded.
|
||||
" This is only for tests.
|
||||
" Do not call this function.
|
||||
function! ale#linter#GetLintersLoaded() abort
|
||||
" This command will throw from the sandbox.
|
||||
let &equalprg=&equalprg
|
||||
|
||||
return s:linters
|
||||
endfunction
|
||||
|
||||
function! s:IsCallback(value) abort
|
||||
return type(a:value) == type('') || type(a:value) == type(function('type'))
|
||||
endfunction
|
||||
|
|
@ -59,7 +68,7 @@ function! s:LanguageGetter(buffer) dict abort
|
|||
return l:self.language
|
||||
endfunction
|
||||
|
||||
function! ale#linter#PreProcess(linter) abort
|
||||
function! ale#linter#PreProcess(filetype, linter) abort
|
||||
if type(a:linter) != type({})
|
||||
throw 'The linter object must be a Dictionary'
|
||||
endif
|
||||
|
|
@ -193,13 +202,20 @@ function! ale#linter#PreProcess(linter) abort
|
|||
endif
|
||||
|
||||
if l:needs_lsp_details
|
||||
if has_key(a:linter, 'language')
|
||||
if has_key(a:linter, 'language_callback')
|
||||
if has_key(a:linter, 'language_callback')
|
||||
if has_key(a:linter, 'language')
|
||||
throw 'Only one of `language` or `language_callback` '
|
||||
\ . 'should be set'
|
||||
endif
|
||||
|
||||
let l:obj.language = get(a:linter, 'language')
|
||||
let l:obj.language_callback = get(a:linter, 'language_callback')
|
||||
|
||||
if !s:IsCallback(l:obj.language_callback)
|
||||
throw '`language_callback` must be a callback for LSP linters'
|
||||
endif
|
||||
else
|
||||
" Default to using the filetype as the language.
|
||||
let l:obj.language = get(a:linter, 'language', a:filetype)
|
||||
|
||||
if type(l:obj.language) != type('')
|
||||
throw '`language` must be a string'
|
||||
|
|
@ -207,12 +223,6 @@ function! ale#linter#PreProcess(linter) abort
|
|||
|
||||
" Make 'language_callback' return the 'language' value.
|
||||
let l:obj.language_callback = function('s:LanguageGetter')
|
||||
else
|
||||
let l:obj.language_callback = get(a:linter, 'language_callback')
|
||||
|
||||
if !s:IsCallback(l:obj.language_callback)
|
||||
throw '`language_callback` must be a callback for LSP linters'
|
||||
endif
|
||||
endif
|
||||
|
||||
let l:obj.project_root_callback = get(a:linter, 'project_root_callback')
|
||||
|
|
@ -282,11 +292,14 @@ function! ale#linter#PreProcess(linter) abort
|
|||
endfunction
|
||||
|
||||
function! ale#linter#Define(filetype, linter) abort
|
||||
" This command will throw from the sandbox.
|
||||
let &equalprg=&equalprg
|
||||
|
||||
if !has_key(s:linters, a:filetype)
|
||||
let s:linters[a:filetype] = []
|
||||
endif
|
||||
|
||||
let l:new_linter = ale#linter#PreProcess(a:linter)
|
||||
let l:new_linter = ale#linter#PreProcess(a:filetype, a:linter)
|
||||
|
||||
call add(s:linters[a:filetype], l:new_linter)
|
||||
endfunction
|
||||
|
|
@ -297,6 +310,12 @@ function! ale#linter#PreventLoading(filetype) abort
|
|||
endfunction
|
||||
|
||||
function! ale#linter#GetAll(filetypes) abort
|
||||
" Don't return linters in the sandbox.
|
||||
" Otherwise a sandboxed script could modify them.
|
||||
if ale#util#InSandbox()
|
||||
return []
|
||||
endif
|
||||
|
||||
let l:combined_linters = []
|
||||
|
||||
for l:filetype in a:filetypes
|
||||
|
|
|
|||
|
|
@ -105,11 +105,17 @@ function! ale#lsp#response#GetErrorMessage(response) abort
|
|||
return ''
|
||||
endif
|
||||
|
||||
" Include the traceback as details, if it's there.
|
||||
let l:traceback = get(get(a:response.error, 'data', {}), 'traceback', [])
|
||||
" Include the traceback or error data as details, if present.
|
||||
let l:error_data = get(a:response.error, 'data', {})
|
||||
|
||||
if type(l:traceback) is type([]) && !empty(l:traceback)
|
||||
let l:message .= "\n" . join(l:traceback, "\n")
|
||||
if type(l:error_data) is type('')
|
||||
let l:message .= "\n" . l:error_data
|
||||
else
|
||||
let l:traceback = get(l:error_data, 'traceback', [])
|
||||
|
||||
if type(l:traceback) is type([]) && !empty(l:traceback)
|
||||
let l:message .= "\n" . join(l:traceback, "\n")
|
||||
endif
|
||||
endif
|
||||
|
||||
return l:message
|
||||
|
|
|
|||
|
|
@ -114,6 +114,18 @@ function! ale#lsp_linter#HandleLSPResponse(conn_id, response) abort
|
|||
endif
|
||||
endfunction
|
||||
|
||||
function! ale#lsp_linter#GetOptions(buffer, linter) abort
|
||||
let l:initialization_options = {}
|
||||
|
||||
if has_key(a:linter, 'initialization_options_callback')
|
||||
let l:initialization_options = ale#util#GetFunction(a:linter.initialization_options_callback)(a:buffer)
|
||||
elseif has_key(a:linter, 'initialization_options')
|
||||
let l:initialization_options = a:linter.initialization_options
|
||||
endif
|
||||
|
||||
return l:initialization_options
|
||||
endfunction
|
||||
|
||||
" Given a buffer, an LSP linter, and a callback to register for handling
|
||||
" messages, start up an LSP linter and get ready to receive errors or
|
||||
" completions.
|
||||
|
|
@ -128,13 +140,7 @@ function! ale#lsp_linter#StartLSP(buffer, linter, callback) abort
|
|||
return {}
|
||||
endif
|
||||
|
||||
let l:initialization_options = {}
|
||||
|
||||
if has_key(a:linter, 'initialization_options_callback')
|
||||
let l:initialization_options = ale#util#GetFunction(a:linter.initialization_options_callback)(a:buffer)
|
||||
elseif has_key(a:linter, 'initialization_options')
|
||||
let l:initialization_options = a:linter.initialization_options
|
||||
endif
|
||||
let l:initialization_options = ale#lsp_linter#GetOptions(a:buffer, a:linter)
|
||||
|
||||
if a:linter.lsp is# 'socket'
|
||||
let l:address = ale#linter#GetAddress(a:buffer, a:linter)
|
||||
|
|
@ -147,14 +153,14 @@ function! ale#lsp_linter#StartLSP(buffer, linter, callback) abort
|
|||
else
|
||||
let l:executable = ale#linter#GetExecutable(a:buffer, a:linter)
|
||||
|
||||
if !executable(l:executable)
|
||||
if empty(l:executable) || !executable(l:executable)
|
||||
return {}
|
||||
endif
|
||||
|
||||
let l:command = ale#job#PrepareCommand(
|
||||
\ a:buffer,
|
||||
\ ale#linter#GetCommand(a:buffer, a:linter),
|
||||
\)
|
||||
let l:command = ale#linter#GetCommand(a:buffer, a:linter)
|
||||
" Format the command, so %e can be formatted into it.
|
||||
let l:command = ale#command#FormatCommand(a:buffer, l:executable, l:command, 0)[1]
|
||||
let l:command = ale#job#PrepareCommand(a:buffer, l:command)
|
||||
let l:conn_id = ale#lsp#StartProgram(
|
||||
\ l:executable,
|
||||
\ l:command,
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ function! ale#path#IsAbsolute(filename) abort
|
|||
return a:filename[:0] is# '/' || a:filename[1:2] is# ':\'
|
||||
endfunction
|
||||
|
||||
let s:temp_dir = ale#path#Simplify(fnamemodify(tempname(), ':h'))
|
||||
let s:temp_dir = ale#path#Simplify(fnamemodify(ale#util#Tempname(), ':h'))
|
||||
|
||||
" Given a filename, return 1 if the file represents some temporary file
|
||||
" created by Vim.
|
||||
|
|
|
|||
|
|
@ -1,11 +1,6 @@
|
|||
" Author: w0rp <devw0rp@gmail.com>
|
||||
" Description: Set options in files based on regex patterns.
|
||||
|
||||
" A dictionary mapping regular expression patterns to arbitrary buffer
|
||||
" variables to be set. Useful for configuring ALE based on filename patterns.
|
||||
let g:ale_pattern_options = get(g:, 'ale_pattern_options', {})
|
||||
let g:ale_pattern_options_enabled = get(g:, 'ale_pattern_options_enabled', !empty(g:ale_pattern_options))
|
||||
|
||||
" These variables are used to cache the sorting of patterns below.
|
||||
let s:last_pattern_options = {}
|
||||
let s:sorted_items = []
|
||||
|
|
@ -23,17 +18,19 @@ function! s:CmpPatterns(left_item, right_item) abort
|
|||
endfunction
|
||||
|
||||
function! ale#pattern_options#SetOptions(buffer) abort
|
||||
if !get(g:, 'ale_pattern_options_enabled', 0)
|
||||
\|| empty(get(g:, 'ale_pattern_options', 0))
|
||||
let l:pattern_options = get(g:, 'ale_pattern_options', {})
|
||||
|
||||
if empty(l:pattern_options)
|
||||
" Stop if no options are set.
|
||||
return
|
||||
endif
|
||||
|
||||
" The items will only be sorted whenever the patterns change.
|
||||
if g:ale_pattern_options != s:last_pattern_options
|
||||
let s:last_pattern_options = deepcopy(g:ale_pattern_options)
|
||||
if l:pattern_options != s:last_pattern_options
|
||||
let s:last_pattern_options = deepcopy(l:pattern_options)
|
||||
" The patterns are sorted, so they are applied consistently.
|
||||
let s:sorted_items = sort(
|
||||
\ items(g:ale_pattern_options),
|
||||
\ items(l:pattern_options),
|
||||
\ function('s:CmpPatterns')
|
||||
\)
|
||||
endif
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@ let s:sep = has('win32') ? '\' : '/'
|
|||
let s:bin_dir = has('unix') ? 'bin' : 'Scripts'
|
||||
let g:ale_virtualenv_dir_names = get(g:, 'ale_virtualenv_dir_names', [
|
||||
\ '.env',
|
||||
\ '.venv',
|
||||
\ 'env',
|
||||
\ 've-py3',
|
||||
\ 've',
|
||||
|
|
@ -23,6 +24,8 @@ function! ale#python#FindProjectRootIni(buffer) abort
|
|||
\|| filereadable(l:path . '/mypy.ini')
|
||||
\|| filereadable(l:path . '/pycodestyle.cfg')
|
||||
\|| filereadable(l:path . '/flake8.cfg')
|
||||
\|| filereadable(l:path . '/Pipfile')
|
||||
\|| filereadable(l:path . '/Pipfile.lock')
|
||||
return l:path
|
||||
endif
|
||||
endfor
|
||||
|
|
|
|||
|
|
@ -45,25 +45,23 @@ if !hlexists('ALESignColumnWithErrors')
|
|||
highlight link ALESignColumnWithErrors error
|
||||
endif
|
||||
|
||||
function! ale#sign#SetUpDefaultColumnWithoutErrorsHighlight() abort
|
||||
redir => l:output
|
||||
0verbose silent highlight SignColumn
|
||||
redir end
|
||||
|
||||
let l:highlight_syntax = join(split(l:output)[2:])
|
||||
let l:match = matchlist(l:highlight_syntax, '\vlinks to (.+)$')
|
||||
|
||||
if !empty(l:match)
|
||||
execute 'highlight link ALESignColumnWithoutErrors ' . l:match[1]
|
||||
elseif l:highlight_syntax isnot# 'cleared'
|
||||
execute 'highlight ALESignColumnWithoutErrors ' . l:highlight_syntax
|
||||
endif
|
||||
endfunction
|
||||
|
||||
if !hlexists('ALESignColumnWithoutErrors')
|
||||
function! s:SetSignColumnWithoutErrorsHighlight() abort
|
||||
redir => l:output
|
||||
silent highlight SignColumn
|
||||
redir end
|
||||
|
||||
let l:highlight_syntax = join(split(l:output)[2:])
|
||||
|
||||
let l:match = matchlist(l:highlight_syntax, '\vlinks to (.+)$')
|
||||
|
||||
if !empty(l:match)
|
||||
execute 'highlight link ALESignColumnWithoutErrors ' . l:match[1]
|
||||
elseif l:highlight_syntax isnot# 'cleared'
|
||||
execute 'highlight ALESignColumnWithoutErrors ' . l:highlight_syntax
|
||||
endif
|
||||
endfunction
|
||||
|
||||
call s:SetSignColumnWithoutErrorsHighlight()
|
||||
delfunction s:SetSignColumnWithoutErrorsHighlight
|
||||
call ale#sign#SetUpDefaultColumnWithoutErrorsHighlight()
|
||||
endif
|
||||
|
||||
" Signs show up on the left for error markers.
|
||||
|
|
|
|||
|
|
@ -268,9 +268,8 @@ endfunction
|
|||
" See :help sandbox
|
||||
function! ale#util#InSandbox() abort
|
||||
try
|
||||
function! s:SandboxCheck() abort
|
||||
endfunction
|
||||
catch /^Vim\%((\a\+)\)\=:E48/
|
||||
let &equalprg=&equalprg
|
||||
catch /E48/
|
||||
" E48 is the sandbox error.
|
||||
return 1
|
||||
endtry
|
||||
|
|
@ -278,6 +277,25 @@ function! ale#util#InSandbox() abort
|
|||
return 0
|
||||
endfunction
|
||||
|
||||
function! ale#util#Tempname() abort
|
||||
let l:clear_tempdir = 0
|
||||
|
||||
if exists('$TMPDIR') && empty($TMPDIR)
|
||||
let l:clear_tempdir = 1
|
||||
let $TMPDIR = '/tmp'
|
||||
endif
|
||||
|
||||
try
|
||||
let l:name = tempname() " no-custom-checks
|
||||
finally
|
||||
if l:clear_tempdir
|
||||
let $TMPDIR = ''
|
||||
endif
|
||||
endtry
|
||||
|
||||
return l:name
|
||||
endfunction
|
||||
|
||||
" Given a single line, or a List of lines, and a single pattern, or a List
|
||||
" of patterns, return all of the matches for the lines(s) from the given
|
||||
" patterns, using matchlist().
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ CONTENTS *ale-development-contents*
|
|||
2. Design Goals.........................|ale-design-goals|
|
||||
3. Coding Standards.....................|ale-coding-standards|
|
||||
4. Testing ALE..........................|ale-development-tests|
|
||||
4.1. Writing Linter Tests.............|ale-development-linter-tests|
|
||||
|
||||
===============================================================================
|
||||
1. Introduction *ale-development-introduction*
|
||||
|
|
@ -111,6 +112,9 @@ these are reported with ALE's `custom-linting-rules` script. See
|
|||
* Don't use the `shellescape()` function. It doesn't escape arguments properly
|
||||
on Windows. Use `ale#Escape()` instead, which will avoid escaping where it
|
||||
isn't needed, and generally escape arguments better on Windows.
|
||||
* Don't use the `tempname()` function. It doesn't work when `$TMPDIR` isn't
|
||||
set. Use `ale#util#Tempname()` instead, which temporarily sets `$TMPDIR`
|
||||
appropriately where needed.
|
||||
|
||||
Apply the following guidelines when writing Vader test files.
|
||||
|
||||
|
|
@ -170,6 +174,9 @@ Look at existing tests in the codebase for examples of how to write tests.
|
|||
Refer to the Vader documentation for general information on how to write Vader
|
||||
tests: https://github.com/junegunn/vader.vim
|
||||
|
||||
See |ale-development-linter-tests| for more information on how to write linter
|
||||
tests.
|
||||
|
||||
When you add new linters or fixers, make sure to add them into the table in
|
||||
the README, and also into the |ale-support| list in the main help file. If you
|
||||
forget to keep them both in sync, you should see an error like the following
|
||||
|
|
@ -219,5 +226,82 @@ margin. For example, if you add a heading for an `aardvark` tool to
|
|||
Make sure to make the table of contents match the headings, and to keep the
|
||||
doc tags on the right margin.
|
||||
|
||||
===============================================================================
|
||||
4.1 Writing Linter Tests *ale-development-linter-tests*
|
||||
|
||||
Tests for ALE linters take two forms.
|
||||
|
||||
1. Tests for handling the output of commands.
|
||||
2. Tests for checking which commands are run, or connections are made.
|
||||
|
||||
Tests of the first form should go in the `test/handler` directory, and should
|
||||
be written like so. >
|
||||
|
||||
Before:
|
||||
" Load the file which defines the linter.
|
||||
runtime ale_linters/filetype/linter_name_here.vim
|
||||
|
||||
After:
|
||||
" Unload all linters again.
|
||||
call ale#linter#Reset()
|
||||
|
||||
Execute(The output should be correct):
|
||||
|
||||
" Test that the right loclist items are parsed from the handler.
|
||||
AssertEqual
|
||||
\ [
|
||||
\ {
|
||||
\ 'lnum': 1,
|
||||
\ 'type': 'E',
|
||||
\ 'text': 'Something went wrong',
|
||||
\ },
|
||||
\ ],
|
||||
\ ale_linters#filetype#linter_name#Handle(bufnr(''), [
|
||||
\ '1:Something went wrong',
|
||||
\ ]
|
||||
<
|
||||
Tests for what ALE runs should go in the `test/command_callback` directory,
|
||||
and should be written like so. >
|
||||
|
||||
Before:
|
||||
" Load the linter and set up a series of commands, reset linter variables,
|
||||
" clear caches, etc.
|
||||
"
|
||||
" Vader's 'Save' command will be called here for linter variables.
|
||||
call ale#assert#SetUpLinterTest('filetype', 'linter_name')
|
||||
|
||||
After:
|
||||
" Reset linters, variables, etc.
|
||||
"
|
||||
" Vader's 'Restore' command will be called here.
|
||||
call ale#assert#TearDownLinterTest()
|
||||
|
||||
Execute(The default command should be correct):
|
||||
" AssertLinter checks the executable and command.
|
||||
" Pass expected_executable, expected_command
|
||||
AssertLinter 'some-command', ale#Escape('some-command') . ' --foo'
|
||||
|
||||
Execute(Check chained commands):
|
||||
" WithChainResults can be called with 1 or more list for passing output
|
||||
" to chained commands. The output for each callback defaults to an empty
|
||||
" list.
|
||||
WithChainResults ['v2.1.2']
|
||||
" Given a List of commands, check all of them.
|
||||
" Given a String, only the last command in the chain will be checked.
|
||||
AssertLinter 'some-command', [
|
||||
\ ale#Escape('some-command') . ' --version',
|
||||
\ ale#Escape('some-command') . ' --foo',
|
||||
\]
|
||||
<
|
||||
The full list of commands that will be temporarily defined for linter tests
|
||||
given the above setup are as follows.
|
||||
|
||||
`WithChainResults [...]` - Define output for command chain functions.
|
||||
`AssertLinter executable, command` - Check the executable and command.
|
||||
`AssertLinterNotExecuted` - Check that linters will not be executed.
|
||||
`AssertLSPLanguage language` - Check the language given to an LSP server.
|
||||
`AssertLSPOptions options_dict` - Check the options given to an LSP server.
|
||||
`AssertLSPProject project_root` - Check the root given to an LSP server.
|
||||
|
||||
===============================================================================
|
||||
vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:
|
||||
|
|
|
|||
|
|
@ -87,4 +87,19 @@ g:ale_kotlin_ktlint_rulesets *g:ale_kotlin_ktlint_rulesets*
|
|||
let g:ale_kotlin_ktlint_rulesets = ['/path/to/custom-rulset.jar',
|
||||
'com.ktlint.rulesets:mycustomrule:1.0.0']
|
||||
|
||||
|
||||
===============================================================================
|
||||
languageserver *ale-kotlin-languageserver*
|
||||
|
||||
g:ale_kotlin_languageserver_executable *g:ale_kotlin_languageserver_executable*
|
||||
Type: |String|
|
||||
Default: `''`
|
||||
|
||||
The kotlin-language-server executable.
|
||||
|
||||
Executables are located inside the bin/ folder of the language server
|
||||
release.
|
||||
|
||||
|
||||
===============================================================================
|
||||
vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:
|
||||
|
|
|
|||
|
|
@ -28,6 +28,33 @@ prettier *ale-markdown-prettier*
|
|||
See |ale-javascript-prettier| for information about the available options.
|
||||
|
||||
|
||||
===============================================================================
|
||||
remark-lint *ale-markdown-remark-lint*
|
||||
|
||||
g:ale_markdown_remark_lint_executable *g:ale_markdown_remark_lint_executable*
|
||||
*b:ale_markdown_remark_lint_executable*
|
||||
Type: |String|
|
||||
Default: `'remark'`
|
||||
|
||||
See |ale-integrations-local-executables|
|
||||
|
||||
|
||||
g:ale_markdown_remark_lint_options *g:ale_markdown_remark_lint_options*
|
||||
*b:ale_markdown_remark_lint_options*
|
||||
Type: |String|
|
||||
Default: `''`
|
||||
|
||||
This variable can be set to pass additional options to remark-lint.
|
||||
|
||||
|
||||
g:ale_markdown_remark_lint_use_global *g:ale_markdown_remark_lint_use_global*
|
||||
*b:ale_markdown_remark_lint_use_global*
|
||||
Type: |Number|
|
||||
Default: `get(g:, 'ale_use_global_executables', 0)`
|
||||
|
||||
See |ale-integrations-local-executables|
|
||||
|
||||
|
||||
===============================================================================
|
||||
textlint *ale-markdown-textlint*
|
||||
|
||||
|
|
|
|||
|
|
@ -22,5 +22,16 @@ g:ale_puppet_puppetlint_options *g:ale_puppet_puppetlint_options*
|
|||
puppet-lint invocation.
|
||||
|
||||
|
||||
===============================================================================
|
||||
puppet-languageserver *ale-puppet-languageserver*
|
||||
|
||||
g:ale_puppet_languageserver_executable *g:ale_puppet_languageserver_executable*
|
||||
*b:ale_puppet_languageserver_executable*
|
||||
type: |String|
|
||||
Default: `'puppet-languageserver'`
|
||||
|
||||
This variable can be used to specify the executable used for
|
||||
puppet-languageserver.
|
||||
|
||||
===============================================================================
|
||||
vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:
|
||||
|
|
|
|||
|
|
@ -22,6 +22,8 @@ ALE will look for configuration files with the following filenames. >
|
|||
mypy.ini
|
||||
pycodestyle.cfg
|
||||
flake8.cfg
|
||||
Pipfile
|
||||
Pipfile.lock
|
||||
<
|
||||
|
||||
The first directory containing any of the files named above will be used.
|
||||
|
|
@ -145,6 +147,14 @@ g:ale_python_isort_executable *g:ale_python_isort_executable*
|
|||
See |ale-integrations-local-executables|
|
||||
|
||||
|
||||
g:ale_python_isort_options *g:ale_python_isort_options*
|
||||
*b:ale_python_isort_options*
|
||||
Type: |String|
|
||||
Default: `''`
|
||||
|
||||
This variable can be set to pass extra options to isort.
|
||||
|
||||
|
||||
g:ale_python_isort_use_global *g:ale_python_isort_use_global*
|
||||
*b:ale_python_isort_use_global*
|
||||
Type: |Number|
|
||||
|
|
|
|||
|
|
@ -41,8 +41,8 @@ To disable `scalastyle` globally, use |g:ale_linters| like so: >
|
|||
See |g:ale_linters| for more information on disabling linters.
|
||||
|
||||
|
||||
g:ale_scalastyle_config_loc *g:ale_scalastyle_config_loc*
|
||||
|
||||
g:ale_scala_scalastyle_config *g:ale_scala_scalastyle_config*
|
||||
*b:ale_scala_scalastyle_config*
|
||||
Type: |String|
|
||||
Default: `''`
|
||||
|
||||
|
|
@ -54,7 +54,7 @@ g:ale_scalastyle_config_loc *g:ale_scalastyle_config_loc*
|
|||
|
||||
|
||||
g:ale_scala_scalastyle_options *g:ale_scala_scalastyle_options*
|
||||
|
||||
*b:ale_scala_scalastyle_options*
|
||||
Type: |String|
|
||||
Default: `''`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,5 +7,25 @@ prettier *ale-vue-prettier*
|
|||
|
||||
See |ale-javascript-prettier| for information about the available options.
|
||||
|
||||
|
||||
===============================================================================
|
||||
vls *ale-vue-vls*
|
||||
|
||||
g:ale_vue_vls_executable *g:ale_vue_vls_executable*
|
||||
*b:ale_vue_vls_executable*
|
||||
Type: |String|
|
||||
Default: `'vls'`
|
||||
|
||||
See |ale-integrations-local-executables|
|
||||
|
||||
|
||||
g:ale_vue_vls_use_global *g:ale_vue_vls_use_global*
|
||||
*b:ale_vue_vls_use_global*
|
||||
Type: |Number|
|
||||
Default: `get(g:, 'ale_use_global_executables', 0)`
|
||||
|
||||
See |ale-integrations-local-executables|
|
||||
|
||||
|
||||
===============================================================================
|
||||
vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:
|
||||
|
|
|
|||
|
|
@ -131,6 +131,7 @@ CONTENTS *ale-contents*
|
|||
kotlin................................|ale-kotlin-options|
|
||||
kotlinc.............................|ale-kotlin-kotlinc|
|
||||
ktlint..............................|ale-kotlin-ktlint|
|
||||
languageserver......................|ale-kotlin-languageserver|
|
||||
latex.................................|ale-latex-options|
|
||||
write-good..........................|ale-latex-write-good|
|
||||
less..................................|ale-less-options|
|
||||
|
|
@ -145,6 +146,7 @@ CONTENTS *ale-contents*
|
|||
markdown..............................|ale-markdown-options|
|
||||
mdl.................................|ale-markdown-mdl|
|
||||
prettier............................|ale-markdown-prettier|
|
||||
remark-lint.........................|ale-markdown-remark-lint|
|
||||
textlint............................|ale-markdown-textlint|
|
||||
write-good..........................|ale-markdown-write-good|
|
||||
mercury...............................|ale-mercury-options|
|
||||
|
|
@ -186,6 +188,7 @@ CONTENTS *ale-contents*
|
|||
puglint.............................|ale-pug-puglint|
|
||||
puppet................................|ale-puppet-options|
|
||||
puppetlint..........................|ale-puppet-puppetlint|
|
||||
puppet-languageserver...............|ale-puppet-languageserver|
|
||||
pyrex (cython)........................|ale-pyrex-options|
|
||||
cython..............................|ale-pyrex-cython|
|
||||
python................................|ale-python-options|
|
||||
|
|
@ -273,6 +276,7 @@ CONTENTS *ale-contents*
|
|||
write-good..........................|ale-vim-help-write-good|
|
||||
vue...................................|ale-vue-options|
|
||||
prettier............................|ale-vue-prettier|
|
||||
vls.................................|ale-vue-vls|
|
||||
xhtml.................................|ale-xhtml-options|
|
||||
write-good..........................|ale-xhtml-write-good|
|
||||
xml...................................|ale-xml-options|
|
||||
|
|
@ -366,7 +370,7 @@ Notes:
|
|||
* Java: `checkstyle`, `javac`, `google-java-format`, `PMD`
|
||||
* JavaScript: `eslint`, `flow`, `jscs`, `jshint`, `prettier`, `prettier-eslint`, `prettier-standard`, `standard`, `xo`
|
||||
* JSON: `fixjson`, `jsonlint`, `jq`, `prettier`
|
||||
* Kotlin: `kotlinc`, `ktlint`
|
||||
* Kotlin: `kotlinc`!!, `ktlint`!!, `languageserver`
|
||||
* LaTeX (tex): `alex`!!, `chktex`, `lacheck`, `proselint`, `redpen`, `vale`, `write-good`
|
||||
* Less: `lessc`, `prettier`, `stylelint`
|
||||
* LLVM: `llc`
|
||||
|
|
@ -390,7 +394,7 @@ Notes:
|
|||
* Pony: `ponyc`
|
||||
* proto: `protoc-gen-lint`
|
||||
* Pug: `pug-lint`
|
||||
* Puppet: `puppet`, `puppet-lint`
|
||||
* Puppet: `languageserver`, `puppet`, `puppet-lint`
|
||||
* Python: `autopep8`, `black`, `flake8`, `isort`, `mypy`, `prospector`, `pycodestyle`, `pyls`, `pyre`, `pylint`!!, `yapf`
|
||||
* QML: `qmlfmt`, `qmllint`
|
||||
* R: `lintr`
|
||||
|
|
@ -418,7 +422,7 @@ Notes:
|
|||
* Verilog: `iverilog`, `verilator`
|
||||
* Vim: `vint`
|
||||
* Vim help^: `alex`!!, `proselint`, `write-good`
|
||||
* Vue: `prettier`
|
||||
* Vue: `prettier`, `vls`
|
||||
* XHTML: `alex`!!, `proselint`, `write-good`
|
||||
* XML: `xmllint`
|
||||
* YAML: `swaglint`, `yamllint`
|
||||
|
|
@ -444,14 +448,20 @@ have even saved your changes. ALE will check your code in the following
|
|||
circumstances, which can be configured with the associated options.
|
||||
|
||||
* When you modify a buffer. - |g:ale_lint_on_text_changed|
|
||||
* On leaving insert mode. (off by default) - |g:ale_lint_on_insert_leave|
|
||||
* When you open a new or modified buffer. - |g:ale_lint_on_enter|
|
||||
* When you save a buffer. - |g:ale_lint_on_save|
|
||||
* When the filetype changes for a buffer. - |g:ale_lint_on_filetype_changed|
|
||||
* If ALE is used to check code manually. - |:ALELint|
|
||||
|
||||
In addition to the above options, ALE can also check buffers for errors when
|
||||
you leave insert mode with |g:ale_lint_on_insert_leave|, which is off by
|
||||
default. It is worth reading the documentation for every option.
|
||||
*ale-lint-settings-on-startup*
|
||||
|
||||
It is worth reading the documentation for every option. You should configure
|
||||
which events ALE will use before ALE is loaded, so it can optimize which
|
||||
autocmd commands to run. You can force autocmd commands to be reloaded with
|
||||
`:ALEDisable | ALEEnable`
|
||||
|
||||
This also applies to the autocmd commands used for |g:ale_echo_cursor|.
|
||||
|
||||
*ale-lint-file-linters*
|
||||
|
||||
|
|
@ -641,9 +651,6 @@ ALE supports the following LSP/tsserver features.
|
|||
-------------------------------------------------------------------------------
|
||||
5.1 Completion *ale-completion*
|
||||
|
||||
NOTE: At the moment, only `tsserver` for TypeScript code is supported for
|
||||
completion.
|
||||
|
||||
ALE offers limited support for automatic completion of code while you type.
|
||||
Completion is only supported while a least one LSP linter is enabled. ALE
|
||||
will only suggest symbols provided by the LSP servers.
|
||||
|
|
@ -842,6 +849,9 @@ g:ale_echo_cursor *g:ale_echo_cursor*
|
|||
this behaviour.
|
||||
The format of the message can be customizable in |g:ale_echo_msg_format|.
|
||||
|
||||
You should set this setting once before ALE is loaded, and restart Vim if
|
||||
you want to change your preferences. See |ale-lint-settings-on-startup|.
|
||||
|
||||
|
||||
g:ale_echo_delay *g:ale_echo_delay*
|
||||
*b:ale_echo_delay*
|
||||
|
|
@ -1042,19 +1052,16 @@ g:ale_lint_on_enter *g:ale_lint_on_enter*
|
|||
Type: |Number|
|
||||
Default: `1`
|
||||
|
||||
When this option is set to `1`, the |BufWinEnter| and |BufRead| events will
|
||||
be used to apply linters when buffers are first opened. If this is not
|
||||
desired, this variable can be set to `0` in your vimrc file to disable this
|
||||
behaviour.
|
||||
When this option is set to `1`, the |BufWinEnter| event will be used to
|
||||
apply linters when buffers are first opened. If this is not desired, this
|
||||
variable can be set to `0` in your vimrc file to disable this behavior.
|
||||
|
||||
The |FileChangedShellPost| and |BufEnter| events will be used to check if
|
||||
files have been changed outside of Vim. If a file is changed outside of
|
||||
Vim, it will be checked when it is next opened.
|
||||
|
||||
A |BufWinLeave| event will be used to look for the |E924|, |E925|, or |E926|
|
||||
errors after moving from a loclist or quickfix window to a new buffer. If
|
||||
prompts for these errors are opened after moving to new buffers, then ALE
|
||||
will automatically send the `<CR>` key needed to close the prompt.
|
||||
You should set this setting once before ALE is loaded, and restart Vim if
|
||||
you want to change your preferences. See |ale-lint-settings-on-startup|.
|
||||
|
||||
|
||||
g:ale_lint_on_filetype_changed *g:ale_lint_on_filetype_changed*
|
||||
|
|
@ -1062,14 +1069,13 @@ g:ale_lint_on_filetype_changed *g:ale_lint_on_filetype_changed*
|
|||
Type: |Number|
|
||||
Default: `1`
|
||||
|
||||
This option will cause ALE to run whenever the filetype is changed. A short
|
||||
delay will be used before linting will be done, so the filetype can be
|
||||
changed quickly several times in a row, but resulting in only one lint
|
||||
cycle.
|
||||
This option will cause ALE to run when the filetype for a file is changed
|
||||
after a buffer has first been loaded. A short delay will be used before
|
||||
linting will be done, so the filetype can be changed quickly several times
|
||||
in a row, but resulting in only one lint cycle.
|
||||
|
||||
If |g:ale_lint_on_enter| is set to `0`, then ALE will not lint a file when
|
||||
the filetype is initially set. Otherwise ALE would still lint files when
|
||||
buffers are opened, and the option for doing so is turned off.
|
||||
You should set this setting once before ALE is loaded, and restart Vim if
|
||||
you want to change your preferences. See |ale-lint-settings-on-startup|.
|
||||
|
||||
|
||||
g:ale_lint_on_save *g:ale_lint_on_save*
|
||||
|
|
@ -1087,17 +1093,22 @@ g:ale_lint_on_save *g:ale_lint_on_save*
|
|||
g:ale_lint_on_text_changed *g:ale_lint_on_text_changed*
|
||||
|
||||
Type: |String|
|
||||
Default: `always`
|
||||
Default: `'always'`
|
||||
|
||||
By default, ALE will check files with the various supported programs when
|
||||
text is changed by using the |TextChanged| event. If this behaviour is not
|
||||
desired, then this option can be disabled by setting it to `never`. The
|
||||
|g:ale_lint_delay| variable will be used to set a |timer_start()| on a
|
||||
delay, and each change to a file will continue to call |timer_stop()| and
|
||||
|timer_start()| repeatedly until the timer ticks by, and the linters will be
|
||||
run. The checking of files will run in the background, so it should not
|
||||
inhibit editing files. This option can also be set to `insert` or `normal`
|
||||
to lint when text is changed only in insert or normal mode respectively.
|
||||
This option controls how ALE will check your files as you make changes.
|
||||
The following values can be used.
|
||||
|
||||
`'always'`, `'1'`, or `1` - Check buffers on |TextChanged| or |TextChangedI|.
|
||||
`'normal'` - Check buffers only on |TextChanged|.
|
||||
`'insert'` - Check buffers only on |TextChangedI|.
|
||||
`'never'`, `'0'`, or `0` - Never check buffers on changes.
|
||||
|
||||
ALE will check buffers after a short delay, with a timer which resets on
|
||||
each change. The delay can be configured by adjusting the |g:ale_lint_delay|
|
||||
variable.
|
||||
|
||||
You should set this setting once before ALE is loaded, and restart Vim if
|
||||
you want to change your preferences. See |ale-lint-settings-on-startup|.
|
||||
|
||||
|
||||
g:ale_lint_on_insert_leave *g:ale_lint_on_insert_leave*
|
||||
|
|
@ -1115,6 +1126,9 @@ g:ale_lint_on_insert_leave *g:ale_lint_on_insert_leave*
|
|||
" Make using Ctrl+C do the same as Escape, to trigger autocmd commands
|
||||
inoremap <C-c> <Esc>
|
||||
<
|
||||
You should set this setting once before ALE is loaded, and restart Vim if
|
||||
you want to change your preferences. See |ale-lint-settings-on-startup|.
|
||||
|
||||
|
||||
g:ale_linter_aliases *g:ale_linter_aliases*
|
||||
*b:ale_linter_aliases*
|
||||
|
|
@ -1360,7 +1374,7 @@ g:ale_open_list *g:ale_open_list*
|
|||
g:ale_pattern_options *g:ale_pattern_options*
|
||||
|
||||
Type: |Dictionary|
|
||||
Default: `{}`
|
||||
Default: undefined
|
||||
|
||||
This option maps regular expression patterns to |Dictionary| values for
|
||||
buffer variables. This option can be set to automatically configure
|
||||
|
|
@ -1389,12 +1403,10 @@ g:ale_pattern_options *g:ale_pattern_options*
|
|||
g:ale_pattern_options_enabled *g:ale_pattern_options_enabled*
|
||||
|
||||
Type: |Number|
|
||||
Default: `!empty(g:ale_pattern_options)`
|
||||
Default: undefined
|
||||
|
||||
This option can be used for turning the behaviour of setting
|
||||
|g:ale_pattern_options| on or off. By default, setting a single key for
|
||||
|g:ale_pattern_options| will turn this option on, as long as the setting is
|
||||
configured before ALE is loaded.
|
||||
This option can be used for disabling pattern options. If set to `0`, ALE
|
||||
will not set buffer variables per |g:ale_pattern_options|.
|
||||
|
||||
|
||||
g:ale_set_balloons *g:ale_set_balloons*
|
||||
|
|
@ -1636,7 +1648,7 @@ g:ale_virtualenv_dir_names *g:ale_virtualenv_dir_names*
|
|||
b:ale_virtualenv_dir_names *b:ale_virtualenv_dir_names*
|
||||
|
||||
Type: |List|
|
||||
Default: `['.env', 'env', 've-py3', 've', 'virtualenv', 'venv']`
|
||||
Default: `['.env', '.venv', 'env', 've-py3', 've', 'virtualenv', 'venv']`
|
||||
|
||||
A list of directory names to be used when searching upwards from Python
|
||||
files to discover virtulenv directories with.
|
||||
|
|
@ -2075,6 +2087,29 @@ ALEStopAllLSPs *ALEStopAllLSPs*
|
|||
===============================================================================
|
||||
9. API *ale-api*
|
||||
|
||||
ALE offers a number of functions for running linters or fixers, or defining
|
||||
them. The following functions are part of the publicly documented part of that
|
||||
API, and should be expected to continue to work.
|
||||
|
||||
|
||||
ale#Env(variable_name, value) *ale#Env()*
|
||||
|
||||
Given a variable name and a string value, produce a string for including in
|
||||
a command for setting environment variables. This function can be used for
|
||||
building a command like so. >
|
||||
|
||||
:echo string(ale#Env('VAR', 'some value') . 'command')
|
||||
'VAR=''some value'' command' # On Linux or Mac OSX
|
||||
'set VAR="some value" && command' # On Windows
|
||||
|
||||
|
||||
ale#Pad(string) *ale#Pad()*
|
||||
|
||||
Given a string or any |empty()| value, return either the string prefixed
|
||||
with a single space, or an empty string. This function can be used to build
|
||||
parts of a command from variables.
|
||||
|
||||
|
||||
ale#Queue(delay, [linting_flag, buffer_number]) *ale#Queue()*
|
||||
|
||||
Run linters for the current buffer, based on the filetype of the buffer,
|
||||
|
|
@ -2099,8 +2134,17 @@ ale#Queue(delay, [linting_flag, buffer_number]) *ale#Queue()*
|
|||
ale#engine#CreateDirectory(buffer) *ale#engine#CreateDirectory()*
|
||||
|
||||
Create a new temporary directory with a unique name, and manage that
|
||||
directory with |ale#engine#ManageDirectory()|, so it will be removed as
|
||||
soon as possible.
|
||||
directory with |ale#engine#ManageDirectory()|, so it will be removed as soon
|
||||
as possible.
|
||||
|
||||
It is advised to only call this function from a callback function for
|
||||
returning a linter command to run.
|
||||
|
||||
|
||||
ale#engine#CreateFile(buffer) *ale#engine#CreateFile()*
|
||||
|
||||
Create a new temporary file with a unique name, and manage that file with
|
||||
|ale#engine#ManageFile()|, so it will be removed as soon as possible.
|
||||
|
||||
It is advised to only call this function from a callback function for
|
||||
returning a linter command to run.
|
||||
|
|
@ -2206,6 +2250,10 @@ ale#linter#Define(filetype, linter) *ale#linter#Define()*
|
|||
defined, as LSP linters handle diagnostics
|
||||
automatically. See |ale-lsp-linters|.
|
||||
|
||||
If the function named does not exist, including if
|
||||
the function is later deleted, ALE will behave as if
|
||||
the callback returned an empty list.
|
||||
|
||||
The keys for each item in the List will be handled in
|
||||
the following manner:
|
||||
*ale-loclist-format*
|
||||
|
|
@ -2383,9 +2431,12 @@ ale#linter#Define(filetype, linter) *ale#linter#Define()*
|
|||
with a callback returning an address to connect to.
|
||||
ALE will not start a server automatically.
|
||||
|
||||
When this argument is not empty, only one of either
|
||||
`language` or `language_callback` must be defined,
|
||||
and `project_root_callback` must be defined.
|
||||
When this argument is not empty
|
||||
`project_root_callback` must be defined.
|
||||
|
||||
`language` or `language_callback` can be defined to
|
||||
describe the language for a file. The filetype will
|
||||
be used as the language by default.
|
||||
|
||||
LSP linters handle diagnostics automatically, so
|
||||
the `callback` argument must not be defined.
|
||||
|
|
@ -2418,8 +2469,9 @@ ale#linter#Define(filetype, linter) *ale#linter#Define()*
|
|||
being checked. This string will be sent to the LSP to
|
||||
tell it what type of language is being checked.
|
||||
|
||||
This argument must only be set if the `lsp` argument
|
||||
is also set to a non-empty string.
|
||||
If this or `language_callback` isn't set, the
|
||||
language will default to the value of the filetype
|
||||
given to |ale#linter#Define|.
|
||||
|
||||
`language_callback` A |String| or |Funcref| for a callback function
|
||||
accepting a buffer number. A |String| should be
|
||||
|
|
@ -2489,15 +2541,23 @@ ale#linter#Define(filetype, linter) *ale#linter#Define()*
|
|||
|
||||
For example: >
|
||||
'command': 'ghc -fno-code -v0 %t',
|
||||
<
|
||||
Any substring `%e` will be replaced with the escaped executable supplied
|
||||
with `executable` or `executable_callback`. This provides a convenient way
|
||||
to define a command string which needs to include a dynamic executable name,
|
||||
but which is otherwise static.
|
||||
|
||||
For example: >
|
||||
'command': '%e --some-argument',
|
||||
<
|
||||
The character sequence `%%` can be used to emit a literal `%` into a
|
||||
command, so literal character sequences `%s` and `%t` can be escaped by
|
||||
using `%%s` and `%%t` instead, etc.
|
||||
|
||||
If a callback for a command generates part of a command string which might
|
||||
possibly contain `%%`, `%s`, or `%t` where the special formatting behaviour
|
||||
is not desired, the |ale#engine#EscapeCommandPart()| function can be used to
|
||||
replace those characters to avoid formatting issues.
|
||||
possibly contain `%%`, `%s`, `%t`, or `%e`, where the special formatting
|
||||
behavior is not desired, the |ale#engine#EscapeCommandPart()| function can
|
||||
be used to replace those characters to avoid formatting issues.
|
||||
|
||||
*ale-linter-loading-behavior*
|
||||
*ale-linter-loading-behaviour*
|
||||
|
|
|
|||
|
|
@ -35,15 +35,11 @@ endif
|
|||
" Set this flag so that other plugins can use it, like airline.
|
||||
let g:loaded_ale = 1
|
||||
|
||||
" Set the TMPDIR environment variable if it is not set automatically.
|
||||
" This can automatically fix some environments.
|
||||
if has('unix') && empty($TMPDIR)
|
||||
let $TMPDIR = '/tmp'
|
||||
endif
|
||||
|
||||
" This global variable is used internally by ALE for tracking information for
|
||||
" each buffer which linters are being run against.
|
||||
let g:ale_buffer_info = {}
|
||||
" This global Dictionary tracks data for fixing code. Don't mess with it.
|
||||
let g:ale_fix_buffer_data = {}
|
||||
|
||||
" User Configuration
|
||||
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ add the following configuration to your `.vimrc`.
|
|||
set laststatus=2
|
||||
```
|
||||
|
||||
If the statusline does not be coloured like
|
||||
If the statusline is not coloured like
|
||||
|
||||
|
||||
then modify `TERM` in your shell configuration (`.zshrc` for example)
|
||||
|
|
|
|||
|
|
@ -18,15 +18,13 @@ uncomments a set of adjacent commented lines.
|
|||
|
||||
## Installation
|
||||
|
||||
If you don't have a preferred installation method, I recommend
|
||||
installing [pathogen.vim](https://github.com/tpope/vim-pathogen), and
|
||||
then simply copy and paste:
|
||||
Install using your favorite package manager, or use Vim's built-in package
|
||||
support:
|
||||
|
||||
cd ~/.vim/bundle
|
||||
git clone git://github.com/tpope/vim-commentary.git
|
||||
|
||||
Once help tags have been generated, you can view the manual with
|
||||
`:help commentary`.
|
||||
mkdir -p ~/.vim/pack/tpope/start
|
||||
cd ~/.vim/pack/tpope/start
|
||||
git clone https://tpope.io/vim/commentary.git
|
||||
vim -u NONE -c "helptags commentary/doc" -c q
|
||||
|
||||
## FAQ
|
||||
|
||||
|
|
|
|||
|
|
@ -93,7 +93,7 @@ command! -range -bar Commentary call s:go(<line1>,<line2>)
|
|||
xnoremap <expr> <Plug>Commentary <SID>go()
|
||||
nnoremap <expr> <Plug>Commentary <SID>go()
|
||||
nnoremap <expr> <Plug>CommentaryLine <SID>go() . '_'
|
||||
onoremap <silent> <Plug>Commentary :<C-U>call <SID>textobject(0)<CR>
|
||||
onoremap <silent> <Plug>Commentary :<C-U>call <SID>textobject(get(v:, 'operator', '') ==# 'c')<CR>
|
||||
nnoremap <silent> <Plug>ChangeCommentary c:<C-U>call <SID>textobject(1)<CR>
|
||||
nmap <silent> <Plug>CommentaryUndo :echoerr "Change your <Plug>CommentaryUndo map to <Plug>Commentary<Plug>Commentary"<CR>
|
||||
|
||||
|
|
@ -102,7 +102,7 @@ if !hasmapto('<Plug>Commentary') || maparg('gc','n') ==# ''
|
|||
nmap gc <Plug>Commentary
|
||||
omap gc <Plug>Commentary
|
||||
nmap gcc <Plug>CommentaryLine
|
||||
if maparg('c','n') ==# ''
|
||||
if maparg('c','n') ==# '' && !exists('v:operator')
|
||||
nmap cgc <Plug>ChangeCommentary
|
||||
endif
|
||||
nmap gcu <Plug>Commentary<Plug>Commentary
|
||||
|
|
|
|||
|
|
@ -46,6 +46,14 @@ function! s:fnameescape(file) abort
|
|||
endif
|
||||
endfunction
|
||||
|
||||
function! s:tempname() abort
|
||||
let temp = resolve(tempname())
|
||||
if has('win32')
|
||||
let temp = fnamemodify(fnamemodify(temp, ':h'), ':p').fnamemodify(temp, ':t')
|
||||
endif
|
||||
return temp
|
||||
endfunction
|
||||
|
||||
function! s:throw(string) abort
|
||||
let v:errmsg = 'fugitive: '.a:string
|
||||
throw v:errmsg
|
||||
|
|
@ -83,12 +91,21 @@ function! s:executable(binary) abort
|
|||
return s:executables[a:binary]
|
||||
endfunction
|
||||
|
||||
let s:git_versions = {}
|
||||
|
||||
function! s:git_command() abort
|
||||
return get(g:, 'fugitive_git_command', g:fugitive_git_executable)
|
||||
endfunction
|
||||
|
||||
function! fugitive#Prepare(...) abort
|
||||
let args = copy(a:000)
|
||||
if empty(args)
|
||||
return g:fugitive_git_executable
|
||||
elseif args[0] !~# '^-' && args[0] =~# '[\/.]'
|
||||
let args[0] = '--git-dir=' . args[0]
|
||||
endif
|
||||
return g:fugitive_git_executable . ' ' . join(map(args, 's:shellesc(v:val)'), ' ')
|
||||
endfunction
|
||||
|
||||
let s:git_versions = {}
|
||||
function! fugitive#GitVersion(...) abort
|
||||
if !has_key(s:git_versions, g:fugitive_git_executable)
|
||||
let s:git_versions[g:fugitive_git_executable] = matchstr(system(g:fugitive_git_executable.' --version'), "\\S\\+\\ze\n")
|
||||
|
|
@ -173,7 +190,7 @@ function! fugitive#Init() abort
|
|||
call s:map('n', 'y<C-G>', ':call setreg(v:register, <SID>recall())<CR>', '<silent>')
|
||||
endif
|
||||
let buffer = fugitive#buffer()
|
||||
if expand('%:p') =~# '://'
|
||||
if expand('%:p') =~# ':[\/][\/]'
|
||||
call buffer.setvar('&path', s:sub(buffer.getvar('&path'), '^\.%(,|$)', ''))
|
||||
endif
|
||||
if stridx(buffer.getvar('&tags'), escape(b:git_dir, ', ')) == -1
|
||||
|
|
@ -315,9 +332,7 @@ function! s:repo_git_command(...) dict abort
|
|||
endfunction
|
||||
|
||||
function! s:repo_git_chomp(...) dict abort
|
||||
let git = g:fugitive_git_executable . ' --git-dir='.s:shellesc(self.git_dir)
|
||||
let output = git.join(map(copy(a:000),'" ".s:shellesc(v:val)'),'')
|
||||
return s:sub(system(output),'\n$','')
|
||||
return s:sub(system(call('fugitive#Prepare', [self.git_dir] + a:000)),'\n$','')
|
||||
endfunction
|
||||
|
||||
function! s:repo_git_chomp_in_tree(...) dict abort
|
||||
|
|
@ -429,11 +444,16 @@ call s:add_methods('repo',['keywordprg'])
|
|||
" Section: Buffer
|
||||
|
||||
function! s:DirCommitFile(path) abort
|
||||
let vals = matchlist(s:shellslash(a:path), '\c^fugitive:\%(//\)\=\(.\{-\}\)\%(//\|::\)\(\w\+\)\(/.*\)\=$')
|
||||
let vals = matchlist(s:shellslash(a:path), '\c^fugitive:\%(//\)\=\(.\{-\}\)\%(//\|::\)\(\x\{40\}\|[0-3]\)\(/.*\)\=$')
|
||||
if empty(vals)
|
||||
return ['', '', '']
|
||||
endif
|
||||
return [vals[1], (vals[2] =~# '^.$' ? ':' : '') . vals[2], vals[3]]
|
||||
return vals[1:3]
|
||||
endfunction
|
||||
|
||||
function! s:DirRev(url) abort
|
||||
let [dir, commit, file] = s:DirCommitFile(a:url)
|
||||
return [dir, (commit =~# '^.$' ? ':' : '') . commit . substitute(file, '^/', ':', '')]
|
||||
endfunction
|
||||
|
||||
function! fugitive#Path(url) abort
|
||||
|
|
@ -454,7 +474,7 @@ endfunction
|
|||
let s:trees = {}
|
||||
let s:indexes = {}
|
||||
function! s:TreeInfo(dir, commit) abort
|
||||
let git = g:fugitive_git_executable . ' --git-dir=' . s:shellesc(a:dir)
|
||||
let git = fugitive#Prepare(a:dir)
|
||||
if a:commit =~# '^:\=[0-3]$'
|
||||
let index = get(s:indexes, a:dir, [])
|
||||
let newftime = getftime(a:dir . '/index')
|
||||
|
|
@ -547,7 +567,7 @@ function! fugitive#getfsize(url) abort
|
|||
let entry = s:PathInfo(a:url)
|
||||
if entry[4] == -2 && entry[2] ==# 'blob' && len(entry[3])
|
||||
let dir = s:DirCommitFile(a:url)[0]
|
||||
let size = +system(g:fugitive_git_executable . ' ' . s:shellesc('--git-dir=' . dir) . ' cat-file -s ' . entry[3])
|
||||
let size = +system(fugitive#Prepare(dir, 'cat-file', '-s', entry[3]))
|
||||
let entry[4] = v:shell_error ? -1 : size
|
||||
endif
|
||||
return entry[4]
|
||||
|
|
@ -572,9 +592,8 @@ function! fugitive#readfile(url, ...) abort
|
|||
if entry[2] !=# 'blob'
|
||||
return []
|
||||
endif
|
||||
let [dir, commit, file] = s:DirCommitFile(a:url)
|
||||
let cmd = g:fugitive_git_executable . ' --git-dir=' . s:shellesc(dir) .
|
||||
\ ' cat-file blob ' . s:shellesc(commit . ':' . file[1:-1])
|
||||
let [dir, rev] = s:DirRev(a:url)
|
||||
let cmd = fugitive#Prepare(dir, 'cat-file', 'blob', rev)
|
||||
if max > 0 && s:executable('head')
|
||||
let cmd .= '|head -' . max
|
||||
endif
|
||||
|
|
@ -634,7 +653,7 @@ function! s:buffer(...) abort
|
|||
if buffer.getvar('git_dir') !=# ''
|
||||
return buffer
|
||||
endif
|
||||
call s:throw('not a git repository: '.expand('%:p'))
|
||||
call s:throw('not a git repository: '.bufname(buffer['#']))
|
||||
endfunction
|
||||
|
||||
function! fugitive#buffer(...) abort
|
||||
|
|
@ -658,9 +677,9 @@ function! s:buffer_repo() dict abort
|
|||
endfunction
|
||||
|
||||
function! s:buffer_type(...) dict abort
|
||||
if self.getvar('fugitive_type') != ''
|
||||
if !empty(self.getvar('fugitive_type'))
|
||||
let type = self.getvar('fugitive_type')
|
||||
elseif fnamemodify(self.spec(),':p') =~# '.\git/refs/\|\.git/\w*HEAD$'
|
||||
elseif fnamemodify(self.spec(),':p') =~# '\.git/refs/\|\.git/\w*HEAD$'
|
||||
let type = 'head'
|
||||
elseif self.getline(1) =~ '^tree \x\{40\}$' && self.getline(2) == ''
|
||||
let type = 'tree'
|
||||
|
|
@ -843,9 +862,9 @@ function! s:Git(bang, mods, args) abort
|
|||
let git .= ' --no-pager'
|
||||
endif
|
||||
let args = matchstr(a:args,'\v\C.{-}%($|\\@<!%(\\\\)*\|)@=')
|
||||
if exists(':terminal') && has('nvim')
|
||||
if exists(':terminal') && has('nvim') && !get(g:, 'fugitive_force_bang_command')
|
||||
let dir = s:repo().tree()
|
||||
if expand('%') != ''
|
||||
if len(@%)
|
||||
-tabedit %
|
||||
else
|
||||
-tabnew
|
||||
|
|
@ -1239,7 +1258,14 @@ function! s:Commit(mods, args, ...) abort
|
|||
let args = a:args
|
||||
let args = s:gsub(args,'%(%(^| )-- )@<!%(^| )@<=%(-[esp]|--edit|--interactive|--patch|--signoff)%($| )','')
|
||||
let args = s:gsub(args,'%(%(^| )-- )@<!%(^| )@<=%(-c|--reedit-message|--reuse-message|-F|--file|-m|--message)%(\s+|\=)%(''[^'']*''|"%(\\.|[^"])*"|\\.|\S)*','')
|
||||
let args = s:gsub(args,'%(^| )@<=[%#]%(:\w)*','\=expand(submatch(0))')
|
||||
let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
|
||||
let cwd = getcwd()
|
||||
try
|
||||
exe cd s:fnameescape(repo.tree())
|
||||
let args = s:gsub(args,'\\@<!(\%|##=|#\<=\d+)(:\w)*','\=fnamemodify(FugitivePath(expand(submatch(1))),":." . submatch(2))')
|
||||
finally
|
||||
exe cd cwd
|
||||
endtry
|
||||
let args = s:sub(args, '\ze -- |$', ' --no-edit --no-interactive --no-signoff')
|
||||
let args = '-F '.s:shellesc(msgfile).' '.args
|
||||
if args !~# '\%(^\| \)--cleanup\>'
|
||||
|
|
@ -1560,10 +1586,7 @@ function! s:Edit(cmd, bang, mods, ...) abort
|
|||
diffupdate
|
||||
return 'redraw|echo '.string(':!'.git.' '.args)
|
||||
else
|
||||
let temp = resolve(tempname())
|
||||
if has('win32')
|
||||
let temp = fnamemodify(fnamemodify(temp, ':h'), ':p').fnamemodify(temp, ':t')
|
||||
endif
|
||||
let temp = s:tempname()
|
||||
let s:temp_files[s:cpath(temp)] = { 'dir': buffer.repo().dir(), 'args': arglist }
|
||||
silent execute mods a:cmd temp
|
||||
if a:cmd =~# 'pedit'
|
||||
|
|
@ -2113,7 +2136,7 @@ augroup fugitive_blame
|
|||
autocmd!
|
||||
autocmd FileType fugitiveblame setlocal nomodeline | if exists('b:git_dir') | let &l:keywordprg = s:repo().keywordprg() | endif
|
||||
autocmd Syntax fugitiveblame call s:BlameSyntax()
|
||||
autocmd User Fugitive if s:buffer().type('file', 'blob') | exe "command! -buffer -bar -bang -range=0 -nargs=* Gblame :execute s:Blame(<bang>0,<line1>,<line2>,<count>,[<f-args>])" | endif
|
||||
autocmd User Fugitive if s:buffer().type('file', 'blob', 'blame') | exe "command! -buffer -bar -bang -range=0 -nargs=* Gblame :execute s:Blame(<bang>0,<line1>,<line2>,<count>,[<f-args>])" | endif
|
||||
autocmd ColorScheme,GUIEnter * call s:RehighlightBlame()
|
||||
autocmd BufWinLeave * execute getwinvar(+bufwinnr(+expand('<abuf>')), 'fugitive_leave')
|
||||
augroup END
|
||||
|
|
@ -2157,7 +2180,7 @@ function! s:Blame(bang,line1,line2,count,args) abort
|
|||
if a:count
|
||||
execute 'write !'.substitute(basecmd,' blame ',' blame -L '.a:line1.','.a:line2.' ','g')
|
||||
else
|
||||
let error = resolve(tempname())
|
||||
let error = s:tempname()
|
||||
let temp = error.'.fugitiveblame'
|
||||
if &shell =~# 'csh'
|
||||
silent! execute '%write !('.basecmd.' > '.temp.') >& '.error
|
||||
|
|
@ -2197,12 +2220,10 @@ function! s:Blame(bang,line1,line2,count,args) abort
|
|||
endif
|
||||
let top = line('w0') + &scrolloff
|
||||
let current = line('.')
|
||||
if has('win32')
|
||||
let temp = fnamemodify(fnamemodify(temp, ':h'), ':p').fnamemodify(temp, ':t')
|
||||
endif
|
||||
let s:temp_files[s:cpath(temp)] = { 'dir': s:repo().dir(), 'args': cmd }
|
||||
exe 'keepalt leftabove vsplit '.temp
|
||||
let b:fugitive_blamed_bufnr = bufnr
|
||||
let b:fugitive_type = 'blame'
|
||||
let w:fugitive_leave = restore
|
||||
let b:fugitive_blame_arguments = join(a:args,' ')
|
||||
execute top
|
||||
|
|
@ -2633,12 +2654,10 @@ call extend(g:fugitive_browse_handlers,
|
|||
|
||||
" Section: File access
|
||||
|
||||
function! s:ReplaceCmd(cmd,...) abort
|
||||
let fn = expand('%:p')
|
||||
let tmp = tempname()
|
||||
function! s:WriteCmd(out, cmd, ...) abort
|
||||
let prefix = ''
|
||||
try
|
||||
if a:0 && a:1 != ''
|
||||
if a:0 && len(a:1)
|
||||
if s:winshell()
|
||||
let old_index = $GIT_INDEX_FILE
|
||||
let $GIT_INDEX_FILE = a:1
|
||||
|
|
@ -2646,23 +2665,29 @@ function! s:ReplaceCmd(cmd,...) abort
|
|||
let prefix = 'env GIT_INDEX_FILE='.s:shellesc(a:1).' '
|
||||
endif
|
||||
endif
|
||||
let redir = ' > '.tmp
|
||||
if &shellpipe =~ '2>&1'
|
||||
let redir .= ' 2>&1'
|
||||
endif
|
||||
let redir = ' > '.a:out
|
||||
if s:winshell()
|
||||
let cmd_escape_char = &shellxquote == '(' ? '^' : '^^^'
|
||||
call system('cmd /c "'.prefix.s:gsub(a:cmd,'[<>]', cmd_escape_char.'&').redir.'"')
|
||||
return system('cmd /c "'.prefix.s:gsub(a:cmd,'[<>]', cmd_escape_char.'&').redir.'"')
|
||||
elseif &shell =~# 'fish'
|
||||
call system(' begin;'.prefix.a:cmd.redir.';end ')
|
||||
return system(' begin;'.prefix.a:cmd.redir.';end ')
|
||||
else
|
||||
call system(' ('.prefix.a:cmd.redir.') ')
|
||||
return system(' ('.prefix.a:cmd.redir.') ')
|
||||
endif
|
||||
finally
|
||||
if exists('old_index')
|
||||
let $GIT_INDEX_FILE = old_index
|
||||
endif
|
||||
endtry
|
||||
endfunction
|
||||
|
||||
function! s:ReplaceCmd(cmd, ...) abort
|
||||
let tmp = tempname()
|
||||
let err = s:WriteCmd(tmp, a:cmd, a:0 ? a:1 : '')
|
||||
if v:shell_error
|
||||
call s:throw((len(err) ? err : filereadable(tmp) ? join(readfile(tmp), ' ') : 'unknown error running ' . a:cmd))
|
||||
endif
|
||||
let fn = expand('%:p')
|
||||
silent exe 'doau BufReadPre '.s:fnameescape(fn)
|
||||
silent exe 'keepalt file '.tmp
|
||||
try
|
||||
|
|
@ -2729,10 +2754,10 @@ function! fugitive#BufReadStatus() abort
|
|||
nnoremap <buffer> <silent> <C-P> :<C-U>execute <SID>StagePrevious(v:count1)<CR>
|
||||
nnoremap <buffer> <silent> - :<C-U>silent execute <SID>StageToggle(line('.'),line('.')+v:count1-1)<CR>
|
||||
xnoremap <buffer> <silent> - :<C-U>silent execute <SID>StageToggle(line("'<"),line("'>"))<CR>
|
||||
nnoremap <buffer> <silent> a :<C-U>let b:fugitive_display_format += 1<Bar>exe fugitive#BufReadIndex()<CR>
|
||||
nnoremap <buffer> <silent> i :<C-U>let b:fugitive_display_format -= 1<Bar>exe fugitive#BufReadIndex()<CR>
|
||||
nnoremap <buffer> <silent> a :<C-U>let b:fugitive_display_format += 1<Bar>exe fugitive#BufReadStatus()<CR>
|
||||
nnoremap <buffer> <silent> i :<C-U>let b:fugitive_display_format -= 1<Bar>exe fugitive#BufReadStatus()<CR>
|
||||
nnoremap <buffer> <silent> C :<C-U>Gcommit<CR>:echohl WarningMsg<Bar>echo ':Gstatus C is deprecated in favor of cc'<Bar>echohl NONE<CR>
|
||||
nnoremap <buffer> <silent> cA :<C-U>Gcommit --amend --reuse-message=HEAD<CR>:echohl WarningMsg<Bar>echo ':Gstatus cA is deprecated in favor of ce'<CR>
|
||||
nnoremap <buffer> <silent> cA :<C-U>Gcommit --amend --reuse-message=HEAD<CR>:echohl WarningMsg<Bar>echo ':Gstatus cA is deprecated in favor of ce'<Bar>echohl NONE<CR>
|
||||
nnoremap <buffer> <silent> ca :<C-U>Gcommit --amend<CR>
|
||||
nnoremap <buffer> <silent> cc :<C-U>Gcommit<CR>
|
||||
nnoremap <buffer> <silent> ce :<C-U>Gcommit --amend --no-edit<CR>
|
||||
|
|
@ -2761,21 +2786,16 @@ function! fugitive#BufReadStatus() abort
|
|||
endfunction
|
||||
|
||||
function! fugitive#FileRead() abort
|
||||
try
|
||||
let [dir, commit, file] = s:DirCommitFile(expand('<amatch>'))
|
||||
let repo = s:repo(dir)
|
||||
let path = commit . substitute(file, '^/', ':', '')
|
||||
let hash = repo.rev_parse(path)
|
||||
if path =~ '^:'
|
||||
let type = 'blob'
|
||||
else
|
||||
let type = repo.git_chomp('cat-file','-t',hash)
|
||||
endif
|
||||
" TODO: use count, if possible
|
||||
return "read !".escape(repo.git_command('cat-file',type,hash),'%#\')
|
||||
catch /^fugitive:/
|
||||
return 'echoerr v:errmsg'
|
||||
endtry
|
||||
let [dir, rev] = s:DirRev(expand('<amatch>'))
|
||||
if empty(dir)
|
||||
return "noautocmd '[read <amatch>"
|
||||
endif
|
||||
if rev !~# ':'
|
||||
let cmd = fugitive#Prepare(dir, 'log', '--pretty=format:%B', '-1', rev)
|
||||
else
|
||||
let cmd = fugitive#Prepare(dir, 'cat-file', '-p', rev)
|
||||
endif
|
||||
return "'[read !" . escape(cmd, '!#%')
|
||||
endfunction
|
||||
|
||||
function! fugitive#BufReadIndex() abort
|
||||
|
|
@ -2916,10 +2936,6 @@ function! fugitive#BufReadObject() abort
|
|||
endtry
|
||||
endfunction
|
||||
|
||||
augroup fugitive_files
|
||||
autocmd!
|
||||
augroup END
|
||||
|
||||
" Section: Temp files
|
||||
|
||||
if !exists('s:temp_files')
|
||||
|
|
@ -2931,7 +2947,7 @@ augroup fugitive_temp
|
|||
autocmd BufNewFile,BufReadPost *
|
||||
\ if has_key(s:temp_files,s:cpath(expand('<afile>:p'))) |
|
||||
\ let b:git_dir = s:temp_files[s:cpath(expand('<afile>:p'))].dir |
|
||||
\ let b:git_type = 'temp' |
|
||||
\ call extend(b:, {'fugitive_type': 'temp'}, 'keep') |
|
||||
\ let b:git_args = s:temp_files[s:cpath(expand('<afile>:p'))].args |
|
||||
\ call FugitiveDetect(expand('<afile>:p')) |
|
||||
\ setlocal bufhidden=delete nobuflisted |
|
||||
|
|
|
|||
|
|
@ -54,8 +54,8 @@ that are part of Git repositories).
|
|||
dv |:Gvdiff|
|
||||
O |:Gtabedit|
|
||||
o |:Gsplit|
|
||||
p |:Git| add --patch
|
||||
p |:Git| reset --patch (staged files)
|
||||
P |:Git| add --patch
|
||||
P |:Git| reset --patch (staged files)
|
||||
q close status
|
||||
r reload status
|
||||
S |:Gvsplit|
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
" fugitive.vim - A Git wrapper so awesome, it should be illegal
|
||||
" Maintainer: Tim Pope <http://tpo.pe/>
|
||||
" Version: 2.3
|
||||
" Version: 2.4
|
||||
" GetLatestVimScripts: 2975 1 :AutoInstall: fugitive.vim
|
||||
|
||||
if exists('g:loaded_fugitive')
|
||||
|
|
@ -110,7 +110,7 @@ function! FugitiveExtractGitDir(path) abort
|
|||
endfunction
|
||||
|
||||
function! FugitiveDetect(path) abort
|
||||
if exists('b:git_dir') && (b:git_dir ==# '' || b:git_dir =~# '/$')
|
||||
if exists('b:git_dir') && b:git_dir =~# '^$\|/$\|^fugitive:'
|
||||
unlet b:git_dir
|
||||
endif
|
||||
if !exists('b:git_dir')
|
||||
|
|
@ -156,7 +156,10 @@ augroup fugitive
|
|||
|
||||
autocmd BufNewFile,BufReadPost * call FugitiveDetect(expand('%:p'))
|
||||
autocmd FileType netrw call FugitiveDetect(fnamemodify(get(b:, 'netrw_curdir', @%), ':p'))
|
||||
autocmd User NERDTreeInit,NERDTreeNewRoot call FugitiveDetect(b:NERDTree.root.path.str())
|
||||
autocmd User NERDTreeInit,NERDTreeNewRoot
|
||||
\ if exists('b:NERDTree.root.path.str') |
|
||||
\ call FugitiveDetect(b:NERDTree.root.path.str()) |
|
||||
\ endif
|
||||
autocmd VimEnter * if expand('<amatch>')==''|call FugitiveDetect(getcwd())|endif
|
||||
autocmd CmdWinEnter * call FugitiveDetect(expand('#:p'))
|
||||
|
||||
|
|
|
|||
|
|
@ -3,11 +3,19 @@ let s:t_string = type('')
|
|||
" Primary functions {{{
|
||||
|
||||
function! gitgutter#all(force) abort
|
||||
for bufnr in s:uniq(tabpagebuflist())
|
||||
let file = expand('#'.bufnr.':p')
|
||||
if !empty(file)
|
||||
call gitgutter#init_buffer(bufnr)
|
||||
call gitgutter#process_buffer(bufnr, a:force)
|
||||
let visible = tabpagebuflist()
|
||||
|
||||
for bufnr in range(1, bufnr('$') + 1)
|
||||
if buflisted(bufnr)
|
||||
let file = expand('#'.bufnr.':p')
|
||||
if !empty(file)
|
||||
if index(visible, bufnr) != -1
|
||||
call gitgutter#init_buffer(bufnr)
|
||||
call gitgutter#process_buffer(bufnr, a:force)
|
||||
elseif a:force
|
||||
call s:reset_tick(bufnr)
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
endfunction
|
||||
|
|
@ -16,10 +24,10 @@ endfunction
|
|||
" Finds the file's path relative to the repo root.
|
||||
function! gitgutter#init_buffer(bufnr)
|
||||
if gitgutter#utility#is_active(a:bufnr)
|
||||
call s:setup_maps()
|
||||
let p = gitgutter#utility#repo_path(a:bufnr, 0)
|
||||
if type(p) != s:t_string || empty(p)
|
||||
call gitgutter#utility#set_repo_path(a:bufnr)
|
||||
call s:setup_maps()
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
|
@ -52,15 +60,12 @@ endfunction
|
|||
|
||||
function! gitgutter#disable() abort
|
||||
" get list of all buffers (across all tabs)
|
||||
let buflist = []
|
||||
for i in range(tabpagenr('$'))
|
||||
call extend(buflist, tabpagebuflist(i + 1))
|
||||
endfor
|
||||
|
||||
for bufnr in s:uniq(buflist)
|
||||
let file = expand('#'.bufnr.':p')
|
||||
if !empty(file)
|
||||
call s:clear(bufnr)
|
||||
for bufnr in range(1, bufnr('$') + 1)
|
||||
if buflisted(bufnr)
|
||||
let file = expand('#'.bufnr.':p')
|
||||
if !empty(file)
|
||||
call s:clear(bufnr)
|
||||
endif
|
||||
endif
|
||||
endfor
|
||||
|
||||
|
|
@ -132,19 +137,3 @@ function! s:clear(bufnr)
|
|||
call gitgutter#hunk#reset(a:bufnr)
|
||||
call s:reset_tick(a:bufnr)
|
||||
endfunction
|
||||
|
||||
if exists('*uniq') " Vim 7.4.218
|
||||
function! s:uniq(list)
|
||||
return uniq(sort(a:list))
|
||||
endfunction
|
||||
else
|
||||
function! s:uniq(list)
|
||||
let processed = []
|
||||
for e in a:list
|
||||
if index(processed, e) == -1
|
||||
call add(processed, e)
|
||||
endif
|
||||
endfor
|
||||
return processed
|
||||
endfunction
|
||||
endif
|
||||
|
|
|
|||
|
|
@ -173,26 +173,10 @@ nnoremap <silent> <Plug>GitGutterPreviewHunk :GitGutterPreviewHunk<CR>
|
|||
|
||||
" }}}
|
||||
|
||||
function! s:flag_inactive_tabs()
|
||||
let active_tab = tabpagenr()
|
||||
for i in range(1, tabpagenr('$'))
|
||||
if i != active_tab
|
||||
call settabvar(i, 'gitgutter_force', 1)
|
||||
endif
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
function! s:on_bufenter()
|
||||
if exists('t:gitgutter_didtabenter') && t:gitgutter_didtabenter
|
||||
let t:gitgutter_didtabenter = 0
|
||||
let force = !g:gitgutter_terminal_reports_focus
|
||||
|
||||
if exists('t:gitgutter_force') && t:gitgutter_force
|
||||
let t:gitgutter_force = 0
|
||||
let force = 1
|
||||
endif
|
||||
|
||||
call gitgutter#all(force)
|
||||
call gitgutter#all(!g:gitgutter_terminal_reports_focus)
|
||||
else
|
||||
call gitgutter#init_buffer(bufnr(''))
|
||||
call gitgutter#process_buffer(bufnr(''), !g:gitgutter_terminal_reports_focus)
|
||||
|
|
@ -208,15 +192,15 @@ augroup gitgutter
|
|||
|
||||
autocmd BufEnter * call s:on_bufenter()
|
||||
|
||||
autocmd CursorHold,CursorHoldI * call gitgutter#process_buffer(bufnr(''), 0)
|
||||
autocmd FileChangedShellPost,ShellCmdPost * call gitgutter#process_buffer(bufnr(''), 1)
|
||||
autocmd CursorHold,CursorHoldI * call gitgutter#process_buffer(bufnr(''), 0)
|
||||
autocmd FileChangedShellPost * call gitgutter#process_buffer(bufnr(''), 1)
|
||||
|
||||
" Ensure that all buffers are processed when opening vim with multiple files, e.g.:
|
||||
"
|
||||
" vim -o file1 file2
|
||||
autocmd VimEnter * if winnr() != winnr('$') | call gitgutter#all(0) | endif
|
||||
|
||||
autocmd FocusGained * call gitgutter#all(1) | call s:flag_inactive_tabs()
|
||||
autocmd FocusGained,ShellCmdPost * call gitgutter#all(1)
|
||||
|
||||
autocmd ColorScheme * call gitgutter#highlight#define_sign_column_highlight() | call gitgutter#highlight#define_highlights()
|
||||
|
||||
|
|
|
|||
|
|
@ -8,9 +8,16 @@ matrix:
|
|||
- env: SCRIPT="test -c" VIM_VERSION=vim-7.4
|
||||
- env: SCRIPT="test -c" VIM_VERSION=vim-8.0
|
||||
- env: SCRIPT="test -c" VIM_VERSION=nvim
|
||||
- env: SCRIPT=lint VIM_VERSION=vim-8.0
|
||||
- env: ENV=vimlint SCRIPT=lint VIM_VERSION=vim-8.0
|
||||
language: python
|
||||
python: 3.6
|
||||
install:
|
||||
- ./scripts/install-vim $VIM_VERSION
|
||||
- pip install --user vim-vint covimerage codecov
|
||||
- |
|
||||
if [ "$ENV" = "vimlint" ]; then
|
||||
pip install vim-vint covimerage codecov pathlib
|
||||
else
|
||||
pip install --user vim-vint covimerage codecov pathlib
|
||||
fi
|
||||
script:
|
||||
- ./scripts/$SCRIPT $VIM_VERSION
|
||||
|
|
|
|||
|
|
@ -1,5 +1,11 @@
|
|||
## unplanned
|
||||
|
||||
IMPROVEMENTS:
|
||||
* Unify async job handling for Vim8 and Neovim.
|
||||
[[GH-1864]](https://github.com/fatih/vim-go/pull/1864)
|
||||
|
||||
## 1.18 - (July 18, 2018)
|
||||
|
||||
FEATURES:
|
||||
|
||||
* Add **:GoIfErr** command together with the `<Plug>(go-iferr)` plug key to
|
||||
|
|
@ -7,21 +13,22 @@ FEATURES:
|
|||
automatically which infer the type of return values and the numbers.
|
||||
For example:
|
||||
|
||||
```
|
||||
func doSomething() (string, error) {
|
||||
f, err := os.Open("file")
|
||||
}
|
||||
```
|
||||
Becomes:
|
||||
```
|
||||
func doSomething() (string, error) {
|
||||
f, err := os.Open("file")
|
||||
}
|
||||
```
|
||||
|
||||
Becomes:
|
||||
|
||||
```
|
||||
func doSomething() (string, error) {
|
||||
f, err := os.Open("file")
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
```
|
||||
```
|
||||
func doSomething() (string, error) {
|
||||
f, err := os.Open("file")
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
* Two new text objects has been added:
|
||||
* `ic` (inner comment) selects the content of the comment, excluding the start/end markers (i.e: `//`, `/*`)
|
||||
|
|
@ -56,6 +63,10 @@ IMPROVEMENTS:
|
|||
manually. [[GH-1861]](https://github.com/fatih/vim-go/pull/1861).
|
||||
* Cleanup title of terminal window.
|
||||
[[GH-1861]](https://github.com/fatih/vim-go/pull/1861).
|
||||
* Add `:GoImpl` is able to complete interfaces by their full import path in
|
||||
addition to the current package name (i.e: `:GoImpl t *T github.com/BurntSushi/toml.Unmarshaller`
|
||||
is now possible)
|
||||
[[GH-1884]](https://github.com/fatih/vim-go/pull/1884)
|
||||
|
||||
BUG FIXES:
|
||||
|
||||
|
|
@ -76,24 +87,14 @@ BUG FIXES:
|
|||
[[GH-1818]](https://github.com/fatih/vim-go/pull/1818)
|
||||
* Fix Neovim handling of guru output.
|
||||
[[GH-1846]](https://github.com/fatih/vim-go/pull/1846)
|
||||
|
||||
BACKWARDS INCOMPATIBILITIES:
|
||||
|
||||
* We switched to a [maintained fork of * gocode](https://github.com/mdempsky/gocode).
|
||||
The new fork doesn't support the following settings anymore and therefore are
|
||||
invalid. Please remove them from your vimrc until those are again supported
|
||||
by `gocode`.
|
||||
|
||||
```
|
||||
g:go_gocode_autobuild
|
||||
g:go_gocode_propose_builtins
|
||||
g:go_gocode_unimported_packages
|
||||
```
|
||||
|
||||
Checkout the issue for more details [[GH-1851]](https://github.com/fatih/vim-go/pull/1851)
|
||||
|
||||
|
||||
|
||||
* Execute commands correctly when they are in $GOBIN but not $PATH.
|
||||
[[GH-1866]](https://github.com/fatih/vim-go/pull/1866)
|
||||
* Open files correctly with ctrlp.
|
||||
[[GH-1878]](https://github.com/fatih/vim-go/pull/1878)
|
||||
* Fix checking guru binary path
|
||||
[[GH-1886]](https://github.com/fatih/vim-go/pull/1886)
|
||||
* Add build tags to `:GoDef` if only it's present
|
||||
[[GH-1882]](https://github.com/fatih/vim-go/pull/1882)
|
||||
|
||||
## 1.17 - (March 27, 2018)
|
||||
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ function! ctrlp#decls#enter() abort
|
|||
call add(s:decls, printf("%s\t%s |%s:%s:%s|\t%s",
|
||||
\ decl.ident . space,
|
||||
\ decl.keyword,
|
||||
\ fnamemodify(decl.filename, ":t"),
|
||||
\ fnamemodify(decl.filename, ":."),
|
||||
\ decl.line,
|
||||
\ decl.col,
|
||||
\ decl.full,
|
||||
|
|
|
|||
|
|
@ -30,8 +30,8 @@ function! go#cmd#Build(bang, ...) abort
|
|||
\ map(copy(a:000), "expand(v:val)") +
|
||||
\ [".", "errors"]
|
||||
|
||||
" Vim async.
|
||||
if go#util#has_job()
|
||||
" Vim and Neovim async.
|
||||
if go#util#has_job() || has('nvim')
|
||||
if go#config#EchoCommandInfo()
|
||||
call go#util#EchoProgress("building dispatched ...")
|
||||
endif
|
||||
|
|
@ -42,14 +42,6 @@ function! go#cmd#Build(bang, ...) abort
|
|||
\ 'for': 'GoBuild',
|
||||
\})
|
||||
|
||||
" Nvim async.
|
||||
elseif has('nvim')
|
||||
if go#config#EchoCommandInfo()
|
||||
call go#util#EchoProgress("building dispatched ...")
|
||||
endif
|
||||
|
||||
call go#jobcontrol#Spawn(a:bang, "build", "GoBuild", args)
|
||||
|
||||
" Vim 7.4 without async
|
||||
else
|
||||
let default_makeprg = &makeprg
|
||||
|
|
@ -297,44 +289,7 @@ function s:cmd_job(args) abort
|
|||
" autowrite is not enabled for jobs
|
||||
call go#cmd#autowrite()
|
||||
|
||||
function! s:complete(job, exit_status, data) closure abort
|
||||
let status = {
|
||||
\ 'desc': 'last status',
|
||||
\ 'type': a:args.cmd[1],
|
||||
\ 'state': "success",
|
||||
\ }
|
||||
|
||||
if a:exit_status
|
||||
let status.state = "failed"
|
||||
endif
|
||||
|
||||
let elapsed_time = reltimestr(reltime(started_at))
|
||||
" strip whitespace
|
||||
let elapsed_time = substitute(elapsed_time, '^\s*\(.\{-}\)\s*$', '\1', '')
|
||||
let status.state .= printf(" (%ss)", elapsed_time)
|
||||
|
||||
call go#statusline#Update(status_dir, status)
|
||||
endfunction
|
||||
|
||||
let a:args.complete = funcref('s:complete')
|
||||
let callbacks = go#job#Spawn(a:args)
|
||||
|
||||
let start_options = {
|
||||
\ 'callback': callbacks.callback,
|
||||
\ 'exit_cb': callbacks.exit_cb,
|
||||
\ 'close_cb': callbacks.close_cb,
|
||||
\ }
|
||||
|
||||
" pre start
|
||||
let dir = getcwd()
|
||||
let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
|
||||
let jobdir = fnameescape(expand("%:p:h"))
|
||||
execute cd . jobdir
|
||||
|
||||
call job_start(a:args.cmd, start_options)
|
||||
|
||||
" post start
|
||||
execute cd . fnameescape(dir)
|
||||
call go#job#Spawn(a:args.cmd, a:args)
|
||||
endfunction
|
||||
|
||||
" vim: sw=2 ts=2 et
|
||||
|
|
|
|||
|
|
@ -48,12 +48,13 @@ function! go#coverage#Buffer(bang, ...) abort
|
|||
call go#util#EchoProgress("testing...")
|
||||
endif
|
||||
|
||||
if go#util#has_job()
|
||||
if go#util#has_job() || has('nvim')
|
||||
call s:coverage_job({
|
||||
\ 'cmd': ['go', 'test', '-tags', go#config#BuildTags(), '-coverprofile', l:tmpname] + a:000,
|
||||
\ 'complete': function('s:coverage_callback', [l:tmpname]),
|
||||
\ 'bang': a:bang,
|
||||
\ 'for': 'GoTest',
|
||||
\ 'statustype': 'coverage',
|
||||
\ })
|
||||
return
|
||||
endif
|
||||
|
|
@ -63,24 +64,8 @@ function! go#coverage#Buffer(bang, ...) abort
|
|||
call extend(args, a:000)
|
||||
endif
|
||||
|
||||
let disabled_term = 0
|
||||
if go#config#TermEnabled()
|
||||
let disabled_term = 1
|
||||
call go#config#SetTermEnabled(0)
|
||||
endif
|
||||
|
||||
let id = call('go#test#Test', args)
|
||||
|
||||
if disabled_term
|
||||
call go#config#SetTermEnabled(1)
|
||||
endif
|
||||
|
||||
if has('nvim')
|
||||
call go#jobcontrol#AddHandler(function('s:coverage_handler'))
|
||||
let s:coverage_handler_jobs[id] = l:tmpname
|
||||
return
|
||||
endif
|
||||
|
||||
if go#util#ShellError() == 0
|
||||
call go#coverage#overlay(l:tmpname)
|
||||
endif
|
||||
|
|
@ -104,7 +89,7 @@ endfunction
|
|||
" a new HTML coverage page from that profile in a new browser
|
||||
function! go#coverage#Browser(bang, ...) abort
|
||||
let l:tmpname = tempname()
|
||||
if go#util#has_job()
|
||||
if go#util#has_job() || has('nvim')
|
||||
call s:coverage_job({
|
||||
\ 'cmd': ['go', 'test', '-tags', go#config#BuildTags(), '-coverprofile', l:tmpname],
|
||||
\ 'complete': function('s:coverage_browser_callback', [l:tmpname]),
|
||||
|
|
@ -120,11 +105,6 @@ function! go#coverage#Browser(bang, ...) abort
|
|||
endif
|
||||
|
||||
let id = call('go#test#Test', args)
|
||||
if has('nvim')
|
||||
call go#jobcontrol#AddHandler(function('s:coverage_browser_handler'))
|
||||
let s:coverage_browser_handler_jobs[id] = l:tmpname
|
||||
return
|
||||
endif
|
||||
|
||||
if go#util#ShellError() == 0
|
||||
call go#tool#ExecuteInDir(['go', 'tool', 'cover', '-html=' . l:tmpname])
|
||||
|
|
@ -275,48 +255,17 @@ function s:coverage_job(args)
|
|||
" autowrite is not enabled for jobs
|
||||
call go#cmd#autowrite()
|
||||
|
||||
let status_dir = expand('%:p:h')
|
||||
let Complete = a:args.complete
|
||||
function! s:complete(job, exit_status, data) closure
|
||||
let status = {
|
||||
\ 'desc': 'last status',
|
||||
\ 'type': "coverage",
|
||||
\ 'state': "finished",
|
||||
\ }
|
||||
let disabled_term = 0
|
||||
if go#config#TermEnabled()
|
||||
let disabled_term = 1
|
||||
call go#config#SetTermEnabled(0)
|
||||
endif
|
||||
|
||||
if a:exit_status
|
||||
let status.state = "failed"
|
||||
endif
|
||||
call go#job#Spawn(a:args.cmd, a:args)
|
||||
|
||||
call go#statusline#Update(status_dir, status)
|
||||
return Complete(a:job, a:exit_status, a:data)
|
||||
endfunction
|
||||
|
||||
let a:args.complete = funcref('s:complete')
|
||||
let callbacks = go#job#Spawn(a:args)
|
||||
|
||||
let start_options = {
|
||||
\ 'callback': callbacks.callback,
|
||||
\ 'exit_cb': callbacks.exit_cb,
|
||||
\ 'close_cb': callbacks.close_cb,
|
||||
\ }
|
||||
|
||||
" pre start
|
||||
let dir = getcwd()
|
||||
let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
|
||||
let jobdir = fnameescape(expand("%:p:h"))
|
||||
execute cd . jobdir
|
||||
|
||||
call go#statusline#Update(status_dir, {
|
||||
\ 'desc': "current status",
|
||||
\ 'type': "coverage",
|
||||
\ 'state': "started",
|
||||
\})
|
||||
|
||||
call job_start(a:args.cmd, start_options)
|
||||
|
||||
" post start
|
||||
execute cd . fnameescape(dir)
|
||||
if disabled_term
|
||||
call go#config#SetTermEnabled(1)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" coverage_callback is called when the coverage execution is finished
|
||||
|
|
@ -336,39 +285,4 @@ function! s:coverage_browser_callback(coverfile, job, exit_status, data)
|
|||
call delete(a:coverfile)
|
||||
endfunction
|
||||
|
||||
" -----------------------
|
||||
" | Neovim job handlers |
|
||||
" -----------------------
|
||||
|
||||
let s:coverage_handler_jobs = {}
|
||||
let s:coverage_browser_handler_jobs = {}
|
||||
|
||||
function! s:coverage_handler(job, exit_status, data) abort
|
||||
if !has_key(s:coverage_handler_jobs, a:job.id)
|
||||
return
|
||||
endif
|
||||
let l:tmpname = s:coverage_handler_jobs[a:job.id]
|
||||
if a:exit_status == 0
|
||||
call go#coverage#overlay(l:tmpname)
|
||||
endif
|
||||
|
||||
call delete(l:tmpname)
|
||||
unlet s:coverage_handler_jobs[a:job.id]
|
||||
endfunction
|
||||
|
||||
function! s:coverage_browser_handler(job, exit_status, data) abort
|
||||
if !has_key(s:coverage_browser_handler_jobs, a:job.id)
|
||||
return
|
||||
endif
|
||||
|
||||
let l:tmpname = s:coverage_browser_handler_jobs[a:job.id]
|
||||
if a:exit_status == 0
|
||||
call go#tool#ExecuteInDir(['go', 'tool', 'cover', '-html=' . l:tmpname])
|
||||
endif
|
||||
|
||||
call delete(l:tmpname)
|
||||
unlet s:coverage_browser_handler_jobs[a:job.id]
|
||||
endfunction
|
||||
|
||||
|
||||
" vim: sw=2 ts=2 et
|
||||
|
|
|
|||
|
|
@ -26,7 +26,12 @@ function! go#def#Jump(mode) abort
|
|||
endif
|
||||
|
||||
elseif bin_name == 'guru'
|
||||
let cmd = [bin_name, '-tags', go#config#BuildTags()]
|
||||
let cmd = [go#path#CheckBinPath(bin_name)]
|
||||
let buildtags = go#config#BuildTags()
|
||||
if buildtags isnot ''
|
||||
let cmd += ['-tags', buildtags]
|
||||
endif
|
||||
|
||||
let stdin_content = ""
|
||||
|
||||
if &modified
|
||||
|
|
@ -278,13 +283,7 @@ function! go#def#Stack(...) abort
|
|||
endfunction
|
||||
|
||||
function s:def_job(args) abort
|
||||
let callbacks = go#job#Spawn(a:args)
|
||||
|
||||
let start_options = {
|
||||
\ 'callback': callbacks.callback,
|
||||
\ 'exit_cb': callbacks.exit_cb,
|
||||
\ 'close_cb': callbacks.close_cb,
|
||||
\ }
|
||||
let l:start_options = go#job#Options(a:args)
|
||||
|
||||
if &modified
|
||||
let l:tmpname = tempname()
|
||||
|
|
@ -293,7 +292,7 @@ function s:def_job(args) abort
|
|||
let l:start_options.in_name = l:tmpname
|
||||
endif
|
||||
|
||||
call job_start(a:args.cmd, start_options)
|
||||
call go#job#Start(a:args.cmd, start_options)
|
||||
endfunction
|
||||
|
||||
" vim: sw=2 ts=2 et
|
||||
|
|
|
|||
|
|
@ -101,13 +101,29 @@ function! s:root_dirs() abort
|
|||
return dirs
|
||||
endfunction
|
||||
|
||||
function! s:go_packages(dirs) abort
|
||||
function! s:go_packages(dirs, arglead) abort
|
||||
let pkgs = []
|
||||
for d in a:dirs
|
||||
let pkg_root = expand(d . '/pkg/' . go#util#osarch())
|
||||
call extend(pkgs, split(globpath(pkg_root, '**/*.a', 1), "\n"))
|
||||
for dir in a:dirs
|
||||
" this may expand to multiple lines
|
||||
let scr_root = expand(dir . '/src/')
|
||||
for pkg in split(globpath(scr_root, a:arglead.'*'), "\n")
|
||||
if isdirectory(pkg)
|
||||
let pkg .= '/'
|
||||
elseif pkg !~ '\.a$'
|
||||
continue
|
||||
endif
|
||||
|
||||
" without this the result can have duplicates in form of
|
||||
" 'encoding/json' and '/encoding/json/'
|
||||
let pkg = go#util#StripPathSep(pkg)
|
||||
|
||||
" remove the scr root and keep the package in tact
|
||||
let pkg = substitute(pkg, scr_root, "", "")
|
||||
call add(pkgs, pkg)
|
||||
endfor
|
||||
endfor
|
||||
return map(pkgs, "fnamemodify(v:val, ':t:r')")
|
||||
|
||||
return pkgs
|
||||
endfunction
|
||||
|
||||
function! s:interface_list(pkg) abort
|
||||
|
|
@ -124,13 +140,24 @@ endfunction
|
|||
" Complete package and interface for {interface}
|
||||
function! go#impl#Complete(arglead, cmdline, cursorpos) abort
|
||||
let words = split(a:cmdline, '\s\+', 1)
|
||||
|
||||
if words[-1] ==# ''
|
||||
return s:uniq(sort(s:go_packages(s:root_dirs())))
|
||||
elseif words[-1] =~# '^\h\w*$'
|
||||
return s:uniq(sort(filter(s:go_packages(s:root_dirs()), 'stridx(v:val, words[-1]) == 0')))
|
||||
elseif words[-1] =~# '^\h\w*\.\%(\h\w*\)\=$'
|
||||
let [pkg, interface] = split(words[-1], '\.', 1)
|
||||
echomsg pkg
|
||||
" if no words are given, just start completing the first package we found
|
||||
return s:uniq(sort(s:go_packages(s:root_dirs(), a:arglead)))
|
||||
elseif words[-1] =~# '^\(\h\w.*\.\%(\h\w*\)\=$\)\@!\S*$'
|
||||
" start matching go packages. It's negate match of the below match
|
||||
return s:uniq(sort(s:go_packages(s:root_dirs(), a:arglead)))
|
||||
elseif words[-1] =~# '^\h\w.*\.\%(\h\w*\)\=$'
|
||||
" match the following, anything that could indicate an interface candidate
|
||||
"
|
||||
" io.
|
||||
" io.Wr
|
||||
" github.com/fatih/color.
|
||||
" github.com/fatih/color.U
|
||||
" github.com/fatih/color.Un
|
||||
let splitted = split(words[-1], '\.', 1)
|
||||
let pkg = join(splitted[:-2], '.')
|
||||
let interface = splitted[-1]
|
||||
return s:uniq(sort(filter(s:interface_list(pkg), 'v:val =~? words[-1]')))
|
||||
else
|
||||
return []
|
||||
|
|
|
|||
|
|
@ -1,7 +1,25 @@
|
|||
" Spawn returns callbacks to be used with job_start. It is abstracted to be
|
||||
" Spawn starts an asynchronous job. See the description of go#job#Options to
|
||||
" understand the args parameter.
|
||||
"
|
||||
" Spawn returns a job.
|
||||
function! go#job#Spawn(cmd, args)
|
||||
let l:options = go#job#Options(a:args)
|
||||
return go#job#Start(a:cmd, l:options)
|
||||
endfunction
|
||||
|
||||
" Spawn starts an asynchronous job. See the description of go#job#Options to
|
||||
" understand the args parameter.
|
||||
"
|
||||
" Spawn returns a job.
|
||||
function! go#job#Spawn(cmd, args)
|
||||
let l:options = go#job#Options(a:args)
|
||||
return go#job#Start(a:cmd, l:options)
|
||||
endfunction
|
||||
|
||||
" Options returns callbacks to be used with job_start. It is abstracted to be
|
||||
" used with various go commands, such as build, test, install, etc.. This
|
||||
" allows us to avoid writing the same callback over and over for some
|
||||
" commands. It's fully customizable so each command can change it to it's own
|
||||
" commands. It's fully customizable so each command can change it to its own
|
||||
" logic.
|
||||
"
|
||||
" args is a dictionary with the these keys:
|
||||
|
|
@ -10,9 +28,16 @@
|
|||
" 'bang':
|
||||
" Set to 0 to jump to the first error in the error list.
|
||||
" Defaults to 0.
|
||||
" 'statustype':
|
||||
" The status type to use when updating the status.
|
||||
" See statusline.vim.
|
||||
" 'for':
|
||||
" The g:go_list_type_command key to use to get the error list type to use.
|
||||
" Defaults to '_job'
|
||||
" 'errorformat':
|
||||
" The errorformat string to use when parsing errors. Defaults to
|
||||
" &errorformat.
|
||||
" See :help 'errorformat'.
|
||||
" 'complete':
|
||||
" A function to call after the job exits and the channel is closed. The
|
||||
" function will be passed three arguments: the job, its exit code, and the
|
||||
|
|
@ -30,22 +55,28 @@
|
|||
" 'close_cb':
|
||||
" A function suitable to be passed as a job close_cb handler. See
|
||||
" job-close_cb.
|
||||
function go#job#Spawn(args)
|
||||
" 'cwd':
|
||||
" The path to the directory which contains the current buffer.
|
||||
function! go#job#Options(args)
|
||||
let cbs = {}
|
||||
let state = {
|
||||
\ 'winid': win_getid(winnr()),
|
||||
\ 'dir': getcwd(),
|
||||
\ 'jobdir': fnameescape(expand("%:p:h")),
|
||||
\ 'messages': [],
|
||||
\ 'args': a:args.cmd,
|
||||
\ 'bang': 0,
|
||||
\ 'for': "_job",
|
||||
\ 'exited': 0,
|
||||
\ 'exit_status': 0,
|
||||
\ 'closed': 0,
|
||||
\ 'errorformat': &errorformat
|
||||
\ 'errorformat': &errorformat,
|
||||
\ 'statustype' : ''
|
||||
\ }
|
||||
|
||||
if has("patch-8.0.0902") || has('nvim')
|
||||
let cbs.cwd = state.jobdir
|
||||
endif
|
||||
|
||||
if has_key(a:args, 'bang')
|
||||
let state.bang = a:args.bang
|
||||
endif
|
||||
|
|
@ -54,14 +85,78 @@ function go#job#Spawn(args)
|
|||
let state.for = a:args.for
|
||||
endif
|
||||
|
||||
if has_key(a:args, 'statustype')
|
||||
let state.statustype = a:args.statustype
|
||||
endif
|
||||
|
||||
if has_key(a:args, 'errorformat')
|
||||
let state.errorformat = a:args.errorformat
|
||||
endif
|
||||
|
||||
" do nothing in state.complete by default.
|
||||
function state.complete(job, exit_status, data)
|
||||
endfunction
|
||||
|
||||
function state.show_status(job, exit_status) dict
|
||||
if go#config#EchoCommandInfo()
|
||||
let prefix = ""
|
||||
if self.statustype != ''
|
||||
let prefix = '[' . self.statustype . '] '
|
||||
endif
|
||||
if a:exit_status == 0
|
||||
call go#util#EchoSuccess(prefix . "SUCCESS")
|
||||
else
|
||||
call go#util#EchoError(prefix . "FAIL")
|
||||
endif
|
||||
endif
|
||||
|
||||
if self.statustype == ''
|
||||
return
|
||||
endif
|
||||
|
||||
let status = {
|
||||
\ 'desc': 'last status',
|
||||
\ 'type': self.statustype,
|
||||
\ 'state': "success",
|
||||
\ }
|
||||
|
||||
if a:exit_status
|
||||
let status.state = "failed"
|
||||
endif
|
||||
|
||||
if has_key(self, 'started_at')
|
||||
let elapsed_time = reltimestr(reltime(self.started_at))
|
||||
" strip whitespace
|
||||
let elapsed_time = substitute(elapsed_time, '^\s*\(.\{-}\)\s*$', '\1', '')
|
||||
let status.state .= printf(" (%ss)", elapsed_time)
|
||||
endif
|
||||
|
||||
call go#statusline#Update(self.jobdir, status)
|
||||
endfunction
|
||||
|
||||
if has_key(a:args, 'complete')
|
||||
let state.complete = a:args.complete
|
||||
endif
|
||||
|
||||
function! s:start(args) dict
|
||||
if self.statustype != ''
|
||||
let status = {
|
||||
\ 'desc': 'current status',
|
||||
\ 'type': self.statustype,
|
||||
\ 'state': "started",
|
||||
\ }
|
||||
|
||||
call go#statusline#Update(self.jobdir, status)
|
||||
endif
|
||||
let self.started_at = reltime()
|
||||
endfunction
|
||||
" explicitly bind _start to state so that within it, self will
|
||||
" always refer to state. See :help Partial for more information.
|
||||
"
|
||||
" _start is intended only for internal use and should not be referenced
|
||||
" outside of this file.
|
||||
let cbs._start = function('s:start', [''], state)
|
||||
|
||||
function! s:callback(chan, msg) dict
|
||||
call add(self.messages, a:msg)
|
||||
endfunction
|
||||
|
|
@ -73,15 +168,9 @@ function go#job#Spawn(args)
|
|||
let self.exit_status = a:exitval
|
||||
let self.exited = 1
|
||||
|
||||
if go#config#EchoCommandInfo()
|
||||
if a:exitval == 0
|
||||
call go#util#EchoSuccess("SUCCESS")
|
||||
else
|
||||
call go#util#EchoError("FAILED")
|
||||
endif
|
||||
endif
|
||||
call self.show_status(a:job, a:exitval)
|
||||
|
||||
if self.closed
|
||||
if self.closed || has('nvim')
|
||||
call self.complete(a:job, self.exit_status, self.messages)
|
||||
call self.show_errors(a:job, self.exit_status, self.messages)
|
||||
endif
|
||||
|
|
@ -123,14 +212,14 @@ function go#job#Spawn(args)
|
|||
|
||||
let out = join(self.messages, "\n")
|
||||
|
||||
let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
|
||||
let l:cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
|
||||
try
|
||||
" parse the errors relative to self.jobdir
|
||||
execute cd self.jobdir
|
||||
execute l:cd self.jobdir
|
||||
call go#list#ParseFormat(l:listtype, self.errorformat, out, self.for)
|
||||
let errors = go#list#Get(l:listtype)
|
||||
finally
|
||||
execute cd . fnameescape(self.dir)
|
||||
execute l:cd fnameescape(self.dir)
|
||||
endtry
|
||||
|
||||
|
||||
|
|
@ -149,7 +238,178 @@ function go#job#Spawn(args)
|
|||
endif
|
||||
endfunction
|
||||
|
||||
if has('nvim')
|
||||
return s:neooptions(cbs)
|
||||
endif
|
||||
|
||||
return cbs
|
||||
endfunction
|
||||
|
||||
function! go#job#Start(cmd, options)
|
||||
let l:cd = exists('*haslocaldir') && haslocaldir() ? 'lcd' : 'cd'
|
||||
let l:options = copy(a:options)
|
||||
|
||||
if !has_key(l:options, 'cwd')
|
||||
" pre start
|
||||
let dir = getcwd()
|
||||
execute l:cd fnameescape(expand("%:p:h"))
|
||||
endif
|
||||
|
||||
if has_key(l:options, '_start')
|
||||
call l:options._start()
|
||||
" remove _start to play nicely with vim (when vim encounters an unexpected
|
||||
" job option it reports an "E475: invalid argument" error.
|
||||
unlet l:options._start
|
||||
endif
|
||||
|
||||
if has('nvim')
|
||||
let l:input = []
|
||||
if has_key(l:options, 'in_io') && l:options.in_io ==# 'file' && !empty(l:options.in_name)
|
||||
let l:input = readfile(l:options.in_name, 1)
|
||||
endif
|
||||
|
||||
let job = jobstart(a:cmd, l:options)
|
||||
|
||||
if len(l:input) > 0
|
||||
call chansend(job, l:input)
|
||||
" close stdin to signal that no more bytes will be sent.
|
||||
call chanclose(job, 'stdin')
|
||||
endif
|
||||
else
|
||||
let job = job_start(a:cmd, l:options)
|
||||
endif
|
||||
|
||||
if !has_key(l:options, 'cwd')
|
||||
" post start
|
||||
execute l:cd fnameescape(dir)
|
||||
endif
|
||||
|
||||
return job
|
||||
endfunction
|
||||
|
||||
" s:neooptions returns a dictionary of job options suitable for use by Neovim
|
||||
" based on a dictionary of job options suitable for Vim8.
|
||||
function! s:neooptions(options)
|
||||
let l:options = {}
|
||||
let l:options['stdout_buf'] = ''
|
||||
let l:options['stderr_buf'] = ''
|
||||
|
||||
for key in keys(a:options)
|
||||
if key == 'callback'
|
||||
let l:options['callback'] = a:options['callback']
|
||||
|
||||
if !has_key(a:options, 'out_cb')
|
||||
let l:options['stdout_buffered'] = v:true
|
||||
|
||||
function! s:callback2on_stdout(ch, data, event) dict
|
||||
let l:data = a:data
|
||||
let l:data[0] = self.stdout_buf . l:data[0]
|
||||
let self.stdout_buf = ""
|
||||
|
||||
if l:data[-1] != ""
|
||||
let self.stdout_buf = l:data[-1]
|
||||
endif
|
||||
|
||||
let l:data = l:data[:-2]
|
||||
if len(l:data) == 0
|
||||
return
|
||||
endif
|
||||
|
||||
call self.callback(a:ch, join(l:data, "\n"))
|
||||
endfunction
|
||||
let l:options['on_stdout'] = function('s:callback2on_stdout', [], l:options)
|
||||
endif
|
||||
|
||||
if !has_key(a:options, 'err_cb')
|
||||
let l:options['stderr_buffered'] = v:true
|
||||
|
||||
function! s:callback2on_stderr(ch, data, event) dict
|
||||
let l:data = a:data
|
||||
let l:data[0] = self.stderr_buf . l:data[0]
|
||||
let self.stderr_buf = ""
|
||||
|
||||
if l:data[-1] != ""
|
||||
let self.stderr_buf = l:data[-1]
|
||||
endif
|
||||
|
||||
let l:data = l:data[:-2]
|
||||
if len(l:data) == 0
|
||||
return
|
||||
endif
|
||||
|
||||
call self.callback(a:ch, join(l:data, "\n"))
|
||||
endfunction
|
||||
let l:options['on_stderr'] = function('s:callback2on_stderr', [], l:options)
|
||||
endif
|
||||
|
||||
continue
|
||||
endif
|
||||
|
||||
if key == 'out_cb'
|
||||
let l:options['out_cb'] = a:options['out_cb']
|
||||
let l:options['stdout_buffered'] = v:true
|
||||
function! s:on_stdout(ch, data, event) dict
|
||||
let l:data = a:data
|
||||
let l:data[0] = self.stdout_buf . l:data[0]
|
||||
let self.stdout_buf = ""
|
||||
|
||||
if l:data[-1] != ""
|
||||
let self.stdout_buf = l:data[-1]
|
||||
endif
|
||||
|
||||
let l:data = l:data[:-2]
|
||||
if len(l:data) == 0
|
||||
return
|
||||
endif
|
||||
|
||||
call self.out_cb(a:ch, join(l:data, "\n"))
|
||||
endfunction
|
||||
let l:options['on_stdout'] = function('s:on_stdout', [], l:options)
|
||||
|
||||
continue
|
||||
endif
|
||||
|
||||
if key == 'err_cb'
|
||||
let l:options['err_cb'] = a:options['err_cb']
|
||||
let l:options['stderr_buffered'] = v:true
|
||||
function! s:on_stderr(ch, data, event) dict
|
||||
let l:data = a:data
|
||||
let l:data[0] = self.stderr_buf . l:data[0]
|
||||
let self.stderr_buf = ""
|
||||
|
||||
if l:data[-1] != ""
|
||||
let self.stderr_buf = l:data[-1]
|
||||
endif
|
||||
|
||||
let l:data = l:data[:-2]
|
||||
if len(l:data) == 0
|
||||
return
|
||||
endif
|
||||
|
||||
call self.err_cb(a:ch, join(l:data, "\n"))
|
||||
endfunction
|
||||
let l:options['on_stderr'] = function('s:on_stderr', [], l:options)
|
||||
|
||||
continue
|
||||
endif
|
||||
|
||||
if key == 'exit_cb'
|
||||
let l:options['exit_cb'] = a:options['exit_cb']
|
||||
function! s:on_exit(jobid, exitval, event) dict
|
||||
call self.exit_cb(a:jobid, a:exitval)
|
||||
endfunction
|
||||
let l:options['on_exit'] = function('s:on_exit', [], l:options)
|
||||
|
||||
continue
|
||||
endif
|
||||
|
||||
if key == 'close_cb'
|
||||
continue
|
||||
endif
|
||||
|
||||
endfor
|
||||
return l:options
|
||||
endfunction
|
||||
|
||||
|
||||
" vim: sw=2 ts=2 et
|
||||
|
|
|
|||
|
|
@ -1,195 +0,0 @@
|
|||
" s:jobs is a global reference to all jobs started with Spawn() or with the
|
||||
" internal function s:spawn
|
||||
let s:jobs = {}
|
||||
|
||||
" s:handlers is a global event handlers for all jobs started with Spawn() or
|
||||
" with the internal function s:spawn
|
||||
let s:handlers = {}
|
||||
|
||||
" Spawn is a wrapper around s:spawn. It can be executed by other files and
|
||||
" scripts if needed. Desc defines the description for printing the status
|
||||
" during the job execution (useful for statusline integration).
|
||||
function! go#jobcontrol#Spawn(bang, desc, for, args) abort
|
||||
" autowrite is not enabled for jobs
|
||||
call go#cmd#autowrite()
|
||||
|
||||
let job = s:spawn(a:bang, a:desc, a:for, a:args)
|
||||
return job.id
|
||||
endfunction
|
||||
|
||||
" AddHandler adds a on_exit callback handler and returns the id.
|
||||
function! go#jobcontrol#AddHandler(handler) abort
|
||||
let i = len(s:handlers)
|
||||
while has_key(s:handlers, string(i))
|
||||
let i += 1
|
||||
break
|
||||
endwhile
|
||||
let s:handlers[string(i)] = a:handler
|
||||
return string(i)
|
||||
endfunction
|
||||
|
||||
" RemoveHandler removes a callback handler by id.
|
||||
function! go#jobcontrol#RemoveHandler(id) abort
|
||||
unlet s:handlers[a:id]
|
||||
endfunction
|
||||
|
||||
" spawn spawns a go subcommand with the name and arguments with jobstart. Once a
|
||||
" job is started a reference will be stored inside s:jobs. The job is started
|
||||
" inside the current files folder.
|
||||
function! s:spawn(bang, desc, for, args) abort
|
||||
let status_type = a:args[0]
|
||||
let status_dir = expand('%:p:h')
|
||||
let started_at = reltime()
|
||||
|
||||
call go#statusline#Update(status_dir, {
|
||||
\ 'desc': "current status",
|
||||
\ 'type': status_type,
|
||||
\ 'state': "started",
|
||||
\})
|
||||
|
||||
let job = {
|
||||
\ 'desc': a:desc,
|
||||
\ 'bang': a:bang,
|
||||
\ 'winid': win_getid(winnr()),
|
||||
\ 'importpath': go#package#ImportPath(),
|
||||
\ 'state': "RUNNING",
|
||||
\ 'stderr' : [],
|
||||
\ 'stdout' : [],
|
||||
\ 'on_stdout': function('s:on_stdout'),
|
||||
\ 'on_stderr': function('s:on_stderr'),
|
||||
\ 'on_exit' : function('s:on_exit'),
|
||||
\ 'status_type' : status_type,
|
||||
\ 'status_dir' : status_dir,
|
||||
\ 'started_at' : started_at,
|
||||
\ 'for' : a:for,
|
||||
\ 'errorformat': &errorformat,
|
||||
\ }
|
||||
|
||||
" execute go build in the files directory
|
||||
let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
|
||||
|
||||
" cleanup previous jobs for this file
|
||||
for jb in values(s:jobs)
|
||||
if jb.importpath == job.importpath
|
||||
unlet s:jobs[jb.id]
|
||||
endif
|
||||
endfor
|
||||
|
||||
let dir = getcwd()
|
||||
let jobdir = fnameescape(expand("%:p:h"))
|
||||
execute cd . jobdir
|
||||
|
||||
" append the subcommand, such as 'build'
|
||||
let argv = ['go'] + a:args
|
||||
|
||||
" run, forrest, run!
|
||||
let id = jobstart(argv, job)
|
||||
let job.id = id
|
||||
let job.dir = jobdir
|
||||
let s:jobs[id] = job
|
||||
|
||||
execute cd . fnameescape(dir)
|
||||
|
||||
return job
|
||||
endfunction
|
||||
|
||||
" on_exit is the exit handler for jobstart(). It handles cleaning up the job
|
||||
" references and also displaying errors in the quickfix window collected by
|
||||
" on_stderr handler. If there are no errors and a quickfix window is open,
|
||||
" it'll be closed.
|
||||
function! s:on_exit(job_id, exit_status, event) dict abort
|
||||
let l:winid = win_getid(winnr())
|
||||
call win_gotoid(self.winid)
|
||||
|
||||
let status = {
|
||||
\ 'desc': 'last status',
|
||||
\ 'type': self.status_type,
|
||||
\ 'state': "success",
|
||||
\ }
|
||||
|
||||
if a:exit_status
|
||||
let status.state = "failed"
|
||||
endif
|
||||
|
||||
let elapsed_time = reltimestr(reltime(self.started_at))
|
||||
" strip whitespace
|
||||
let elapsed_time = substitute(elapsed_time, '^\s*\(.\{-}\)\s*$', '\1', '')
|
||||
let status.state .= printf(" (%ss)", elapsed_time)
|
||||
|
||||
call go#statusline#Update(self.status_dir, status)
|
||||
|
||||
let std_combined = self.stderr + self.stdout
|
||||
|
||||
let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
|
||||
let dir = getcwd()
|
||||
execute cd self.dir
|
||||
|
||||
call s:callback_handlers_on_exit(s:jobs[a:job_id], a:exit_status, std_combined)
|
||||
|
||||
let l:listtype = go#list#Type(self.for)
|
||||
if a:exit_status == 0
|
||||
call go#list#Clean(l:listtype)
|
||||
|
||||
let self.state = "SUCCESS"
|
||||
|
||||
if go#config#EchoCommandInfo()
|
||||
call go#util#EchoSuccess("[" . self.status_type . "] SUCCESS")
|
||||
endif
|
||||
|
||||
execute cd . fnameescape(dir)
|
||||
call win_gotoid(l:winid)
|
||||
return
|
||||
endif
|
||||
|
||||
let self.state = "FAILED"
|
||||
|
||||
if go#config#EchoCommandInfo()
|
||||
call go#util#EchoError("[" . self.status_type . "] FAILED")
|
||||
endif
|
||||
|
||||
" parse the errors relative to self.jobdir
|
||||
call go#list#ParseFormat(l:listtype, self.errorformat, std_combined, self.for)
|
||||
let errors = go#list#Get(l:listtype)
|
||||
|
||||
execute cd . fnameescape(dir)
|
||||
|
||||
if !len(errors)
|
||||
" failed to parse errors, output the original content
|
||||
call go#util#EchoError(std_combined[0])
|
||||
call win_gotoid(l:winid)
|
||||
return
|
||||
endif
|
||||
|
||||
" if we are still in the same windows show the list
|
||||
if self.winid == l:winid
|
||||
call go#list#Window(l:listtype, len(errors))
|
||||
if !empty(errors) && !self.bang
|
||||
call go#list#JumpToFirst(l:listtype)
|
||||
endif
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" callback_handlers_on_exit runs all handlers for job on exit event.
|
||||
function! s:callback_handlers_on_exit(job, exit_status, data) abort
|
||||
if empty(s:handlers)
|
||||
return
|
||||
endif
|
||||
|
||||
for s:handler in values(s:handlers)
|
||||
call s:handler(a:job, a:exit_status, a:data)
|
||||
endfor
|
||||
endfunction
|
||||
|
||||
" on_stdout is the stdout handler for jobstart(). It collects the output of
|
||||
" stderr and stores them to the jobs internal stdout list.
|
||||
function! s:on_stdout(job_id, data, event) dict abort
|
||||
call extend(self.stdout, a:data)
|
||||
endfunction
|
||||
|
||||
" on_stderr is the stderr handler for jobstart(). It collects the output of
|
||||
" stderr and stores them to the jobs internal stderr list.
|
||||
function! s:on_stderr(job_id, data, event) dict abort
|
||||
call extend(self.stderr, a:data)
|
||||
endfunction
|
||||
|
||||
" vim: sw=2 ts=2 et
|
||||
|
|
@ -34,28 +34,21 @@ function! go#test#Test(bang, compile, ...) abort
|
|||
endif
|
||||
endif
|
||||
|
||||
if go#util#has_job()
|
||||
if go#util#has_job() || has('nvim')
|
||||
" use vim's job functionality to call it asynchronously
|
||||
let job_args = {
|
||||
\ 'cmd': ['go'] + args,
|
||||
let job_options = {
|
||||
\ 'bang': a:bang,
|
||||
\ 'winid': win_getid(winnr()),
|
||||
\ 'dir': getcwd(),
|
||||
\ 'compile_test': a:compile,
|
||||
\ 'jobdir': fnameescape(expand("%:p:h")),
|
||||
\ 'for': 'GoTest',
|
||||
\ 'statustype': 'test',
|
||||
\ 'errorformat': s:errorformat(),
|
||||
\ }
|
||||
|
||||
call s:test_job(job_args)
|
||||
return
|
||||
elseif has('nvim')
|
||||
" use nvims's job functionality
|
||||
if go#config#TermEnabled()
|
||||
let id = go#term#new(a:bang, ["go"] + args)
|
||||
else
|
||||
let id = go#jobcontrol#Spawn(a:bang, "test", "GoTest", args)
|
||||
if a:compile
|
||||
let job_options.statustype = 'compile ' . job_options.statustype
|
||||
endif
|
||||
|
||||
return id
|
||||
call s:test_job(['go'] + args, job_options)
|
||||
return
|
||||
endif
|
||||
|
||||
call go#cmd#autowrite()
|
||||
|
|
@ -129,156 +122,13 @@ function! go#test#Func(bang, ...) abort
|
|||
call call('go#test#Test', args)
|
||||
endfunction
|
||||
|
||||
function! s:test_job(args) abort
|
||||
let status = {
|
||||
\ 'desc': 'current status',
|
||||
\ 'type': "test",
|
||||
\ 'state': "started",
|
||||
\ }
|
||||
|
||||
if a:args.compile_test
|
||||
let status.state = "compiling"
|
||||
endif
|
||||
|
||||
function! s:test_job(cmd, args) abort
|
||||
" autowrite is not enabled for jobs
|
||||
call go#cmd#autowrite()
|
||||
|
||||
let state = {
|
||||
\ 'exited': 0,
|
||||
\ 'closed': 0,
|
||||
\ 'exitval': 0,
|
||||
\ 'messages': [],
|
||||
\ 'args': a:args,
|
||||
\ 'compile_test': a:args.compile_test,
|
||||
\ 'status_dir': expand('%:p:h'),
|
||||
\ 'started_at': reltime()
|
||||
\ }
|
||||
|
||||
call go#statusline#Update(state.status_dir, status)
|
||||
|
||||
function! s:callback(chan, msg) dict
|
||||
call add(self.messages, a:msg)
|
||||
endfunction
|
||||
|
||||
function! s:exit_cb(job, exitval) dict
|
||||
let self.exited = 1
|
||||
let self.exitval = a:exitval
|
||||
|
||||
let status = {
|
||||
\ 'desc': 'last status',
|
||||
\ 'type': "test",
|
||||
\ 'state': "pass",
|
||||
\ }
|
||||
|
||||
if self.compile_test
|
||||
let status.state = "success"
|
||||
endif
|
||||
|
||||
if a:exitval
|
||||
let status.state = "failed"
|
||||
endif
|
||||
|
||||
if go#config#EchoCommandInfo()
|
||||
if a:exitval == 0
|
||||
if self.compile_test
|
||||
call go#util#EchoSuccess("[test] SUCCESS")
|
||||
else
|
||||
call go#util#EchoSuccess("[test] PASS")
|
||||
endif
|
||||
else
|
||||
call go#util#EchoError("[test] FAIL")
|
||||
endif
|
||||
endif
|
||||
|
||||
let elapsed_time = reltimestr(reltime(self.started_at))
|
||||
" strip whitespace
|
||||
let elapsed_time = substitute(elapsed_time, '^\s*\(.\{-}\)\s*$', '\1', '')
|
||||
let status.state .= printf(" (%ss)", elapsed_time)
|
||||
|
||||
call go#statusline#Update(self.status_dir, status)
|
||||
|
||||
if self.closed
|
||||
call s:show_errors(self.args, self.exitval, self.messages)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
function! s:close_cb(ch) dict
|
||||
let self.closed = 1
|
||||
|
||||
if self.exited
|
||||
call s:show_errors(self.args, self.exitval, self.messages)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
" explicitly bind the callbacks to state so that self within them always
|
||||
" refers to state. See :help Partial for more information.
|
||||
let start_options = {
|
||||
\ 'callback': funcref("s:callback", [], state),
|
||||
\ 'exit_cb': funcref("s:exit_cb", [], state),
|
||||
\ 'close_cb': funcref("s:close_cb", [], state)
|
||||
\ }
|
||||
|
||||
" pre start
|
||||
let dir = getcwd()
|
||||
let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
|
||||
let jobdir = fnameescape(expand("%:p:h"))
|
||||
execute cd . jobdir
|
||||
|
||||
call job_start(a:args.cmd, start_options)
|
||||
|
||||
" post start
|
||||
execute cd . fnameescape(dir)
|
||||
call go#job#Spawn(a:cmd, a:args)
|
||||
endfunction
|
||||
|
||||
" show_errors parses the given list of lines of a 'go test' output and returns
|
||||
" a quickfix compatible list of errors. It's intended to be used only for go
|
||||
" test output.
|
||||
function! s:show_errors(args, exit_val, messages) abort
|
||||
let l:winid = win_getid(winnr())
|
||||
|
||||
call win_gotoid(a:args.winid)
|
||||
|
||||
let l:listtype = go#list#Type("GoTest")
|
||||
if a:exit_val == 0
|
||||
call go#list#Clean(l:listtype)
|
||||
call win_gotoid(l:winid)
|
||||
return
|
||||
endif
|
||||
|
||||
" TODO(bc): When messages is JSON, the JSON should be run through a
|
||||
" filter to produce lines that are more easily described by errorformat.
|
||||
|
||||
let l:listtype = go#list#Type("GoTest")
|
||||
|
||||
let cd = exists('*haslocaldir') && haslocaldir() ? 'lcd ' : 'cd '
|
||||
try
|
||||
execute cd a:args.jobdir
|
||||
call go#list#ParseFormat(l:listtype, s:errorformat(), a:messages, join(a:args.cmd))
|
||||
let errors = go#list#Get(l:listtype)
|
||||
finally
|
||||
execute cd . fnameescape(a:args.dir)
|
||||
endtry
|
||||
|
||||
if !len(errors)
|
||||
" failed to parse errors, output the original content
|
||||
call go#util#EchoError(a:messages)
|
||||
call go#util#EchoError(a:args.dir)
|
||||
call win_gotoid(l:winid)
|
||||
return
|
||||
endif
|
||||
|
||||
if a:args.winid != l:winid
|
||||
call win_gotoid(l:winid)
|
||||
return
|
||||
endif
|
||||
|
||||
call go#list#Window(l:listtype, len(errors))
|
||||
if !empty(errors) && !a:args.bang
|
||||
call go#list#JumpToFirst(l:listtype)
|
||||
endif
|
||||
endfunction
|
||||
|
||||
|
||||
let s:efm = ""
|
||||
let s:go_test_show_name = 0
|
||||
|
||||
|
|
|
|||
|
|
@ -89,15 +89,6 @@ func! Test_GoTestTestCompilerError() abort
|
|||
endfunc
|
||||
|
||||
func! s:test(file, expected, ...) abort
|
||||
if has('nvim')
|
||||
" nvim mostly shows test errors correctly, but the the expected errors are
|
||||
" slightly different; buffer numbers are not the same and stderr doesn't
|
||||
" seem to be redirected to the job, so the lines from the panic aren't in
|
||||
" the output to be parsed, and hence are not in the quickfix lists. Once
|
||||
" those two issues are resolved, this early return should be removed so
|
||||
" the tests will run for Neovim, too.
|
||||
return
|
||||
endif
|
||||
let $GOPATH = fnameescape(fnamemodify(getcwd(), ':p')) . 'test-fixtures/test'
|
||||
silent exe 'e ' . $GOPATH . '/src/' . a:file
|
||||
|
||||
|
|
|
|||
|
|
@ -167,13 +167,16 @@ function! go#util#Exec(cmd, ...) abort
|
|||
|
||||
let l:bin = a:cmd[0]
|
||||
|
||||
" Lookup the full path, respecting settings such as 'go_bin_path'. On errors,
|
||||
" CheckBinPath will show a warning for us.
|
||||
let l:bin = go#path#CheckBinPath(l:bin)
|
||||
if empty(l:bin)
|
||||
return ['', 1]
|
||||
endif
|
||||
|
||||
return call('s:exec', [a:cmd] + a:000)
|
||||
" Finally execute the command using the full, resolved path. Do not pass the
|
||||
" unmodified command as the correct program might not exist in $PATH.
|
||||
return call('s:exec', [[l:bin] + a:cmd[1:]] + a:000)
|
||||
endfunction
|
||||
|
||||
function! s:exec(cmd, ...) abort
|
||||
|
|
|
|||
|
|
@ -39,9 +39,23 @@ Vim command sequence: `df[$r,0f,v<C-n>…<C-n>c<CR><Up><Del><Right><Right><Right
|
|||
To see what keystrokes are used for the above examples, see [the wiki page](https://github.com/terryma/vim-multiple-cursors/wiki/Keystrokes-for-example-gifs).
|
||||
|
||||
## Installation
|
||||
Install using [Pathogen], [Vundle], [Neobundle], or your favorite Vim package manager.
|
||||
Install using [Pathogen], [Vundle], [Neobundle], [vim-plug], or your favorite Vim package manager.
|
||||
|
||||
Requires vim 7.4 or later for full functionality.
|
||||
Requires vim 7.4 or newer for full functionality.
|
||||
|
||||
### vim-plug instructions
|
||||
|
||||
1. Paste this block into the top of `~/.vimrc`.
|
||||
|
||||
```vim script
|
||||
call plug#begin()
|
||||
|
||||
Plug 'terryma/vim-multiple-cursors'
|
||||
|
||||
call plug#end()
|
||||
```
|
||||
|
||||
2. Start vim and execute `:PlugInstall`.
|
||||
|
||||
## Quick Start
|
||||
### normal mode / visual mode
|
||||
|
|
@ -213,4 +227,5 @@ Obviously inspired by Sublime Text's [multiple selection][sublime-multiple-selec
|
|||
[Pathogen]:http://github.com/tpope/vim-pathogen
|
||||
[Vundle]:http://github.com/gmarik/vundle
|
||||
[Neobundle]:http://github.com/Shougo/neobundle.vim
|
||||
[vim-plug]:https://github.com/junegunn/vim-plug
|
||||
[emacs-multiple-cursors]:https://github.com/magnars/multiple-cursors.el
|
||||
|
|
|
|||
|
|
@ -9,94 +9,10 @@ ${1:pattern}${2: when ${3:guard}} ->
|
|||
${4:body}
|
||||
endsnippet
|
||||
|
||||
snippet beh "Behaviour Directive" b
|
||||
-behaviour(${1:behaviour}).
|
||||
endsnippet
|
||||
|
||||
snippet case "Case Expression"
|
||||
case ${1:expression} of
|
||||
${2:pattern}${3: when ${4:guard}} ->
|
||||
${5:body}
|
||||
end
|
||||
endsnippet
|
||||
|
||||
snippet def "Define Directive" b
|
||||
-define(${1:macro}${2: (${3:param})}, ${4:body}).
|
||||
endsnippet
|
||||
|
||||
snippet exp "Export Directive" b
|
||||
-export([${1:function}/${2:arity}]).
|
||||
endsnippet
|
||||
|
||||
snippet fun "Fun Expression"
|
||||
fun
|
||||
(${1:pattern})${2: when ${3:guard}} ->
|
||||
${4:body}
|
||||
end
|
||||
endsnippet
|
||||
|
||||
snippet fu "Function"
|
||||
${1:function}(${2:param})${3: when ${4:guard}} ->
|
||||
${5:body}
|
||||
endsnippet
|
||||
|
||||
snippet if "If Expression"
|
||||
if
|
||||
${1:guard} ->
|
||||
${2:body}
|
||||
end
|
||||
endsnippet
|
||||
|
||||
snippet ifdef "Ifdef Directive" b
|
||||
-ifdef(${1:macro}).
|
||||
endsnippet
|
||||
|
||||
snippet ifndef "Ifndef Directive" b
|
||||
-ifndef(${1:macro}).
|
||||
endsnippet
|
||||
|
||||
snippet imp "Import Directive" b
|
||||
-import(${1:module}, [${2:function}/${3:arity}]).
|
||||
endsnippet
|
||||
|
||||
snippet inc "Include Directive" b
|
||||
-include("${1:file}").
|
||||
endsnippet
|
||||
|
||||
snippet mod "Module Directive" b
|
||||
-module(${1:`!p snip.rv = snip.basename or "module"`}).
|
||||
endsnippet
|
||||
|
||||
snippet rcv "Receive Expression"
|
||||
receive
|
||||
${1: ${2:pattern}${3: when ${4:guard}} ->
|
||||
${5:body}}
|
||||
${6:after
|
||||
${7:expression} ->
|
||||
${8:body}}
|
||||
end
|
||||
endsnippet
|
||||
|
||||
snippet rec "Record Directive" b
|
||||
-record(${1:record}, {${2:field}${3: = ${4:value}}}).
|
||||
endsnippet
|
||||
|
||||
snippet try "Try Expression"
|
||||
try${1: ${2:expression}${3: of
|
||||
${4:pattern}${5: when ${6:guard}} ->
|
||||
${7:body}}}
|
||||
${8:catch
|
||||
${9:pattern}${10: when ${11:guard}} ->
|
||||
${12:body}}
|
||||
${13:after
|
||||
${14:body}}
|
||||
end
|
||||
endsnippet
|
||||
|
||||
snippet undef "Undef Directive" b
|
||||
-undef(${1:macro}).
|
||||
endsnippet
|
||||
|
||||
snippet || "List Comprehension"
|
||||
[${1:X} || ${2:X} <- ${3:List}${4:, gen}]
|
||||
endsnippet
|
||||
|
|
|
|||
|
|
@ -50,6 +50,23 @@ snippet spar "Paragraph" b
|
|||
$0
|
||||
endsnippet
|
||||
|
||||
###################
|
||||
# Text formatting #
|
||||
###################
|
||||
|
||||
snippet * "italics"
|
||||
*${1:${VISUAL}}*$0
|
||||
endsnippet
|
||||
|
||||
snippet ** "bold"
|
||||
**${1:${VISUAL}}**$0
|
||||
endsnippet
|
||||
|
||||
snippet *** "bold italics"
|
||||
***${1:${VISUAL}}***$0
|
||||
endsnippet
|
||||
|
||||
|
||||
################
|
||||
# Common stuff #
|
||||
################
|
||||
|
|
|
|||
|
|
@ -7,10 +7,10 @@ endsnippet
|
|||
|
||||
snippet t "Simple tag" b
|
||||
<${1:tag}>
|
||||
${2:content}
|
||||
${2:${VISUAL}}
|
||||
</${1/([\w:._-]+).*/$1/}>
|
||||
endsnippet
|
||||
|
||||
snippet ti "Inline tag" b
|
||||
<${1:tag}>${2:content}</${1/([\w:._-]+).*/$1/}>
|
||||
<${1:tag}>${2:${VISUAL}}</${1/([\w:._-]+).*/$1/}>
|
||||
endsnippet
|
||||
|
|
|
|||
|
|
@ -5,12 +5,16 @@ snippet mod
|
|||
snippet modall
|
||||
-module(${1:`vim_snippets#Filename()`}).
|
||||
-compile([export_all]).
|
||||
|
||||
|
||||
start() ->
|
||||
${0}
|
||||
|
||||
|
||||
stop() ->
|
||||
ok.
|
||||
snippet d
|
||||
erlang:display(${0}),
|
||||
snippet dt
|
||||
erlang:display({${1}, ${0}}),
|
||||
# define directive
|
||||
snippet def
|
||||
-define(${1:macro}, ${2:body}).
|
||||
|
|
@ -30,17 +34,23 @@ snippet ifd
|
|||
-ifdef(${1:TEST}).
|
||||
${0}
|
||||
-endif.
|
||||
snippet ifnd
|
||||
-ifndef(${1:TEST}).
|
||||
${0}
|
||||
-endif.
|
||||
snippet undef
|
||||
-undef(${1:macro}).
|
||||
# if expression
|
||||
snippet if
|
||||
if
|
||||
${1:guard} ->
|
||||
${0:body}
|
||||
${1:guard} ->
|
||||
${0:body}
|
||||
end
|
||||
# case expression
|
||||
snippet case
|
||||
case ${1:expression} of
|
||||
${2:pattern} ->
|
||||
${0:body};
|
||||
${2:pattern} ->
|
||||
${0:body};
|
||||
end
|
||||
# anonymous function
|
||||
snippet fun
|
||||
|
|
@ -48,14 +58,21 @@ snippet fun
|
|||
# try...catch
|
||||
snippet try
|
||||
try
|
||||
${1:${VISUAL}}
|
||||
${1:${VISUAL}}
|
||||
catch
|
||||
${2:_:_} -> ${0:got_some_exception}
|
||||
${2:_:_} -> ${0:got_some_exception}
|
||||
end
|
||||
snippet rcv "Receive Expression"
|
||||
receive
|
||||
${1: ${2:pattern}${3: when ${4:guard}} ->
|
||||
${5:body}}
|
||||
${6:after
|
||||
${7:expression} ->
|
||||
${8:body}}
|
||||
end
|
||||
# record directive
|
||||
snippet rec
|
||||
-record(${1:record}, {
|
||||
${2:field}=${3:value}}).
|
||||
-record(${1:record}, {${2:field}=${3:value}}).
|
||||
# todo comment
|
||||
snippet todo
|
||||
%% TODO: ${0}
|
||||
|
|
@ -82,15 +99,15 @@ snippet application
|
|||
-export([start/2, stop/1]).
|
||||
|
||||
start(_Type, _StartArgs) ->
|
||||
case ${0:root_supervisor}:start_link() of
|
||||
{ok, Pid} ->
|
||||
{ok, Pid};
|
||||
Other ->
|
||||
{error, Other}
|
||||
end.
|
||||
case ${0:root_supervisor}:start_link() of
|
||||
{ok, Pid} ->
|
||||
{ok, Pid};
|
||||
Other ->
|
||||
{error, Other}
|
||||
end.
|
||||
|
||||
stop(_State) ->
|
||||
ok.
|
||||
ok.
|
||||
# OTP supervisor
|
||||
snippet supervisor
|
||||
-module(${1:`vim_snippets#Filename()`}).
|
||||
|
|
@ -106,14 +123,14 @@ snippet supervisor
|
|||
-define(SERVER, ?MODULE).
|
||||
|
||||
start_link() ->
|
||||
supervisor:start_link({local, ?SERVER}, ?MODULE, []).
|
||||
supervisor:start_link({local, ?SERVER}, ?MODULE, []).
|
||||
|
||||
init([]) ->
|
||||
Server = {${0:my_server}, {${2}, start_link, []},
|
||||
permanent, 2000, worker, [${2}]},
|
||||
Children = [Server],
|
||||
RestartStrategy = {one_for_one, 0, 1},
|
||||
{ok, {RestartStrategy, Children}}.
|
||||
Server = {${0:my_server}, {${2}, start_link, []},
|
||||
permanent, 2000, worker, [${2}]},
|
||||
Children = [Server],
|
||||
RestartStrategy = {one_for_one, 0, 1},
|
||||
{ok, {RestartStrategy, Children}}.
|
||||
# OTP gen_server
|
||||
snippet gen_server
|
||||
-module(${0:`vim_snippets#Filename()`}).
|
||||
|
|
@ -121,17 +138,10 @@ snippet gen_server
|
|||
-behaviour(gen_server).
|
||||
|
||||
%% API
|
||||
-export([
|
||||
start_link/0
|
||||
]).
|
||||
-export([start_link/0]).
|
||||
|
||||
%% gen_server callbacks
|
||||
-export([init/1,
|
||||
handle_call/3,
|
||||
handle_cast/2,
|
||||
handle_info/2,
|
||||
terminate/2,
|
||||
code_change/3]).
|
||||
-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
|
||||
|
||||
-define(SERVER, ?MODULE).
|
||||
|
||||
|
|
@ -142,30 +152,30 @@ snippet gen_server
|
|||
%%%===================================================================
|
||||
|
||||
start_link() ->
|
||||
gen_server:start_link({local, ?SERVER}, ?MODULE, [], []).
|
||||
gen_server:start_link({local, ?SERVER}, ?MODULE, [], []).
|
||||
|
||||
%%%===================================================================
|
||||
%%% gen_server callbacks
|
||||
%%%===================================================================
|
||||
|
||||
init([]) ->
|
||||
{ok, #state{}}.
|
||||
{ok, #state{}}.
|
||||
|
||||
handle_call(_Request, _From, State) ->
|
||||
Reply = ok,
|
||||
{reply, Reply, State}.
|
||||
Reply = ok,
|
||||
{reply, Reply, State}.
|
||||
|
||||
handle_cast(_Msg, State) ->
|
||||
{noreply, State}.
|
||||
{noreply, State}.
|
||||
|
||||
handle_info(_Info, State) ->
|
||||
{noreply, State}.
|
||||
{noreply, State}.
|
||||
|
||||
terminate(_Reason, _State) ->
|
||||
ok.
|
||||
ok.
|
||||
|
||||
code_change(_OldVsn, State, _Extra) ->
|
||||
{ok, State}.
|
||||
{ok, State}.
|
||||
|
||||
%%%===================================================================
|
||||
%%% Internal functions
|
||||
|
|
@ -180,14 +190,8 @@ snippet gen_fsm
|
|||
-export([start_link/0]).
|
||||
|
||||
%% gen_fsm callbacks
|
||||
-export([init/1,
|
||||
state_name/2,
|
||||
state_name/3,
|
||||
handle_event/3,
|
||||
handle_sync_event/4,
|
||||
handle_info/3,
|
||||
terminate/3,
|
||||
code_change/4]).
|
||||
-export([init/1, state_name/2, state_name/3, handle_event/3, handle_sync_event/4,
|
||||
handle_info/3, terminate/3, code_change/4]).
|
||||
|
||||
-record(state, {}).
|
||||
|
||||
|
|
@ -356,15 +360,15 @@ snippet gen_event
|
|||
|
||||
%% API
|
||||
-export([start_link/0,
|
||||
add_handler/2]).
|
||||
add_handler/2]).
|
||||
|
||||
%% gen_event callbacks
|
||||
-export([init/1,
|
||||
handle_event/2,
|
||||
handle_call/2,
|
||||
handle_info/2,
|
||||
terminate/2,
|
||||
code_change/3]).
|
||||
handle_event/2,
|
||||
handle_call/2,
|
||||
handle_info/2,
|
||||
terminate/2,
|
||||
code_change/3]).
|
||||
|
||||
-record(state, {}).
|
||||
|
||||
|
|
@ -497,6 +501,16 @@ snippet ieunit
|
|||
${0}
|
||||
|
||||
-endif.
|
||||
snippet itest
|
||||
-ifdef(TEST).
|
||||
|
||||
${1}_test() ->
|
||||
${0}
|
||||
|
||||
-endif.
|
||||
snippet test
|
||||
${1}_test() ->
|
||||
${0}
|
||||
snippet as
|
||||
?assert(${0})
|
||||
snippet asn
|
||||
|
|
@ -523,9 +537,9 @@ snippet testsuite
|
|||
|
||||
%% Test server callbacks
|
||||
-export([suite/0, all/0, groups/0,
|
||||
init_per_suite/1, end_per_suite/1,
|
||||
init_per_group/2, end_per_group/2,
|
||||
init_per_testcase/2, end_per_testcase/2]).
|
||||
init_per_suite/1, end_per_suite/1,
|
||||
init_per_group/2, end_per_group/2,
|
||||
init_per_testcase/2, end_per_testcase/2]).
|
||||
|
||||
%% Test cases
|
||||
-export([
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
extends typescript
|
||||
Loading…
Add table
Reference in a new issue