880 lines
21 KiB
Plaintext
880 lines
21 KiB
Plaintext
Before:
|
|
Save g:ale_fixers
|
|
Save &shell
|
|
Save g:ale_enabled
|
|
Save g:ale_fix_on_save
|
|
Save g:ale_lint_on_save
|
|
Save g:ale_echo_cursor
|
|
|
|
silent! cd /testplugin/test/fix
|
|
|
|
unlet! b:ale_lint_on_save
|
|
let g:ale_enabled = 0
|
|
let g:ale_echo_cursor = 0
|
|
let g:ale_run_synchronously = 1
|
|
let g:ale_set_lists_synchronously = 1
|
|
let g:ale_fix_buffer_data = {}
|
|
let g:ale_fixers = {
|
|
\ 'testft': [],
|
|
\}
|
|
|
|
let g:pre_success = 0
|
|
let g:post_success = 0
|
|
augroup VaderTest
|
|
autocmd!
|
|
autocmd User ALEFixPre let g:pre_success = 1
|
|
autocmd User ALEFixPost let g:post_success = 1
|
|
augroup END
|
|
|
|
if !has('win32')
|
|
let &shell = '/bin/bash'
|
|
endif
|
|
|
|
call ale#test#SetDirectory('/testplugin/test')
|
|
call ale#test#SetFilename('test.txt')
|
|
call ale#linter#PreventLoading('testft')
|
|
|
|
function AddCarets(buffer, lines) abort
|
|
" map() is applied to the original lines here.
|
|
" This way, we can ensure that defensive copies are made.
|
|
return map(a:lines, '''^'' . v:val')
|
|
endfunction
|
|
|
|
function AddDollars(buffer, lines) abort
|
|
return map(a:lines, '''$'' . v:val')
|
|
endfunction
|
|
|
|
function DoNothing(buffer, lines) abort
|
|
return 0
|
|
endfunction
|
|
|
|
function CatLine(buffer, lines) abort
|
|
return {'command': 'cat - <(echo d)'}
|
|
endfunction
|
|
|
|
function CatLineOneArg(buffer) abort
|
|
return {'command': 'cat - <(echo d)'}
|
|
endfunction
|
|
|
|
function CatLineDeferred(buffer, lines) abort
|
|
return ale#command#Run(a:buffer, 'echo', {
|
|
\ -> ale#command#Run(a:buffer, 'echo', {-> {'command': 'cat - <(echo d)'}})
|
|
\})
|
|
endfunction
|
|
|
|
function ReplaceWithTempFile(buffer, lines) abort
|
|
return {'command': 'echo x > %t', 'read_temporary_file': 1}
|
|
endfunction
|
|
|
|
function CatWithTempFile(buffer, lines) abort
|
|
return {'command': 'cat %t <(echo d)'}
|
|
endfunction
|
|
|
|
function RemoveLastLine(buffer, lines) abort
|
|
return ['a', 'b']
|
|
endfunction
|
|
|
|
function RemoveLastLineOneArg(buffer) abort
|
|
return ['a', 'b']
|
|
endfunction
|
|
|
|
function! TestCallback(buffer, output)
|
|
return [{'lnum': 1, 'col': 1, 'text': 'xxx'}]
|
|
endfunction
|
|
|
|
function! FirstChainCallback(buffer)
|
|
return {'command': 'echo echoline', 'chain_with': 'SecondChainCallback'}
|
|
endfunction
|
|
|
|
function! FirstChainCallbackSkipped(buffer)
|
|
let l:ChainWith = 'SecondChainCallback'
|
|
|
|
" Test with lambdas where support is available.
|
|
if has('lambda')
|
|
let l:ChainWith = {buffer, output -> SecondChainCallback(buffer, output)}
|
|
endif
|
|
|
|
return {'command': '', 'chain_with': l:ChainWith}
|
|
endfunction
|
|
|
|
function! FirstChainCallbackSecondSkipped(buffer)
|
|
return {'command': 'echo skipit', 'chain_with': 'SecondChainCallback'}
|
|
endfunction
|
|
|
|
function! SecondChainCallback(buffer, output)
|
|
let l:previous_line = empty(a:output)
|
|
\ ? 'emptydefault'
|
|
\ : join(split(a:output[0]))
|
|
|
|
if l:previous_line is# 'skipit'
|
|
return {'command': '', 'chain_with': 'ThirdChainCallback'}
|
|
endif
|
|
|
|
return {
|
|
\ 'command': 'echo ' . l:previous_line,
|
|
\ 'chain_with': 'ThirdChainCallback',
|
|
\}
|
|
endfunction
|
|
|
|
function! ThirdChainCallback(buffer, output, input)
|
|
let l:previous_line = empty(a:output)
|
|
\ ? 'thirddefault'
|
|
\ : join(split(a:output[0]))
|
|
|
|
return a:input + [l:previous_line]
|
|
endfunction
|
|
|
|
function! ChainWhereLastIsSkipped(buffer)
|
|
return {'command': 'echo echoline', 'chain_with': 'ChainEndSkipped'}
|
|
endfunction
|
|
|
|
function! ChainEndSkipped(buffer, output)
|
|
return {'command': ''}
|
|
endfunction
|
|
|
|
" echo will output a single blank line, and we should ingore it.
|
|
function! IgnoredEmptyOutput(buffer, output)
|
|
return {'command': has('win32') ? 'echo(' : 'echo'}
|
|
endfunction
|
|
|
|
function! EchoLineNoPipe(buffer, output)
|
|
return {'command': 'echo new line', 'read_buffer': 0}
|
|
endfunction
|
|
|
|
function! SetUpLinters()
|
|
call ale#linter#Define('testft', {
|
|
\ 'name': 'testlinter',
|
|
\ 'callback': 'TestCallback',
|
|
\ 'executable': 'true',
|
|
\ 'command': 'true',
|
|
\})
|
|
endfunction
|
|
|
|
function GetLastMessage()
|
|
redir => l:output
|
|
silent mess
|
|
redir END
|
|
|
|
let l:lines = split(l:output, "\n")
|
|
|
|
return empty(l:lines) ? '' : l:lines[-1]
|
|
endfunction
|
|
|
|
function! FixWithJSONPostProcessing(buffer) abort
|
|
let l:ProcessWith = 'JSONPostProcessor'
|
|
|
|
" Test with lambdas where support is available.
|
|
if has('lambda')
|
|
let l:ProcessWith = {buffer, output -> JSONPostProcessor(buffer, output)}
|
|
endif
|
|
|
|
" Escaping needs to be handled specially for CMD on Windows.
|
|
let l:json_string = has('win32')
|
|
\ ? '{"output":["x","y","z"]}'
|
|
\ : ale#Escape('{"output": ["x", "y", "z"]}')
|
|
|
|
return {
|
|
\ 'command': 'echo ' . l:json_string,
|
|
\ 'read_buffer': 0,
|
|
\ 'process_with': l:ProcessWith,
|
|
\}
|
|
endfunction
|
|
|
|
function! JSONPostProcessor(buffer, output) abort
|
|
return json_decode(a:output[0]).output
|
|
endfunction
|
|
|
|
After:
|
|
Restore
|
|
unlet! g:test_filename
|
|
unlet! g:ale_run_synchronously
|
|
unlet! g:ale_set_lists_synchronously
|
|
unlet! g:ale_run_synchronously_callbacks
|
|
unlet! g:ale_emulate_job_failure
|
|
unlet! b:ale_fixers
|
|
unlet! b:ale_lint_on_save
|
|
unlet! b:ale_fix_on_save
|
|
unlet! b:ale_quitting
|
|
delfunction AddCarets
|
|
delfunction AddDollars
|
|
delfunction DoNothing
|
|
delfunction CatLine
|
|
delfunction CatLineOneArg
|
|
delfunction CatLineDeferred
|
|
delfunction ReplaceWithTempFile
|
|
delfunction CatWithTempFile
|
|
delfunction RemoveLastLine
|
|
delfunction RemoveLastLineOneArg
|
|
delfunction TestCallback
|
|
delfunction FirstChainCallback
|
|
delfunction FirstChainCallbackSkipped
|
|
delfunction FirstChainCallbackSecondSkipped
|
|
delfunction SecondChainCallback
|
|
delfunction ThirdChainCallback
|
|
delfunction ChainWhereLastIsSkipped
|
|
delfunction ChainEndSkipped
|
|
delfunction SetUpLinters
|
|
delfunction GetLastMessage
|
|
delfunction IgnoredEmptyOutput
|
|
delfunction EchoLineNoPipe
|
|
delfunction FixWithJSONPostProcessing
|
|
delfunction JSONPostProcessor
|
|
|
|
augroup VaderTest
|
|
autocmd!
|
|
augroup END
|
|
|
|
augroup! VaderTest
|
|
|
|
call ale#test#RestoreDirectory()
|
|
|
|
call ale#fix#registry#ResetToDefaults()
|
|
call ale#linter#Reset()
|
|
|
|
setlocal buftype=nofile
|
|
|
|
if exists('g:test_filename') && filereadable(g:test_filename)
|
|
call delete(g:test_filename)
|
|
endif
|
|
|
|
call setloclist(0, [])
|
|
|
|
let g:ale_fix_buffer_data = {}
|
|
|
|
" Clear the messages between tests.
|
|
echomsg ''
|
|
|
|
Given testft (A file with three lines):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix should complain when there are no functions to call):
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
AssertEqual 'No fixers have been defined. Try :ALEFixSuggest', GetLastMessage()
|
|
|
|
Execute(ALEFix should apply simple functions):
|
|
let g:ale_fixers.testft = ['AddCarets']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The first function should be used):
|
|
^a
|
|
^b
|
|
^c
|
|
|
|
Execute(ALEFix should apply simple functions in a chain):
|
|
let g:ale_fixers.testft = ['AddCarets', 'AddDollars']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(Both functions should be used):
|
|
$^a
|
|
$^b
|
|
$^c
|
|
|
|
Execute(ALEFix should allow 0 to be returned to skip functions):
|
|
let g:ale_fixers.testft = ['DoNothing', 'AddDollars']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(Only the second function should be applied):
|
|
$a
|
|
$b
|
|
$c
|
|
|
|
Execute(The * fixers shouldn't be used if an empty list is set for fixers):
|
|
let g:ale_fixers.testft = []
|
|
let g:ale_fixers['*'] = ['AddDollars']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(Nothing should be changed):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(* fixers should be used if no filetype is matched):
|
|
let g:ale_fixers = {'*': ['AddDollars']}
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The file should be changed):
|
|
$a
|
|
$b
|
|
$c
|
|
|
|
Execute(ALEFix should allow commands to be run):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['a', 'b', 'c', 'd'])
|
|
else
|
|
let g:ale_fixers.testft = ['CatLine']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(An extra line should be added):
|
|
a
|
|
b
|
|
c
|
|
d
|
|
|
|
Execute(ALEFix should use fixers passed in commandline when provided):
|
|
let g:ale_fixers.testft = ['RemoveLastLine']
|
|
ALEFix AddCarets AddDollars
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(Only fixers passed via command line should be run):
|
|
$^a
|
|
$^b
|
|
$^c
|
|
|
|
Execute(ALEFix should allow temporary files to be read):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['x'])
|
|
2,3d
|
|
else
|
|
let g:ale_fixers.testft = ['ReplaceWithTempFile']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(The line we wrote to the temporary file should be used here):
|
|
x
|
|
|
|
Execute(ALEFix should not read the temporary file when the option is not set):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['a', 'b', 'c', 'd'])
|
|
else
|
|
let g:ale_fixers.testft = ['CatWithTempFile']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(An extra line should be added):
|
|
a
|
|
b
|
|
c
|
|
d
|
|
|
|
Execute(ALEFix should allow jobs and simple functions to be combined):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['$x'])
|
|
2,3d
|
|
else
|
|
let g:ale_fixers.testft = ['ReplaceWithTempFile', 'AddDollars']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(The lines from the temporary file should be modified):
|
|
$x
|
|
|
|
Execute(ALEFix should send lines modified by functions to jobs):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['$a', '$b', '$c', 'd'])
|
|
else
|
|
let g:ale_fixers.testft = ['AddDollars', 'CatLine']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(The lines should first be modified by the function, then the job):
|
|
$a
|
|
$b
|
|
$c
|
|
d
|
|
|
|
Execute(ALEFix should skip commands when jobs fail to run):
|
|
let g:ale_emulate_job_failure = 1
|
|
let g:ale_fixers.testft = ['CatLine', 'AddDollars']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(Only the second function should be applied):
|
|
$a
|
|
$b
|
|
$c
|
|
|
|
Execute(ALEFix should handle strings for selecting a single function):
|
|
let g:ale_fixers.testft = 'AddCarets'
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The first function should be used):
|
|
^a
|
|
^b
|
|
^c
|
|
|
|
Execute(ALEFix should use functions from the registry):
|
|
call ale#fix#registry#Add('add_carets', 'AddCarets', [], 'Add some carets')
|
|
let g:ale_fixers.testft = ['add_carets']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The registry function should be used):
|
|
^a
|
|
^b
|
|
^c
|
|
|
|
Execute(ALEFix should be able to remove the last line for files):
|
|
let g:ale_fixers.testft = ['RemoveLastLine']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Execute(ALEFix should accept funcrefs):
|
|
let g:ale_fixers.testft = [function('RemoveLastLine')]
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Execute(ALEFix should accept lambdas):
|
|
if has('nvim')
|
|
" NeoVim 0.1.7 can't interpret lambdas correctly, so just set the lines
|
|
" to make the test pass.
|
|
call setline(1, ['a', 'b', 'c', 'd'])
|
|
else
|
|
let g:ale_fixers.testft = [{buffer, lines -> lines + ['d']}]
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(There should be an extra line):
|
|
a
|
|
b
|
|
c
|
|
d
|
|
|
|
Execute(ALEFix should user buffer-local fixer settings):
|
|
let g:ale_fixers.testft = ['AddCarets', 'AddDollars']
|
|
let b:ale_fixers = {'testft': ['RemoveLastLine']}
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Execute(ALEFix should allow Lists to be used for buffer-local fixer settings):
|
|
let g:ale_fixers.testft = ['AddCarets', 'AddDollars']
|
|
let b:ale_fixers = ['RemoveLastLine']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Given testft (A file with three lines):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix should fix files on the save event):
|
|
let g:ale_fix_on_save = 1
|
|
let g:ale_lint_on_save = 1
|
|
let g:ale_enabled = 1
|
|
|
|
let g:test_filename = tempname()
|
|
execute 'noautocmd silent file ' . fnameescape(g:test_filename)
|
|
call writefile(getline(1, '$'), g:test_filename)
|
|
|
|
let g:ale_fixers.testft = ['AddDollars']
|
|
|
|
" We have to set the buftype to empty so the file will be written.
|
|
setlocal buftype=
|
|
|
|
call SetUpLinters()
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
call ale#test#FlushJobs()
|
|
|
|
" We should save the file.
|
|
AssertEqual ['$a', '$b', '$c'], readfile(g:test_filename)
|
|
Assert !&modified, 'The file was marked as ''modified'''
|
|
|
|
if !has('win32')
|
|
" We should have run the linter.
|
|
AssertEqual [{
|
|
\ 'bufnr': bufnr('%'),
|
|
\ 'lnum': 1,
|
|
\ 'vcol': 0,
|
|
\ 'col': 1,
|
|
\ 'text': 'xxx',
|
|
\ 'type': 'E',
|
|
\ 'nr': -1,
|
|
\ 'pattern': '',
|
|
\ 'valid': 1,
|
|
\}], ale#test#GetLoclistWithoutModule()
|
|
endif
|
|
|
|
Expect(The buffer should be modified):
|
|
$a
|
|
$b
|
|
$c
|
|
|
|
Execute(ALEFix should not fix files on :wq):
|
|
let g:ale_fix_on_save = 1
|
|
let g:ale_lint_on_save = 1
|
|
let g:ale_enabled = 1
|
|
|
|
let g:test_filename = tempname()
|
|
execute 'noautocmd silent file ' . fnameescape(g:test_filename)
|
|
call writefile(getline(1, '$'), g:test_filename)
|
|
|
|
let g:ale_fixers.testft = ['AddDollars']
|
|
|
|
" We have to set the buftype to empty so the file will be written.
|
|
setlocal buftype=
|
|
|
|
call ale#events#QuitEvent(bufnr(''))
|
|
|
|
call SetUpLinters()
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
|
|
" We should save the file.
|
|
AssertEqual ['a', 'b', 'c'], readfile(g:test_filename)
|
|
Assert &modified, 'The was not marked as ''modified'''
|
|
|
|
" We should not run the linter.
|
|
AssertEqual [], ale#test#GetLoclistWithoutModule()
|
|
|
|
Expect(The buffer should not be modified):
|
|
a
|
|
b
|
|
c
|
|
|
|
Given testft (A file with three lines):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix should still lint with no linters to be applied):
|
|
let g:ale_fix_on_save = 1
|
|
let g:ale_lint_on_save = 1
|
|
let g:ale_enabled = 1
|
|
|
|
let g:test_filename = tempname()
|
|
execute 'noautocmd silent file ' . fnameescape(g:test_filename)
|
|
|
|
let g:ale_fixers.testft = []
|
|
|
|
call SetUpLinters()
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
call ale#test#FlushJobs()
|
|
|
|
Assert !filereadable(g:test_filename), 'The file should not have been saved'
|
|
|
|
if !has('win32')
|
|
" We have run the linter.
|
|
AssertEqual [{
|
|
\ 'bufnr': bufnr('%'),
|
|
\ 'lnum': 1,
|
|
\ 'vcol': 0,
|
|
\ 'col': 1,
|
|
\ 'text': 'xxx',
|
|
\ 'type': 'E',
|
|
\ 'nr': -1,
|
|
\ 'pattern': '',
|
|
\ 'valid': 1,
|
|
\}], ale#test#GetLoclistWithoutModule()
|
|
endif
|
|
|
|
Expect(The buffer should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix should still lint when nothing was fixed on save):
|
|
let g:ale_fix_on_save = 1
|
|
let g:ale_lint_on_save = 1
|
|
let g:ale_enabled = 1
|
|
|
|
let g:test_filename = tempname()
|
|
execute 'noautocmd silent file ' . fnameescape(g:test_filename)
|
|
|
|
let g:ale_fixers.testft = ['DoNothing']
|
|
|
|
call SetUpLinters()
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
call ale#test#FlushJobs()
|
|
|
|
Assert !filereadable(g:test_filename), 'The file should not have been saved'
|
|
|
|
if !has('win32')
|
|
" We should have run the linter.
|
|
AssertEqual [{
|
|
\ 'bufnr': bufnr('%'),
|
|
\ 'lnum': 1,
|
|
\ 'vcol': 0,
|
|
\ 'col': 1,
|
|
\ 'text': 'xxx',
|
|
\ 'type': 'E',
|
|
\ 'nr': -1,
|
|
\ 'pattern': '',
|
|
\ 'valid': 1,
|
|
\}], ale#test#GetLoclistWithoutModule()
|
|
endif
|
|
|
|
Expect(The buffer should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix should not lint the buffer on save if linting on save is disabled globally):
|
|
let g:ale_fix_on_save = 1
|
|
let g:ale_lint_on_save = 0
|
|
let g:ale_enabled = 1
|
|
|
|
let g:test_filename = tempname()
|
|
execute 'noautocmd silent file ' . fnameescape(g:test_filename)
|
|
|
|
let g:ale_fixers.testft = ['DoNothing']
|
|
|
|
call SetUpLinters()
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
call ale#test#FlushJobs()
|
|
|
|
Assert !filereadable(g:test_filename), 'The file should not have been saved'
|
|
|
|
AssertEqual [], ale#test#GetLoclistWithoutModule()
|
|
|
|
Expect(The buffer should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix should not lint the buffer on save if linting on save is disabled locally):
|
|
let g:ale_fix_on_save = 1
|
|
let b:ale_lint_on_save = 0
|
|
let g:ale_enabled = 1
|
|
|
|
let g:test_filename = tempname()
|
|
execute 'noautocmd silent file ' . fnameescape(g:test_filename)
|
|
|
|
let g:ale_fixers.testft = ['DoNothing']
|
|
|
|
call SetUpLinters()
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
call ale#test#FlushJobs()
|
|
|
|
Assert !filereadable(g:test_filename), 'The file should not have been saved'
|
|
|
|
AssertEqual [], ale#test#GetLoclistWithoutModule()
|
|
|
|
Expect(The buffer should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Given testft (A file with three lines):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ale#fix#InitBufferData() should set up the correct data):
|
|
let g:test_filename = tempname()
|
|
execute 'noautocmd silent file ' . fnameescape(g:test_filename)
|
|
|
|
call ale#fix#InitBufferData(bufnr(''), 'save_file')
|
|
|
|
AssertEqual {
|
|
\ bufnr(''): {
|
|
\ 'temporary_directory_list': [],
|
|
\ 'done': 0,
|
|
\ 'lines_before': ['a', 'b', 'c'],
|
|
\ 'should_save': 1,
|
|
\ },
|
|
\}, g:ale_fix_buffer_data
|
|
|
|
Execute(ALEFix simple functions should be able to accept one argument, the buffer):
|
|
let g:ale_fixers.testft = ['RemoveLastLineOneArg']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Execute(b:ale_fix_on_save = 1 should override g:ale_fix_on_save = 0):
|
|
let g:ale_fix_on_save = 0
|
|
let b:ale_fix_on_save = 1
|
|
|
|
let g:ale_fixers.testft = ['RemoveLastLineOneArg']
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
|
|
Expect(There should be only two lines):
|
|
a
|
|
b
|
|
|
|
Execute(b:ale_fix_on_save = 0 should override g:ale_fix_on_save = 1):
|
|
let g:ale_fix_on_save = 1
|
|
let b:ale_fix_on_save = 0
|
|
|
|
let g:ale_fixers.testft = ['RemoveLastLineOneArg']
|
|
call ale#events#SaveEvent(bufnr(''))
|
|
|
|
Expect(The lines should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(ALEFix functions returning jobs should be able to accept one argument):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['a', 'b', 'c', 'd'])
|
|
else
|
|
let g:ale_fixers.testft = ['CatLine']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(An extra line should be added):
|
|
a
|
|
b
|
|
c
|
|
d
|
|
|
|
Execute(ALE should print a message telling you something isn't a valid fixer when you type some nonsense):
|
|
let g:ale_fixers.testft = ['CatLine', 'invalidname']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
AssertEqual 'There is no fixer named `invalidname`. Check :ALEFixSuggest', GetLastMessage()
|
|
|
|
Execute(ALE should complain about invalid fixers with minuses in the name):
|
|
let g:ale_fixers.testft = ['foo-bar']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
AssertEqual 'There is no fixer named `foo-bar`. Check :ALEFixSuggest', GetLastMessage()
|
|
|
|
Execute(ALE should tolerate valid fixers with minuses in the name):
|
|
let g:ale_fixers.testft = ['prettier-standard']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Execute(Test fixing with chained callbacks):
|
|
let g:ale_fixers.testft = ['FirstChainCallback']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
" The buffer shouldn't be piped in for earlier commands in the chain.
|
|
AssertEqual
|
|
\ [
|
|
\ string(ale#job#PrepareCommand(bufnr(''), 'echo echoline')),
|
|
\ string(ale#job#PrepareCommand(bufnr(''), 'echo echoline')),
|
|
\ ],
|
|
\ map(ale#history#Get(bufnr(''))[-2:-1], 'string(v:val.command)')
|
|
|
|
Expect(The echoed line should be added):
|
|
a
|
|
b
|
|
c
|
|
echoline
|
|
|
|
Execute(Test fixing with chained callback where the first command is skipped):
|
|
let g:ale_fixers.testft = ['FirstChainCallbackSkipped']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The default line should be added):
|
|
a
|
|
b
|
|
c
|
|
emptydefault
|
|
|
|
Execute(Test fixing with chained callback where the second command is skipped):
|
|
let g:ale_fixers.testft = ['FirstChainCallbackSecondSkipped']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The default line should be added):
|
|
a
|
|
b
|
|
c
|
|
thirddefault
|
|
|
|
Execute(Test fixing with chained callback where the final callback is skipped):
|
|
let g:ale_fixers.testft = ['ChainWhereLastIsSkipped']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The lines should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(Empty output should be ignored):
|
|
let g:ale_fixers.testft = ['IgnoredEmptyOutput']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The lines should be the same):
|
|
a
|
|
b
|
|
c
|
|
|
|
Execute(A temporary file shouldn't be piped into the command when disabled):
|
|
let g:ale_fixers.testft = ['EchoLineNoPipe']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
AssertEqual
|
|
\ string(ale#job#PrepareCommand(bufnr(''), 'echo new line')),
|
|
\ string(ale#history#Get(bufnr(''))[-1].command)
|
|
|
|
" Remove trailing whitespace for Windows.
|
|
if has('win32')
|
|
%s/[[:space:]]*$//g
|
|
endif
|
|
|
|
Expect(The new line should be used):
|
|
new line
|
|
|
|
Execute(Post-processing should work):
|
|
let g:ale_fixers.testft = ['FixWithJSONPostProcessing']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
Expect(The lines in the JSON should be used):
|
|
x
|
|
y
|
|
z
|
|
|
|
Execute(ALEFix should apply autocmds):
|
|
let g:ale_fixers.testft = ['AddCarets']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
|
|
AssertEqual g:pre_success, 1
|
|
AssertEqual g:post_success, 1
|
|
|
|
Execute(ALEFix should support ale#command#Run):
|
|
if has('win32')
|
|
" Just skip this test on Windows, we can't run it.
|
|
call setline(1, ['a', 'b', 'c', 'd'])
|
|
else
|
|
let g:ale_fixers.testft = ['CatLineDeferred']
|
|
ALEFix
|
|
call ale#test#FlushJobs()
|
|
endif
|
|
|
|
Expect(The extra line should be added):
|
|
a
|
|
b
|
|
c
|
|
d
|