hasufell/ale
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

First pass at optimizing ale to autoload (#80)

Browse Source 
* First pass at optimizing ale to autoload

First off, the structure/function names should be revised a bit,
but I will wait for @w0rp's input before unifying the naming style.
Second off, the docs probably need some more work, I just did some
simple find-and-replace work.

With that said, this pull brings major performance gains for ale. On my
slowest system, fully loading ale and all its code takes around 150ms.

I have moved all of ale's autoload-able code to autoload/, and in
addition, implemented lazy-loading of linters. This brings load time on
that same system down to 5ms.

The only downside of lazy loading is that `g:ale_linters` cannot be
changed at runtime; however, it also speeds up performance at runtime by
simplfying the logic greatly.

Please let me know what you think!

Closes #59

* Address Travis/Vint errors

For some reason, ale isn't running vint for me...

* Incorporate feedback, make fixes

Lazy-loading logic is much improved.

* Add header comments; remove incorrect workaround

* Remove unneeded plugin guards

* Fix lazy-loading linter logic

Set the wrong variable....

* Fix capitialization
This commit is contained in:
Bjorn Neergaard
2016-10-10 13:51:29 -05:00
committed by w0rp
parent 0680f875fe
commit 7f0ce89d2b
44 changed files with 337 additions and 336 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
plugin/ale/aaflags.vim → plugin/ale.vim
View File

@@ -1,12 +1,11 @@
" Author: w0rp <devw0rp@gmail.com>
" Description: This file sets up configuration settings for the ALE plugin.
" Flags can be set in vimrc files and so on to disable particular features
" Description: Main entry point for the plugin: sets up prefs and autocommands
" Preferences can be set in vimrc files and so on to configure ale
if exists('g:loaded_ale_flags')
if exists('g:loaded_ale')
finish
endif
let g:loaded_ale_flags = 1
let g:loaded_ale = 1
" A flag for detecting if the required features are set.
if has('nvim')
@@ -15,6 +14,15 @@ else
let g:ale_has_required_features = has('timers') && has('job') && has('channel')
endif
if !g:ale_has_required_features
echoerr 'ALE requires NeoVim >= 0.1.5 or Vim 8 with +timers +job +channel'
echoerr 'Please update your editor appropriately.'
finish
endif
" This list configures which linters are enabled for which languages.
let g:ale_linters = get(g:, 'ale_linters', {})
" This flag can be set to 0 to disable linting when text is changed.
let g:ale_lint_on_text_changed = get(g:, 'ale_lint_on_text_changed', 1)
@@ -64,3 +72,43 @@ let g:ale_echo_msg_format = get(g:, 'ale_echo_msg_format', '%s')
" Strings used for severity in the echoed message
let g:ale_echo_msg_error_str = get(g:, 'ale_echo_msg_error_str', 'Error')
let g:ale_echo_msg_warning_str = get(g:, 'ale_echo_msg_warning_str', 'Warning')
if g:ale_lint_on_text_changed
augroup ALERunOnTextChangedGroup
autocmd!
autocmd TextChanged,TextChangedI * call ale#Queue(g:ale_lint_delay)
augroup END
endif
if g:ale_lint_on_enter
augroup ALERunOnEnterGroup
autocmd!
autocmd BufEnter,BufRead * call ale#Queue(100)
augroup END
endif
if g:ale_lint_on_save
augroup ALERunOnSaveGroup
autocmd!
autocmd BufWrite * call ale#Queue(0)
augroup END
endif
" Clean up buffers automatically when they are unloaded.
augroup ALEBufferCleanup
autocmd!
autocmd BufUnload * call ale#cleanup#Buffer('<abuf>')
augroup END
" Globals which each part of the plugin should use.
let g:ale_buffer_loclist_map = {}
let g:ale_buffer_should_reset_map = {}
let g:ale_buffer_sign_dummy_map = {}
" Backwards compatibility
function! ALELint(delay)
call ale#Queue(a:delay)
endfunction
function! ALEGetStatusLine()
call ale#statusline#Status()
endfunction

125
plugin/ale/cursor.vim
View File

@@ -1,125 +0,0 @@
" Author: w0rp <devw0rp@gmail.com>
" Description: Echoes lint message for the current line, if any
if exists('g:loaded_ale_cursor')
finish
endif
let g:loaded_ale_cursor = 1
" Return a formatted message according to g:ale_echo_msg_format variable
function! s:GetMessage(linter, type, text) abort
let msg = g:ale_echo_msg_format
let type = a:type ==# 'E'
\ ? g:ale_echo_msg_error_str
\ : g:ale_echo_msg_warning_str
" Capitalize the 1st character
let text = toupper(a:text[0]) . a:text[1:-1]
" Replace handlers if they exist
for [k, v] in items({'linter': a:linter, 'severity': type})
let msg = substitute(msg, '\V%' . k . '%', v, '')
endfor
return printf(msg, text)
endfunction
" This function will perform a binary search to find a message from the
" loclist to echo when the cursor moves.
function! s:BinarySearch(loclist, line, column)
let min = 0
let max = len(a:loclist) - 1
let last_column_match = -1
while 1
if max < min
return last_column_match
endif
let mid = (min + max) / 2
let obj = a:loclist[mid]
" Binary search to get on the same line
if a:loclist[mid]['lnum'] < a:line
let min = mid + 1
elseif a:loclist[mid]['lnum'] > a:line
let max = mid - 1
else
let last_column_match = mid
" Binary search to get the same column, or near it
if a:loclist[mid]['col'] < a:column
let min = mid + 1
elseif a:loclist[mid]['col'] > a:column
let max = mid - 1
else
return mid
endif
endif
endwhile
endfunction
function! ale#cursor#TruncatedEcho(message)
let message = a:message
" Change tabs to spaces.
let message = substitute(message, "\t", ' ', 'g')
" Remove any newlines in the message.
let message = substitute(message, "\n", '', 'g')
" We need to turn T for truncated messages on for shortmess,
" and then then we need to reset the option back to what it was.
let shortmess_options = getbufvar('%', '&shortmess')
try
" Echo the message truncated to fit without creating a prompt.
setlocal shortmess+=T
exec "norm :echomsg message\n"
finally
call setbufvar('%', '&shortmess', shortmess_options)
endtry
endfunction
function! ale#cursor#EchoCursorWarning(...)
" Only echo the warnings in normal mode, otherwise we will get problems.
if mode() !=# 'n'
return
endif
let buffer = bufnr('%')
if !has_key(g:ale_buffer_loclist_map, buffer)
return
endif
let loclist = g:ale_buffer_loclist_map[buffer]
let pos = getcurpos()
let index = s:BinarySearch(loclist, pos[1], pos[2])
if index >= 0
let l = loclist[index]
let msg = s:GetMessage(l.linter_name, l.type, l.text)
call ale#cursor#TruncatedEcho(msg)
else
echo
endif
endfunction
let s:cursor_timer = -1
function! ale#cursor#EchoCursorWarningWithDelay()
if s:cursor_timer != -1
call timer_stop(s:cursor_timer)
let s:cursor_timer = -1
endif
let s:cursor_timer = timer_start(10, function('ale#cursor#EchoCursorWarning'))
endfunction
if g:ale_has_required_features && g:ale_echo_cursor
augroup ALECursorGroup
autocmd!
autocmd CursorMoved,CursorHold * call ale#cursor#EchoCursorWarningWithDelay()
augroup END
endif

82
plugin/ale/handlers.vim
View File

@@ -1,82 +0,0 @@
scriptencoding utf-8
" Author: w0rp <devw0rp@gmail.com>
" Description: This file defines some standard error format handlers. Any
" linter which outputs warnings and errors in a format accepted by one of
" these functions can simply use one of these pre-defined error handlers.
if exists('g:loaded_ale_handlers')
finish
endif
let g:loaded_ale_handlers = 1
function! ale#handlers#HandleGCCFormat(buffer, lines)
" Look for lines like the following.
"
" <stdin>:8:5: warning: conversion lacks type at end of format [-Wformat=]
" <stdin>:10:27: error: invalid operands to binary - (have ‘int’ and ‘char *’)
" -:189:7: note: $/${} is unnecessary on arithmetic variables. [SC2004]
let pattern = '^.\+:\(\d\+\):\(\d\+\): \([^:]\+\): \(.\+\)$'
let output = []
for line in a:lines
let l:match = matchlist(line, pattern)
if len(l:match) == 0
continue
endif
call add(output, {
\ 'bufnr': a:buffer,
\ 'lnum': l:match[1] + 0,
\ 'vcol': 0,
\ 'col': l:match[2] + 0,
\ 'text': l:match[4],
\ 'type': l:match[3] ==# 'error' ? 'E' : 'W',
\ 'nr': -1,
\})
endfor
return output
endfunction
function! ale#handlers#HandleCSSLintFormat(buffer, lines)
" Matches patterns line the following:
"
" something.css: line 2, col 1, Error - Expected RBRACE at line 2, col 1. (errors)
" something.css: line 2, col 5, Warning - Expected (inline | block | list-item | inline-block | table | inline-table | table-row-group | table-header-group | table-footer-group | table-row | table-column-group | table-column | table-cell | table-caption | grid | inline-grid | run-in | ruby | ruby-base | ruby-text | ruby-base-container | ruby-text-container | contents | none | -moz-box | -moz-inline-block | -moz-inline-box | -moz-inline-grid | -moz-inline-stack | -moz-inline-table | -moz-grid | -moz-grid-group | -moz-grid-line | -moz-groupbox | -moz-deck | -moz-popup | -moz-stack | -moz-marker | -webkit-box | -webkit-inline-box | -ms-flexbox | -ms-inline-flexbox | flex | -webkit-flex | inline-flex | -webkit-inline-flex) but found 'wat'. (known-properties)
"
" These errors can be very massive, so the type will be moved to the front
" so you can actually read the error type.
let pattern = '^.*: line \(\d\+\), col \(\d\+\), \(Error\|Warning\) - \(.\+\) (\([^)]\+\))$'
let output = []
for line in a:lines
let l:match = matchlist(line, pattern)
if len(l:match) == 0
continue
endif
let text = l:match[4]
let type = l:match[3]
let errorGroup = l:match[5]
" Put the error group at the front, so we can see what kind of error
" it is on small echo lines.
let text = '(' . errorGroup . ') ' . text
" vcol is Needed to indicate that the column is a character.
call add(output, {
\ 'bufnr': a:buffer,
\ 'lnum': l:match[1] + 0,
\ 'vcol': 0,
\ 'col': l:match[2] + 0,
\ 'text': text,
\ 'type': type ==# 'Warning' ? 'W' : 'E',
\ 'nr': -1,
\})
endfor
return output
endfunction

143
plugin/ale/sign.vim
View File

@@ -1,143 +0,0 @@
scriptencoding utf-8
" Author: w0rp <devw0rp@gmail.com>
" Description: Draws error and warning signs into signcolumn
if exists('g:loaded_ale_sign')
finish
endif
let g:loaded_ale_sign = 1
let b:dummy_sign_set_map = {}
if !hlexists('ALEErrorSign')
highlight link ALEErrorSign error
endif
if !hlexists('ALEWarningSign')
highlight link ALEWarningSign todo
endif
if !hlexists('ALEError')
highlight link ALEError SpellBad
endif
if !hlexists('ALEWarning')
highlight link ALEWarning SpellCap
endif
" Global variables for signs
let g:ale_sign_error = get(g:, 'ale_sign_error', '>>')
let g:ale_sign_warning = get(g:, 'ale_sign_warning', '--')
" An offset which can be set for sign IDs.
" This ID can be changed depending on what IDs are set for other plugins.
" The dummy sign will use the ID exactly equal to the offset.
let g:ale_sign_offset = get(g:, 'ale_sign_offset', 1000000)
" Signs show up on the left for error markers.
execute 'sign define ALEErrorSign text=' . g:ale_sign_error
\ . ' texthl=ALEErrorSign'
execute 'sign define ALEWarningSign text=' . g:ale_sign_warning
\ . ' texthl=ALEWarningSign'
sign define ALEDummySign
function! ale#sign#FindCurrentSigns(buffer)
" Matches output like :
" line=4 id=1 name=ALEErrorSign
" строка=1 id=1000001 имя=ALEErrorSign
let pattern = 'id=\(\d\+\).*=ALE\(Warning\|Error\)Sign'
redir => output
silent exec 'sign place buffer=' . a:buffer
redir END
let id_list = []
for line in split(output, "\n")
let match = matchlist(line, pattern)
if len(match) > 0
call add(id_list, match[1] + 0)
endif
endfor
return id_list
endfunction
" Given a loclist, combine the loclist into a list of signs such that only
" one sign appears per line. Error lines will take precedence.
" The loclist will have been previously sorted.
function! ale#sign#CombineSigns(loclist)
let signlist = []
for obj in a:loclist
let should_append = 1
if obj.lnum < 1
" Skip warnings and errors at line 0, etc.
continue
endif
if len(signlist) > 0 && signlist[-1].lnum == obj.lnum
" We can't add the same line twice, because signs must be
" unique per line.
let should_append = 0
if signlist[-1].type ==# 'W' && obj.type ==# 'E'
" If we had a warning previously, but now have an error,
" we replace the object to set an error instead.
let signlist[-1] = obj
endif
endif
if should_append
call add(signlist, obj)
endif
endfor
return signlist
endfunction
" This function will set the signs which show up on the left.
function! ale#sign#SetSigns(buffer, loclist)
let signlist = ale#sign#CombineSigns(a:loclist)
if len(signlist) > 0 || g:ale_sign_column_always
if !get(g:ale_buffer_sign_dummy_map, a:buffer, 0)
" 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
endif
endif
" Find the current signs with the markers we use.
let current_id_list = ale#sign#FindCurrentSigns(a:buffer)
" Remove those markers.
for current_id in current_id_list
exec 'sign unplace ' . current_id . ' buffer=' . a:buffer
endfor
" Now set all of the signs.
for i in range(0, len(signlist) - 1)
let obj = signlist[i]
let name = obj['type'] ==# 'W' ? 'ALEWarningSign' : 'ALEErrorSign'
let sign_line = 'sign place ' . (i + g:ale_sign_offset + 1)
\. ' line=' . obj['lnum']
\. ' name=' . name
\. ' buffer=' . a:buffer
exec sign_line
endfor
if !g:ale_sign_column_always && len(signlist) > 0
if get(g:ale_buffer_sign_dummy_map, a:buffer, 0)
execute 'sign unplace ' . g:ale_sign_offset . ' buffer=' . a:buffer
let g:ale_buffer_sign_dummy_map[a:buffer] = 0
endif
endif
endfunction

39
plugin/ale/statusline.vim
View File

@@ -1,39 +0,0 @@
" Author: KabbAmine <amine.kabb@gmail.com>
" Description: Statusline related function(s)
function! ALEGetStatusLine() abort
" Returns a formatted string that can be integrated in the
" statusline
let buf = bufnr('%')
let bufLoclist = g:ale_buffer_loclist_map
if !has_key(bufLoclist, buf)
return ''
endif
let errors = 0
let warnings = 0
for e in bufLoclist[buf]
if e.type ==# 'E'
let errors += 1
else
let warnings += 1
endif
endfor
let errors = errors ? printf(g:ale_statusline_format[0], errors) : ''
let warnings = warnings ? printf(g:ale_statusline_format[1], warnings) : ''
let no_errors = g:ale_statusline_format[2]
" Different formats if no errors or no warnings
if empty(errors) && empty(warnings)
let res = no_errors
elseif !empty(errors) && !empty(warnings)
let res = printf('%s %s', errors, warnings)
else
let res = empty(errors) ? warnings : errors
endif
return res
endfunction

43
plugin/ale/util.vim
View File

@@ -1,43 +0,0 @@
" Author: w0rp <devw0rp@gmail.com>
" Description: Contains miscellaneous functions
if exists('g:loaded_ale_util')
finish
endif
let g:loaded_ale_util = 1
function! s:FindWrapperScript()
for parent in split(&runtimepath, ',')
" Expand the path to deal with ~ issues.
let path = expand(parent . '/' . 'stdin-wrapper')
if filereadable(path)
if has('win32')
return path . '.exe'
endif
return path
endif
endfor
endfunction
let g:ale#util#stdin_wrapper = s:FindWrapperScript()
" Return the number of lines for a given buffer.
function! ale#util#GetLineCount(buffer)
return len(getbufline(a:buffer, 1, '$'))
endfunction
" Given a buffer and a filename, find the nearest file by searching upwards
" through the paths relative to the given buffer.
function! ale#util#FindNearestFile(buffer, filename)
return findfile(a:filename, fnamemodify(bufname(a:buffer), ':p') . ';')
endfunction
" A null file for sending output to nothing.
let g:ale#util#nul_file = '/dev/null'
if has('win32')
let g:ale#util#nul_file = 'nul'
endif

437
plugin/ale/zmain.vim
View File

@@ -1,437 +0,0 @@
" Author: w0rp <devw0rp@gmail.com>
" Description: Main entry point for this plugin
" Loads linters and manages lint jobs
if exists('g:loaded_ale_zmain')
finish
endif
let g:loaded_ale_zmain = 1
let s:lint_timer = -1
let s:linters = {}
if !exists('g:ale_linters')
let g:ale_linters = {}
endif
" Stores information for each job including:
"
" linter: The linter dictionary for the job.
" buffer: The buffer number for the job.
" output: The array of lines for the output of the job.
let s:job_info_map = {}
" Globals which each part of the plugin should use.
let g:ale_buffer_loclist_map = {}
let g:ale_buffer_should_reset_map = {}
let g:ale_buffer_sign_dummy_map = {}
function! s:GetFunction(string_or_ref)
if type(a:string_or_ref) == type('')
return function(a:string_or_ref)
endif
return a:string_or_ref
endfunction
function! s:ClearJob(job)
let job_id = s:GetJobID(a:job)
let linter = s:job_info_map[job_id].linter
if has('nvim')
call jobstop(a:job)
else
" We must close the channel for reading the buffer if it is open
" when stopping a job. Otherwise, we will get errors in the status line.
if ch_status(job_getchannel(a:job)) ==# 'open'
call ch_close_in(job_getchannel(a:job))
endif
call job_stop(a:job)
endif
call remove(s:job_info_map, job_id)
call remove(linter, 'job')
endfunction
function! s:GatherOutput(job, data)
let job_id = s:GetJobID(a:job)
if !has_key(s:job_info_map, job_id)
return
endif
call extend(s:job_info_map[job_id].output, a:data)
endfunction
function! s:GatherOutputNeoVim(job, data, event)
call s:GatherOutput(a:job, a:data)
endfunction
function! s:GatherOutputVim(channel, data)
call s:GatherOutput(ch_getjob(a:channel), [a:data])
endfunction
function! s:LocItemCompare(left, right)
if a:left['lnum'] < a:right['lnum']
return -1
endif
if a:left['lnum'] > a:right['lnum']
return 1
endif
if a:left['col'] < a:right['col']
return -1
endif
if a:left['col'] > a:right['col']
return 1
endif
return 0
endfunction
function! s:FixLoclist(buffer, loclist)
" Some errors have line numbers beyond the end of the file,
" so we need to adjust them so they set the error at the last line
" of the file instead.
let last_line_number = ale#util#GetLineCount(a:buffer)
for item in a:loclist
if item.lnum == 0
" When errors appear at line 0, put them at line 1 instead.
let item.lnum = 1
elseif item.lnum > last_line_number
let item.lnum = last_line_number
endif
endfor
endfunction
function! s:HandleExit(job)
if a:job ==# 'no process'
" Stop right away when the job is not valid in Vim 8.
return
endif
let job_id = s:GetJobID(a:job)
if !has_key(s:job_info_map, job_id)
return
endif
let job_info = s:job_info_map[job_id]
call s:ClearJob(a:job)
let linter = job_info.linter
let output = job_info.output
let buffer = job_info.buffer
let linter_loclist = s:GetFunction(linter.callback)(buffer, output)
" Make some adjustments to the loclists to fix common problems.
call s:FixLoclist(buffer, linter_loclist)
" Remember which linter returned these items for later use.
for obj in linter_loclist
let obj.linter_name = linter.name
endfor
if g:ale_buffer_should_reset_map[buffer]
let g:ale_buffer_should_reset_map[buffer] = 0
let g:ale_buffer_loclist_map[buffer] = []
endif
" Add the loclist items from the linter.
call extend(g:ale_buffer_loclist_map[buffer], linter_loclist)
" Sort the loclist again.
" We need a sorted list so we can run a binary search against it
" for efficient lookup of the messages in the cursor handler.
call sort(g:ale_buffer_loclist_map[buffer], 's:LocItemCompare')
if g:ale_set_loclist
call setloclist(0, g:ale_buffer_loclist_map[buffer])
endif
if g:ale_set_signs
call ale#sign#SetSigns(buffer, g:ale_buffer_loclist_map[buffer])
endif
" Mark line 200, column 17 with a squiggly line or something
" matchadd('ALEError', '\%200l\%17v')
endfunction
function! s:GetJobID(job)
if has('nvim')
"In NeoVim, job values are just IDs.
return a:job
endif
" In Vim 8, the job is a special variable, and we open a channel for each
" job. We'll use the ID of the channel instead as the job ID.
return ch_info(job_getchannel(a:job)).id
endfunction
function! s:HandleExitNeoVim(job, data, event)
call s:HandleExit(a:job)
endfunction
function! s:HandleExitVim(channel)
call s:HandleExit(ch_getjob(a:channel))
endfunction
function! s:ApplyLinter(buffer, linter)
if has_key(a:linter, 'job')
" Stop previous jobs for the same linter.
call s:ClearJob(a:linter.job)
endif
if has_key(a:linter, 'command_callback')
" If there is a callback for generating a command, call that instead.
let command = s:GetFunction(a:linter.command_callback)(a:buffer)
else
let command = a:linter.command
endif
if command =~# '%s'
" If there is a '%s' in the command string, replace it with the name
" of the file.
let command = printf(command, shellescape(fnamemodify(bufname(a:buffer), ':p')))
endif
if has('nvim')
if a:linter.output_stream ==# 'stderr'
" Read from stderr instead of stdout.
let job = jobstart(command, {
\ 'on_stderr': 's:GatherOutputNeoVim',
\ 'on_exit': 's:HandleExitNeoVim',
\})
elseif a:linter.output_stream ==# 'both'
let job = jobstart(command, {
\ 'on_stdout': 's:GatherOutputNeoVim',
\ 'on_stderr': 's:GatherOutputNeoVim',
\ 'on_exit': 's:HandleExitNeoVim',
\})
else
let job = jobstart(command, {
\ 'on_stdout': 's:GatherOutputNeoVim',
\ 'on_exit': 's:HandleExitNeoVim',
\})
endif
else
let job_options = {
\ 'in_mode': 'nl',
\ 'out_mode': 'nl',
\ 'err_mode': 'nl',
\ 'close_cb': function('s:HandleExitVim'),
\}
if a:linter.output_stream ==# 'stderr'
" Read from stderr instead of stdout.
let job_options.err_cb = function('s:GatherOutputVim')
elseif a:linter.output_stream ==# 'both'
" Read from both streams.
let job_options.out_cb = function('s:GatherOutputVim')
let job_options.err_cb = function('s:GatherOutputVim')
else
let job_options.out_cb = function('s:GatherOutputVim')
endif
if has('win32')
" job_start commands on Windows have to be run with cmd /c,
" othwerwise %PATHTEXT% will not be used to programs ending int
" .cmd, .bat, .exe, etc.
let l:command = 'cmd /c ' . l:command
else
" On Unix machines, we can send the Vim buffer directly.
" This is faster than reading the lines ourselves.
let job_options.in_io = 'buffer'
let job_options.in_buf = a:buffer
endif
" Vim 8 will read the stdin from the file's buffer.
let job = job_start(l:command, l:job_options)
endif
" Only proceed if the job is being run.
if has('nvim') || (job !=# 'no process' && job_status(job) ==# 'run')
let a:linter.job = job
" Store the ID for the job in the map to read back again.
let s:job_info_map[s:GetJobID(job)] = {
\ 'linter': a:linter,
\ 'buffer': a:buffer,
\ 'output': [],
\}
if has('nvim')
" In NeoVim, we have to send the buffer lines ourselves.
let input = join(getbufline(a:buffer, 1, '$'), "\n") . "\n"
call jobsend(job, input)
call jobclose(job, 'stdin')
elseif has('win32')
" On Windows, we have to send the buffer lines ourselves,
" as there are issues with Windows and 'in_buf'
let input = join(getbufline(a:buffer, 1, '$'), "\n") . "\n"
let channel = job_getchannel(job)
if ch_status(channel) ==# 'open'
call ch_sendraw(channel, input)
call ch_close_in(channel)
endif
endif
endif
endfunction
function! s:TimerHandler(...)
let filetype = &filetype
let linters = ALEGetLinters(filetype)
let buffer = bufnr('%')
" Set a variable telling us to clear the loclist later.
let g:ale_buffer_should_reset_map[buffer] = 1
for linter in linters
" Check if a given linter has a program which can be executed.
if has_key(linter, 'executable_callback')
let l:executable = s:GetFunction(linter.executable_callback)(buffer)
else
let l:executable = linter.executable
endif
if !executable(l:executable)
" The linter's program cannot be executed, so skip it.
continue
endif
call s:ApplyLinter(buffer, linter)
endfor
endfunction
function s:BufferCleanup(buffer)
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_loclist_map, a:buffer)
call remove(g:ale_buffer_loclist_map, a:buffer)
endif
if has_key(g:ale_buffer_sign_dummy_map, a:buffer)
call remove(g:ale_buffer_sign_dummy_map, a:buffer)
endif
endfunction
function! ALEAddLinter(filetype, linter)
if !has_key(s:linters, a:filetype)
let s:linters[a:filetype] = []
endif
let new_linter = {
\ 'name': a:linter.name,
\ 'callback': a:linter.callback,
\}
if has_key(a:linter, 'executable_callback')
let new_linter.executable_callback = a:linter.executable_callback
else
let new_linter.executable = a:linter.executable
endif
if has_key(a:linter, 'command_callback')
let new_linter.command_callback = a:linter.command_callback
else
let new_linter.command = a:linter.command
endif
if has_key(a:linter, 'output_stream')
let new_linter.output_stream = a:linter.output_stream
else
let new_linter.output_stream = 'stdout'
endif
" TODO: Assert the value of the output_stream to be something sensible.
call add(s:linters[a:filetype], new_linter)
endfunction
function! ALEGetLinters(filetype)
if !has_key(s:linters, a:filetype)
return []
endif
if has_key(g:ale_linters, a:filetype)
let linters = []
" Filter loaded linters according to list of linters specified in option
for linter in s:linters[a:filetype]
if index(g:ale_linters[a:filetype], linter.name) != -1
call add(linters, linter)
endif
endfor
return linters
endif
return s:linters[a:filetype]
endfunction
function! ALELint(delay)
let filetype = &filetype
let linters = ALEGetLinters(filetype)
if s:lint_timer != -1
call timer_stop(s:lint_timer)
let s:lint_timer = -1
endif
if len(linters) == 0
" There are no linters to lint with, so stop here.
return
endif
if a:delay > 0
let s:lint_timer = timer_start(a:delay, function('s:TimerHandler'))
else
call s:TimerHandler()
endif
endfunction
" Load all of the linters for each filetype.
runtime! ale_linters/*/*.vim
if !g:ale_has_required_features
echoerr 'ALE requires NeoVim >= 0.1.5 or Vim 8 with +timers +job +channel'
echoerr 'Please update your editor appropriately.'
finish
endif
if g:ale_lint_on_text_changed
augroup ALERunOnTextChangedGroup
autocmd!
autocmd TextChanged,TextChangedI * call ALELint(g:ale_lint_delay)
augroup END
endif
if g:ale_lint_on_enter
augroup ALERunOnEnterGroup
autocmd!
autocmd BufEnter,BufRead * call ALELint(100)
augroup END
endif
if g:ale_lint_on_save
augroup ALERunOnSaveGroup
autocmd!
autocmd BufWrite * call ALELint(0)
augroup END
endif
" Clean up buffers automatically when they are unloaded.
augroup ALEBuffferCleanup
autocmd!
autocmd BufUnload * call s:BufferCleanup('<abuf>')
augroup END