365 lines
9.0 KiB
Plaintext
365 lines
9.0 KiB
Plaintext
Before:
|
|
Save g:ale_run_synchronously
|
|
|
|
let g:ale_run_synchronously = 1
|
|
unlet! g:ale_run_synchronously_callbacks
|
|
|
|
runtime autoload/ale/lsp.vim
|
|
runtime autoload/ale/lsp_linter.vim
|
|
runtime autoload/ale/engine.vim
|
|
runtime autoload/ale/job.vim
|
|
runtime autoload/ale/socket.vim
|
|
|
|
let g:job_map = {}
|
|
let g:emulate_job_failure = 0
|
|
let g:next_job_id = 1
|
|
|
|
let g:socket_map = {}
|
|
let g:emulate_socket_failure = 0
|
|
let g:next_channel_id = 0
|
|
|
|
let g:message_buffer = ''
|
|
let g:calls = []
|
|
|
|
function! ale#engine#IsExecutable(buffer, executable) abort
|
|
return !empty(a:executable)
|
|
endfunction
|
|
|
|
function! ale#job#HasOpenChannel(job_id) abort
|
|
return has_key(g:job_map, a:job_id)
|
|
endfunction
|
|
|
|
function! ale#job#Stop(job_id) abort
|
|
if has_key(g:job_map, a:job_id)
|
|
call remove(g:job_map, a:job_id)
|
|
endif
|
|
endfunction
|
|
|
|
function! ale#job#Start(command, options) abort
|
|
if g:emulate_job_failure
|
|
return 0
|
|
endif
|
|
|
|
let l:job_id = g:next_job_id
|
|
let g:next_job_id += 1
|
|
let g:job_map[l:job_id] = [a:command, a:options]
|
|
|
|
return l:job_id
|
|
endfunction
|
|
|
|
function! ale#job#SendRaw(job_id, data) abort
|
|
let g:message_buffer .= a:data
|
|
endfunction
|
|
|
|
function! ale#socket#IsOpen(channel_id) abort
|
|
return has_key(g:socket_map, a:channel_id)
|
|
endfunction
|
|
|
|
function! ale#socket#Close(channel_id) abort
|
|
if has_key(g:socket_map, a:channel_id)
|
|
call remove(g:socket_map, a:channel_id)
|
|
endif
|
|
endfunction
|
|
|
|
function! ale#socket#Open(address, options) abort
|
|
if g:emulate_socket_failure
|
|
return -1
|
|
endif
|
|
|
|
let l:channel_id = g:next_channel_id
|
|
let g:next_channel_id += 1
|
|
let g:socket_map[l:channel_id] = [a:address, a:options]
|
|
|
|
return l:channel_id
|
|
endfunction
|
|
|
|
function! ale#socket#Send(channel_id, data) abort
|
|
let g:message_buffer .= a:data
|
|
endfunction
|
|
|
|
function! PopMessages() abort
|
|
let l:message_list = []
|
|
|
|
for l:line in split(g:message_buffer, '\(\r\|\n\|Content-Length\)\+')
|
|
if l:line[:0] is '{'
|
|
let l:data = json_decode(l:line)
|
|
|
|
call add(l:message_list, l:data)
|
|
endif
|
|
endfor
|
|
|
|
let g:message_buffer = ''
|
|
|
|
return l:message_list
|
|
endfunction
|
|
|
|
function! SendMessage(message) abort
|
|
let l:conn_id = keys(ale#lsp#GetConnections())[0]
|
|
let l:body = json_encode(a:message)
|
|
let l:data = 'Content-Length: ' . strlen(l:body) . "\r\n\r\n" . l:body
|
|
|
|
call ale#lsp#HandleMessage(l:conn_id, l:data)
|
|
endfunction
|
|
|
|
function! Start() abort
|
|
let l:linter = values(ale#linter#GetLintersLoaded())[0][0]
|
|
|
|
return ale#lsp_linter#StartLSP(
|
|
\ bufnr(''),
|
|
\ l:linter,
|
|
\ {linter, details -> add(g:calls, [linter.name, details])},
|
|
\)
|
|
endfunction
|
|
|
|
function! AssertInitSuccess(linter_name, conn_prefix, language, root, command) abort
|
|
let l:messages = PopMessages()
|
|
|
|
if a:linter_name is# 'tsserver'
|
|
AssertEqual
|
|
\ [
|
|
\ {
|
|
\ 'seq': v:null,
|
|
\ 'arguments': {
|
|
\ 'file': expand('%:p'),
|
|
\ },
|
|
\ 'type': 'request',
|
|
\ 'command': 'open',
|
|
\ },
|
|
\ ],
|
|
\ l:messages
|
|
else
|
|
AssertEqual
|
|
\ [
|
|
\ {
|
|
\ 'method': 'initialize',
|
|
\ 'jsonrpc': '2.0',
|
|
\ 'id': 1,
|
|
\ 'params': {
|
|
\ 'initializationOptions': {},
|
|
\ 'rootUri': ale#path#ToURI(a:root),
|
|
\ 'capabilities': {},
|
|
\ 'rootPath': a:root,
|
|
\ 'processId': getpid(),
|
|
\ },
|
|
\ },
|
|
\ ],
|
|
\ l:messages
|
|
|
|
call SendMessage({
|
|
\ 'jsonrpc': '2.0',
|
|
\ 'id': 1,
|
|
\ 'result': {
|
|
\ 'capabilities': {
|
|
\ 'renameProvider': v:true,
|
|
\ 'executeCommandProvider': {
|
|
\ 'commands': [],
|
|
\ },
|
|
\ 'hoverProvider': v:true,
|
|
\ 'documentSymbolProvider': v:true,
|
|
\ 'documentRangeFormattingProvider': v:true,
|
|
\ 'codeLensProvider': {
|
|
\ 'resolveProvider': v:false
|
|
\ },
|
|
\ 'referencesProvider': v:true,
|
|
\ 'textDocumentSync': 2,
|
|
\ 'documentFormattingProvider': v:true,
|
|
\ 'codeActionProvider': v:true,
|
|
\ 'signatureHelpProvider': {
|
|
\ 'triggerCharacters': ['(', ','],
|
|
\ },
|
|
\ 'completionProvider': {
|
|
\ 'triggerCharacters': ['.'],
|
|
\ 'resolveProvider': v:false
|
|
\ },
|
|
\ 'definitionProvider': v:true,
|
|
\ 'experimental': {},
|
|
\ 'documentHighlightProvider': v:true,
|
|
\ 'workspaceSymbolProvider': v:true,
|
|
\ },
|
|
\ },
|
|
\})
|
|
|
|
let l:messages = PopMessages()
|
|
|
|
AssertEqual
|
|
\ [
|
|
\ {
|
|
\ 'method': 'initialized',
|
|
\ 'jsonrpc': '2.0',
|
|
\ 'params': {},
|
|
\ },
|
|
\ {
|
|
\ 'method': 'textDocument/didOpen',
|
|
\ 'jsonrpc': '2.0',
|
|
\ 'params': {
|
|
\ 'textDocument': {
|
|
\ 'uri': ale#path#ToURI(expand('%:p')),
|
|
\ 'version': ale#lsp#message#GetNextVersionID() - 1,
|
|
\ 'languageId': a:language,
|
|
\ 'text': "\n",
|
|
\ },
|
|
\ },
|
|
\ },
|
|
\ ],
|
|
\ l:messages
|
|
endif
|
|
|
|
AssertEqual
|
|
\ [
|
|
\ [
|
|
\ a:linter_name,
|
|
\ {
|
|
\ 'connection_id': a:conn_prefix . ':' . a:root,
|
|
\ 'project_root': a:root,
|
|
\ 'buffer': bufnr(''),
|
|
\ 'command': !empty(a:command) ? ale#job#PrepareCommand(bufnr(''), a:command) : '',
|
|
\ },
|
|
\ ],
|
|
\ ],
|
|
\ g:calls
|
|
endfunction
|
|
|
|
function! AssertInitFailure() abort
|
|
let l:messages = PopMessages()
|
|
|
|
AssertEqual [], l:messages
|
|
AssertEqual [], g:calls
|
|
endfunction
|
|
|
|
call ale#linter#Reset()
|
|
|
|
After:
|
|
Restore
|
|
|
|
call ale#linter#Reset()
|
|
call ale#lsp#ResetConnections()
|
|
|
|
unlet! g:job_map
|
|
unlet! g:emulate_job_failure
|
|
unlet! g:next_job_id
|
|
|
|
unlet! g:socket_map
|
|
unlet! g:emulate_socket_failure
|
|
unlet! g:next_channel_id
|
|
|
|
unlet! g:message_buffer
|
|
unlet! g:calls
|
|
|
|
delfunction PopMessages
|
|
delfunction Start
|
|
delfunction AssertInitSuccess
|
|
delfunction AssertInitFailure
|
|
|
|
runtime autoload/ale/engine.vim
|
|
runtime autoload/ale/job.vim
|
|
runtime autoload/ale/socket.vim
|
|
|
|
Execute(tsserver should be started correctly):
|
|
runtime ale_linters/typescript/tsserver.vim
|
|
|
|
Assert Start()
|
|
call AssertInitSuccess('tsserver', 'tsserver', '', '', ale#Escape('tsserver'))
|
|
|
|
Execute(tsserver failures should be handled appropriately):
|
|
runtime ale_linters/typescript/tsserver.vim
|
|
|
|
let g:emulate_job_failure = 1
|
|
|
|
Assert !Start()
|
|
call AssertInitFailure()
|
|
|
|
Execute(LSP jobs should start correctly):
|
|
call ale#linter#Define('foobar', {
|
|
\ 'name': 'foo',
|
|
\ 'lsp': 'stdio',
|
|
\ 'executable': 'foo',
|
|
\ 'command': 'foo',
|
|
\ 'project_root': '/foo/bar',
|
|
\ 'initialization_options': {},
|
|
\})
|
|
|
|
Assert Start()
|
|
call AssertInitSuccess('foo', 'foo', 'foobar', '/foo/bar', 'foo')
|
|
|
|
Execute(LSP job failures should be handled):
|
|
call ale#linter#Define('foobar', {
|
|
\ 'name': 'foo',
|
|
\ 'lsp': 'stdio',
|
|
\ 'executable': 'foo',
|
|
\ 'command': 'foo',
|
|
\ 'project_root': '/foo/bar',
|
|
\ 'initialization_options': {},
|
|
\})
|
|
|
|
let g:emulate_job_failure = 1
|
|
|
|
Assert !Start()
|
|
call AssertInitFailure()
|
|
|
|
Execute(LSP TCP connections should start correctly):
|
|
call ale#linter#Define('foobar', {
|
|
\ 'name': 'foo',
|
|
\ 'lsp': 'socket',
|
|
\ 'address': 'foo',
|
|
\ 'project_root': '/foo/bar',
|
|
\ 'initialization_options': {},
|
|
\})
|
|
|
|
Assert Start()
|
|
call AssertInitSuccess('foo', 'foo', 'foobar', '/foo/bar', '')
|
|
|
|
Execute(LSP TCP connection failures should be handled):
|
|
call ale#linter#Define('foobar', {
|
|
\ 'name': 'foo',
|
|
\ 'lsp': 'socket',
|
|
\ 'address': 'foo',
|
|
\ 'project_root': '/foo/bar',
|
|
\ 'initialization_options': {},
|
|
\})
|
|
|
|
let g:emulate_socket_failure = 1
|
|
|
|
Assert !Start()
|
|
call AssertInitFailure()
|
|
|
|
Execute(Deferred executables should be handled correctly):
|
|
call ale#linter#Define('foobar', {
|
|
\ 'name': 'foo',
|
|
\ 'lsp': 'stdio',
|
|
\ 'executable': {b -> ale#command#Run(b, 'echo', {-> 'foo'})},
|
|
\ 'command': '%e -c',
|
|
\ 'project_root': '/foo/bar',
|
|
\ 'initialization_options': {},
|
|
\})
|
|
|
|
Assert Start()
|
|
call ale#test#FlushJobs()
|
|
call AssertInitSuccess('foo', 'foo', 'foobar', '/foo/bar', ale#Escape('foo') . ' -c')
|
|
|
|
Execute(Deferred commands should be handled correctly):
|
|
call ale#linter#Define('foobar', {
|
|
\ 'name': 'foo',
|
|
\ 'lsp': 'stdio',
|
|
\ 'executable': 'foo',
|
|
\ 'command': {b -> ale#command#Run(b, 'echo', {-> '%e -c'})},
|
|
\ 'project_root': '/foo/bar',
|
|
\ 'initialization_options': {},
|
|
\})
|
|
|
|
Assert Start()
|
|
call ale#test#FlushJobs()
|
|
call AssertInitSuccess('foo', 'foo', 'foobar', '/foo/bar', ale#Escape('foo') . ' -c')
|
|
|
|
Execute(Deferred addresses should be handled correctly):
|
|
call ale#linter#Define('foobar', {
|
|
\ 'name': 'foo',
|
|
\ 'lsp': 'socket',
|
|
\ 'address': {b -> ale#command#Run(b, 'echo', {-> 'localhost:1234'})},
|
|
\ 'project_root': '/foo/bar',
|
|
\ 'initialization_options': {},
|
|
\})
|
|
|
|
Assert Start()
|
|
call ale#test#FlushJobs()
|
|
call AssertInitSuccess('foo', 'localhost:1234', 'foobar', '/foo/bar', '')
|