RepoMirrors
/
ale
mirror of https://github.com/dense-analysis/ale
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

#107 Stop jobs when buffers close

This commit is contained in:
w0rp 2016-10-23 22:41:00 +01:00
parent 36461b69d7
commit 7481facd73
9 changed files with 161 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
autoload/ale.vim
View File

@ -27,8 +27,11 @@ function! ale#Lint(...) abort
let l:buffer = bufnr('%')
let l:linters = ale#linter#Get(&filetype)
" Initialise the buffer information if needed.
call ale#engine#InitBufferInfo(l:buffer)
" Set a variable telling us to clear the loclist later.
let g:ale_buffer_should_reset_map[l:buffer] = 1
let g:ale_buffer_info[l:buffer].should_reset = 1
for l:linter in l:linters
" Check if a given linter has a program which can be executed.

15
autoload/ale/cleanup.vim
View File

@ -2,19 +2,16 @@
" Description: Utility functions related to cleaning state.
function! ale#cleanup#Buffer(buffer) abort
if has_key(g:ale_buffer_count_map, a:buffer)
call remove(g:ale_buffer_count_map, a:buffer)
endif
if has_key(g:ale_buffer_loclist_map, a:buffer)
call remove(g:ale_buffer_loclist_map, a:buffer)
endif
if has_key(g:ale_buffer_should_reset_map, a:buffer)
call remove(g:ale_buffer_should_reset_map, a:buffer)
endif
if has_key(g:ale_buffer_info, a:buffer)
" When buffers are removed, clear all of the jobs.
for l:job in get(g:ale_buffer_info[a:buffer], 'job_list', [])
call ale#engine#ClearJob(l:job)
endfor
if has_key(g:ale_buffer_sign_dummy_map, a:buffer)
call remove(g:ale_buffer_sign_dummy_map, a:buffer)
call remove(g:ale_buffer_info, a:buffer)
endif
endfunction

60
autoload/ale/engine.vim
View File

@ -20,7 +20,17 @@ function! s:GetJobID(job) abort
return ch_info(job_getchannel(a:job)).id
endfunction
function! s:ClearJob(job) abort
function! ale#engine#InitBufferInfo(buffer) abort
if !has_key(g:ale_buffer_info, a:buffer)
let g:ale_buffer_info[a:buffer] = {
\ 'job_list': [],
\ 'should_reset': 1,
\ 'dummy_sign_set': 0,
\}
endif
endfunction
function! ale#engine#ClearJob(job) abort
let l:job_id = s:GetJobID(a:job)
let l:linter = s:job_info_map[l:job_id].linter
@ -37,7 +47,26 @@ function! s:ClearJob(job) abort
endif
call remove(s:job_info_map, l:job_id)
call remove(l:linter, 'job')
endfunction
function! s:StopPreviousJobs(buffer, linter) abort
let l:new_job_list = []
for l:job in g:ale_buffer_info[a:buffer].job_list
let l:job_id = s:GetJobID(l:job)
if has_key(s:job_info_map, l:job_id)
\&& s:job_info_map[l:job_id].linter.name ==# a:linter.name
" Stop jobs which match the buffer and linter.
call ale#engine#ClearJob(l:job)
else
" Keep other jobs in the list.
call add(l:new_job_list, l:job)
endif
endfor
" Update the list, removing the previously run job.
let g:ale_buffer_info[a:buffer].job_list = l:new_job_list
endfunction
function! s:GatherOutput(job, data) abort
@ -71,17 +100,11 @@ function! s:HandleExit(job) abort
endif
let l:job_info = s:job_info_map[l:job_id]
call s:ClearJob(a:job)
let l:linter = l:job_info.linter
let l:output = l:job_info.output
let l:buffer = l:job_info.buffer
if !has_key(g:ale_buffer_should_reset_map, l:buffer)
" A job ended for a buffer which has been closed, so stop here.
return
endif
call s:StopPreviousJobs(l:buffer, l:linter)
let l:linter_loclist = ale#util#GetFunction(l:linter.callback)(l:buffer, l:output)
@ -92,8 +115,10 @@ function! s:HandleExit(job) abort
let l:item.linter_name = l:linter.name
endfor
if g:ale_buffer_should_reset_map[l:buffer]
let g:ale_buffer_should_reset_map[l:buffer] = 0
if g:ale_buffer_info[l:buffer].should_reset
" Set the flag for resetting the loclist to 0 again, so we won't
" empty the list later.
let g:ale_buffer_info[l:buffer].should_reset = 0
let g:ale_buffer_loclist_map[l:buffer] = []
endif
@ -150,10 +175,8 @@ function! s:FixLocList(buffer, loclist) abort
endfunction
function! ale#engine#Invoke(buffer, linter) abort
if has_key(a:linter, 'job')
" Stop previous jobs for the same linter.
call s:ClearJob(a:linter.job)
endif
" Stop previous jobs for the same linter.
call s:StopPreviousJobs(a:buffer, a:linter)
if has_key(a:linter, 'command_callback')
" If there is a callback for generating a command, call that instead.
@ -227,7 +250,8 @@ function! ale#engine#Invoke(buffer, linter) abort
" Only proceed if the job is being run.
if has('nvim') || (l:job !=# 'no process' && job_status(l:job) ==# 'run')
let a:linter.job = l:job
" Add the job to the list of jobs, so we can track them.
call add(g:ale_buffer_info[a:buffer].job_list, l:job)
" Store the ID for the job in the map to read back again.
let s:job_info_map[s:GetJobID(l:job)] = {
@ -270,8 +294,8 @@ function! ale#engine#WaitForJobs(deadline) abort
let l:job_list = []
for l:job_id in keys(s:job_info_map)
call add(l:job_list, s:job_info_map[l:job_id].linter.job)
for l:info in values(g:ale_buffer_info)
call extend(l:job_list, l:info.job_list)
endfor
let l:should_wait_more = 1

8
autoload/ale/sign.vim
View File

@ -89,13 +89,13 @@ function! ale#sign#SetSigns(buffer, loclist) abort
let l:signlist = ale#sign#CombineSigns(a:loclist)
if len(l:signlist) > 0 || g:ale_sign_column_always
if !get(g:ale_buffer_sign_dummy_map, a:buffer, 0)
if !g:ale_buffer_info[a:buffer].dummy_sign_set
" Insert a dummy sign if one is missing.
execute 'sign place ' . g:ale_sign_offset
\ . ' line=1 name=ALEDummySign buffer='
\ . a:buffer
let g:ale_buffer_sign_dummy_map[a:buffer] = 1
let g:ale_buffer_info[a:buffer].dummy_sign_set = 1
endif
endif
@ -121,10 +121,10 @@ function! ale#sign#SetSigns(buffer, loclist) abort
endfor
if !g:ale_sign_column_always && len(l:signlist) > 0
if get(g:ale_buffer_sign_dummy_map, a:buffer, 0)
if g:ale_buffer_info[a:buffer].dummy_sign_set
execute 'sign unplace ' . g:ale_sign_offset . ' buffer=' . a:buffer
let g:ale_buffer_sign_dummy_map[a:buffer] = 0
let g:ale_buffer_info[a:buffer].dummy_sign_set = 0
endif
endif
endfunction

40
autoload/ale/statusline.vim
View File

@ -14,34 +14,48 @@ function! ale#statusline#Update(buffer, loclist) abort
endif
endfor
let g:ale_buffer_count_map[a:buffer] = [l:errors, l:warnings]
let g:ale_buffer_info[a:buffer].count = [l:errors, l:warnings]
endfunction
" Set the error and warning counts, calling for an update only if needed.
" If counts cannot be set, return 0.
function! s:SetupCount(buffer) abort
if !has_key(g:ale_buffer_info, a:buffer)
" Linters have not been run for the buffer yet, so stop here.
return 0
endif
" Cache is cold, so manually ask for an update.
if !has_key(g:ale_buffer_info[a:buffer], 'count')
call ale#statusline#Update(a:buffer, get(g:ale_buffer_loclist_map, a:buffer, []))
endif
return 1
endfunction
" Returns a tuple of errors and warnings for use in third-party integrations.
function! ale#statusline#Count(buffer) abort
" Cache is cold, so manually ask for an update.
if !has_key(g:ale_buffer_count_map, a:buffer)
call ale#statusline#Update(a:buffer, get(g:ale_buffer_loclist_map, a:buffer, []))
if !s:SetupCount(a:buffer)
return [0, 0]
endif
return g:ale_buffer_count_map[a:buffer]
return g:ale_buffer_info[a:buffer].count
endfunction
" Returns a formatted string that can be integrated in the statusline.
function! ale#statusline#Status() abort
let [l:error_format, l:warning_format, l:no_errors] = g:ale_statusline_format
let l:buffer = bufnr('%')
" Cache is cold, so manually ask for an update.
if !has_key(g:ale_buffer_count_map, l:buffer)
call ale#statusline#Update(l:buffer, get(g:ale_buffer_loclist_map, l:buffer, []))
if !s:SetupCount(l:buffer)
return l:no_errors
endif
let [l:error_count, l:warning_count] = g:ale_buffer_info[l:buffer].count
" Build strings based on user formatting preferences.
let l:errors = g:ale_buffer_count_map[l:buffer][0] ?
\ printf(g:ale_statusline_format[0], g:ale_buffer_count_map[l:buffer][0]) : ''
let l:warnings = g:ale_buffer_count_map[l:buffer][1] ?
\ printf(g:ale_statusline_format[1], g:ale_buffer_count_map[l:buffer][1]) : ''
let l:no_errors = g:ale_statusline_format[2]
let l:errors = l:error_count ? printf(l:error_format, l:error_count) : ''
let l:warnings = l:warning_count ? printf(l:warning_format, l:warning_count) : ''
" Different formats based on the combination of errors and warnings.
if empty(l:errors) && empty(l:warnings)

4
plugin/ale.vim
View File

@ -24,10 +24,8 @@ endif
" Globals
let g:ale_buffer_count_map = {}
let g:ale_buffer_loclist_map = {}
let g:ale_buffer_should_reset_map = {}
let g:ale_buffer_sign_dummy_map = {}
let g:ale_buffer_info = {}
" User Configuration

23
test/test_cleanup.vader
View File

@ -1,32 +1,21 @@
Before:
let g:buffer = bufnr('%')
let g:ale_buffer_count_map = {
\ g:buffer: [1, 1],
\ 10347: [1, 1],
\}
let g:ale_buffer_loclist_map = {
\ g:buffer : [],
\ 10347: [],
\}
let g:ale_buffer_should_reset_map = {
\ g:buffer : 1,
\ 10347: 1,
\}
let g:ale_buffer_sign_dummy_map = {
\ g:buffer : 1,
\ 10347: 1,
let g:ale_buffer_info = {
\ g:buffer : {},
\ 10347: {},
\}
After:
unlet! g:buffer
let g:ale_buffer_count_map = {}
let g:ale_buffer_loclist_map = {}
let g:ale_buffer_should_reset_map = {}
let g:ale_buffer_sign_dummy_map = {}
let g:ale_buffer_info = {}
Execute('ALE globals should be cleared when the buffer is closed.'):
:q!
AssertEqual {10347: [1, 1]}, g:ale_buffer_count_map
AssertEqual {10347: []}, g:ale_buffer_loclist_map
AssertEqual {10347: 1}, g:ale_buffer_should_reset_map
AssertEqual {10347: 1}, g:ale_buffer_sign_dummy_map
AssertEqual {10347: {}}, g:ale_buffer_info

40
test/test_linting_sets_signs.vader Normal file
View File

@ -0,0 +1,40 @@
Given javascript (Some JavaScript with problems):
var y = 3+3;
var y = 3
Before:
sign unplace *
let g:actual_sign_list = []
let g:expected_sign_list = [
\ ['1', 'ALEWarningSign'],
\ ['2', 'ALEErrorSign'],
\]
function! g:CollectSigns()
redir => l:output
silent exec 'sign place'
redir END
for l:line in split(l:output, "\n")
let l:match = matchlist(l:line, 'line=\(\d\+\).*name=\(ALE[a-zA-Z]\+\)')
if len(l:match) > 0
call add(g:actual_sign_list, [l:match[1], l:match[2]])
endif
endfor
endfunction
After:
sign unplace *
let g:ale_buffer_loclist_map = {}
let g:ale_buffer_info = {}
delfunction g:CollectSigns
unlet g:actual_sign_list
unlet g:expected_sign_list
Execute(The signs should be updated after linting is done):
call ale#Lint()
call ale#engine#WaitForJobs(2000)
call g:CollectSigns()
AssertEqual g:expected_sign_list, g:actual_sign_list

52
test/test_statusline.vader
View File

@ -1,49 +1,59 @@
Before:
let g:ale_buffer_loclist_map = {}
let g:ale_statusline_format = ['%sE', '%sW', 'OKIE']
After:
let g:ale_buffer_loclist_map = {}
let g:ale_buffer_info = {}
Execute (Count should be 0 when data is empty):
let g:ale_buffer_info = {}
AssertEqual [0, 0], ale#statusline#Count(bufnr('%'))
Before:
let g:ale_buffer_count_map = {'44': [1, 2]}
Execute (Count should read data from the cache):
let g:ale_buffer_info = {'44': {'count': [1, 2]}}
AssertEqual [1, 2], ale#statusline#Count(44)
Execute (Update the cache with new data):
Execute (The count should be correct after an update):
let g:ale_buffer_info = {'44': {}}
call ale#statusline#Update(44, [])
Then (The cache should reflect the new data):
AssertEqual [0, 0], ale#statusline#Count(44)
Before:
let g:ale_buffer_loclist_map = {'1': [{'lnum': 1, 'bufnr': 1, 'vcol': 0, 'linter_name': 'testlinter', 'nr': -1, 'type': 'E', 'col': 1, 'text': 'Test Error'}]}
Execute (Count should be match the loclist):
AssertEqual [1, 0], ale#statusline#Count(1)
let g:ale_buffer_info = {bufnr('%'): {}}
let g:ale_buffer_loclist_map = {bufnr('%'): [
\ {
\ 'lnum': 1,
\ 'bufnr': 1,
\ 'vcol': 0,
\ 'linter_name': 'testlinter',
\ 'nr': -1,
\ 'type': 'E',
\ 'col': 1,
\ 'text': 'Test Error',
\ },
\]}
AssertEqual [1, 0], ale#statusline#Count(bufnr('%'))
Execute (Output should be empty for non-existant buffer):
AssertEqual [0, 0], ale#statusline#Count(9001)
Before:
let g:ale_statusline_format = ['%sE', '%sW', 'OKIE']
Execute (Given some errors):
Execute (Statusline is formatted to the users preference for just errors):
let g:ale_buffer_info = {bufnr('%'): {}}
call ale#statusline#Update(bufnr('%'), [{'type': 'E'}, {'type': 'E'}])
Then (Statusline is formatted to the users preference):
AssertEqual '2E', ale#statusline#Status()
Execute (Given some warnings):
Execute (Statusline is formatted to the users preference for just warnings):
let g:ale_buffer_info = {bufnr('%'): {}}
call ale#statusline#Update(bufnr('%'), [{'type': 'W'}, {'type': 'W'}, {'type': 'W'}])
Then (Statusline is formatted to the users preference):
AssertEqual '3W', ale#statusline#Status()
Execute (Given some warnings, and errors):
Execute (Statusline is formatted to the users preference for errors and warnings):
let g:ale_buffer_info = {bufnr('%'): {}}
call ale#statusline#Update(bufnr('%'), [{'type': 'E'}, {'type': 'W'}, {'type': 'W'}])
Then (Statusline is formatted to the users preference):
AssertEqual '1E 2W', ale#statusline#Status()
Execute (Given a lack of data):
Execute (Statusline is formatted to the users preference for no errors or warnings):
let g:ale_buffer_info = {bufnr('%'): {}}
call ale#statusline#Update(bufnr('%'), [])
Then (Statusline is formatted to the users preference):
AssertEqual 'OKIE', ale#statusline#Status()