1472 lines
59 KiB
Plaintext
1472 lines
59 KiB
Plaintext
*ale.txt* For Vim version 8.0.
|
|
*ale*
|
|
|
|
ALE - Asynchronous Lint Engine
|
|
|
|
===============================================================================
|
|
CONTENTS *ale-contents*
|
|
|
|
1. Introduction.........................|ale-introduction|
|
|
2. Supported Languages & Tools..........|ale-support|
|
|
3. Global Options.......................|ale-options|
|
|
3.1 Highlights........................|ale-highlights|
|
|
4. Fixing Problems......................|ale-fix|
|
|
5. Integration Documentation............|ale-integrations|
|
|
asm...................................|ale-asm-options|
|
|
gcc.................................|ale-asm-gcc|
|
|
c.....................................|ale-c-options|
|
|
clang...............................|ale-c-clang|
|
|
cppcheck............................|ale-c-cppcheck|
|
|
gcc.................................|ale-c-gcc|
|
|
chef..................................|ale-chef-options|
|
|
foodcritic..........................|ale-chef-foodcritic|
|
|
cpp...................................|ale-cpp-options|
|
|
clang...............................|ale-cpp-clang|
|
|
clangcheck..........................|ale-cpp-clangcheck|
|
|
clangtidy...........................|ale-cpp-clangtidy|
|
|
cppcheck............................|ale-cpp-cppcheck|
|
|
cpplint.............................|ale-cpp-cpplint|
|
|
gcc.................................|ale-cpp-gcc|
|
|
css...................................|ale-css-options|
|
|
stylelint...........................|ale-css-stylelint|
|
|
cmake.................................|ale-cmake-options|
|
|
cmakelint...........................|ale-cmake-cmakelint|
|
|
erlang................................|ale-erlang-options|
|
|
erlc................................|ale-erlang-erlc|
|
|
fortran...............................|ale-fortran-options|
|
|
gcc.................................|ale-fortran-gcc|
|
|
fusionscript..........................|ale-fuse-options|
|
|
fusion-lint.........................|ale-fuse-fusionlint|
|
|
go....................................|ale-go-options|
|
|
gometalinter........................|ale-go-gometalinter|
|
|
handlebars............................|ale-handlebars-options|
|
|
ember-template-lint.................|ale-handlebars-embertemplatelint|
|
|
html..................................|ale-html-options|
|
|
htmlhint............................|ale-html-htmlhint|
|
|
tidy................................|ale-html-tidy|
|
|
java..................................|ale-java-options|
|
|
checkstyle..........................|ale-java-checkstyle|
|
|
javac...............................|ale-java-javac|
|
|
javascript............................|ale-javascript-options|
|
|
eslint..............................|ale-javascript-eslint|
|
|
flow................................|ale-javascript-flow|
|
|
jshint..............................|ale-javascript-jshint|
|
|
prettier............................|ale-javascript-prettier|
|
|
prettier-eslint.....................|ale-javascript-prettier-eslint|
|
|
standard............................|ale-javascript-standard|
|
|
xo..................................|ale-javascript-xo|
|
|
kotlin................................|ale-kotlin-options|
|
|
kotlinc.............................|ale-kotlin-kotlinc|
|
|
lua...................................|ale-lua-options|
|
|
luacheck............................|ale-lua-luacheck|
|
|
objc..................................|ale-objc-options|
|
|
clang...............................|ale-objc-clang|
|
|
objcpp................................|ale-objcpp-options|
|
|
clang...............................|ale-objcpp-clang|
|
|
ocaml.................................|ale-ocaml-options|
|
|
merlin..............................|ale-ocaml-merlin|
|
|
perl..................................|ale-perl-options|
|
|
perl................................|ale-perl-perl|
|
|
perlcritic..........................|ale-perl-perlcritic|
|
|
php...................................|ale-php-options|
|
|
phpcs...............................|ale-php-phpcs|
|
|
phpmd...............................|ale-php-phpmd|
|
|
python................................|ale-python-options|
|
|
autopep8............................|ale-python-autopep8|
|
|
flake8..............................|ale-python-flake8|
|
|
isort...............................|ale-python-isort|
|
|
mypy................................|ale-python-mypy|
|
|
pylint..............................|ale-python-pylint|
|
|
yapf................................|ale-python-yapf|
|
|
ruby..................................|ale-ruby-options|
|
|
reek................................|ale-ruby-reek|
|
|
rubocop.............................|ale-ruby-rubocop|
|
|
rust..................................|ale-rust-options|
|
|
cargo...............................|ale-rust-cargo|
|
|
rustc...............................|ale-rust-rustc|
|
|
sass..................................|ale-sass-options|
|
|
stylelint...........................|ale-sass-stylelint|
|
|
scss..................................|ale-scss-options|
|
|
stylelint...........................|ale-scss-stylelint|
|
|
sh....................................|ale-sh-options|
|
|
shell...............................|ale-sh-shell|
|
|
shellcheck..........................|ale-sh-shellcheck|
|
|
spec..................................|ale-spec-options|
|
|
rpmlint.............................|ale-spec-rpmlint|
|
|
tex...................................|ale-tex-options|
|
|
chktex..............................|ale-tex-chktex|
|
|
lacheck.............................|ale-tex-lacheck|
|
|
typescript............................|ale-typescript-options|
|
|
eslint..............................|ale-typescript-eslint|
|
|
tslint..............................|ale-typescript-tslint|
|
|
tsserver............................|ale-typescript-tsserver|
|
|
vim...................................|ale-vim-options|
|
|
vint................................|ale-vim-vint|
|
|
xml...................................|ale-xml-options|
|
|
xmllint.............................|ale-xml-xmllint|
|
|
yaml..................................|ale-yaml-options|
|
|
yamllint............................|ale-yaml-yamllint|
|
|
6. Commands/Keybinds....................|ale-commands|
|
|
7. API..................................|ale-api|
|
|
8. Special Thanks.......................|ale-special-thanks|
|
|
9. Contact..............................|ale-contact|
|
|
|
|
===============================================================================
|
|
1. Introduction *ale-introduction*
|
|
|
|
ALE provides the means to run linters asynchronously in Vim in a variety of
|
|
languages and tools. ALE sends the contents of buffers to linter programs
|
|
using the |job-control| features available in Vim 8 and NeoVim. For Vim 8,
|
|
Vim must be compiled with the |job| and |channel| and |timer| features
|
|
as a minimum.
|
|
|
|
ALE supports the following key features for linting:
|
|
|
|
1. Running linters when text is changed.
|
|
2. Running linters when files are opened.
|
|
3. Running linters when files are saved. (When a global flag is set.)
|
|
4. Populating the |loclist| with warning and errors.
|
|
5. Setting |signs| with warnings and errors for error markers.
|
|
6. Using |echo| to show error messages when the cursor moves.
|
|
7. Setting syntax highlights for errors.
|
|
|
|
ALE can fix problems with files with the |ALEFix| command, using the same job
|
|
control functionality used for checking for problems. Try using the
|
|
|ALEFixSuggest| command for browsing tools that can be used to fix problems
|
|
for the current buffer.
|
|
|
|
===============================================================================
|
|
2. Supported Languages & Tools *ale-support*
|
|
|
|
The following languages and tools are supported.
|
|
|
|
* ASM: 'gcc'
|
|
* Ansible: 'ansible-lint'
|
|
* Asciidoc: 'proselint'
|
|
* Bash: 'shell' (-n flag), 'shellcheck'
|
|
* Bourne Shell: 'shell' (-n flag), 'shellcheck'
|
|
* C: 'cppcheck', 'gcc', 'clang'
|
|
* C++ (filetype cpp): 'clang', 'clangtidy', 'cppcheck', 'cpplint', 'gcc'
|
|
* C#: 'mcs'
|
|
* Chef: 'foodcritic'
|
|
* CMake: 'cmakelint'
|
|
* CoffeeScript: 'coffee', 'coffelint'
|
|
* Crystal: 'crystal'
|
|
* CSS: 'csslint', 'stylelint'
|
|
* Cython (pyrex filetype): 'cython'
|
|
* D: 'dmd'
|
|
* Dockerfile: 'hadolint'
|
|
* Elixir: 'credo', 'dogma'
|
|
* Elm: 'elm-make'
|
|
* Erlang: 'erlc'
|
|
* Fortran: 'gcc'
|
|
* Go: 'gofmt', 'go vet', 'golint', 'go build', 'gosimple', 'staticcheck'
|
|
* FusionScript: 'fusion-lint'
|
|
* Haml: 'hamllint'
|
|
* Handlebars: 'ember-template-lint'
|
|
* Haskell: 'ghc', 'ghc-mod', 'hlint', 'hdevtools'
|
|
* HTML: 'HTMLHint', 'proselint', 'tidy'
|
|
* Java: 'javac'
|
|
* JavaScript: 'eslint', 'jscs', 'jshint', 'flow', 'prettier', 'prettier-eslint', 'xo'
|
|
* JSON: 'jsonlint'
|
|
* Kotlin: 'kotlinc'
|
|
* LaTeX (tex): 'chktex', 'lacheck', 'proselint'
|
|
* Lua: 'luacheck'
|
|
* Markdown: 'mdl', 'proselint', 'vale'
|
|
* MATLAB: 'mlint'
|
|
* nim: 'nim check'
|
|
* nix: 'nix-instantiate'
|
|
* nroff: 'proselint'
|
|
* Objective-C: 'clang'
|
|
* Objective-C++: 'clang'
|
|
* OCaml: 'merlin' (see |ale-linter-integration-ocaml-merlin|)
|
|
* Perl: 'perl' (-c flag), 'perlcritic'
|
|
* PHP: 'hack', 'php' (-l flag), 'phpcs', 'phpmd'
|
|
* Pod: 'proselint'
|
|
* Pug: 'pug-lint'
|
|
* Puppet: 'puppet', 'puppet-lint'
|
|
* Python: 'autopep8', 'flake8', 'isort', 'mypy', 'pylint', 'yapf'
|
|
* ReasonML: 'merlin'
|
|
* reStructuredText: 'proselint'
|
|
* RPM spec: 'spec'
|
|
* Rust: 'rustc' (see |ale-integration-rust|)
|
|
* Ruby: 'reek', 'rubocop'
|
|
* SASS: 'sasslint', 'stylelint'
|
|
* SCSS: 'sasslint', 'scsslint', 'stylelint'
|
|
* Scala: 'scalac'
|
|
* Slim: 'slim-lint'
|
|
* SML: 'smlnj'
|
|
* SQL: 'sqlint'
|
|
* Swift: 'swiftlint'
|
|
* Texinfo: 'proselint'
|
|
* Text: 'proselint', 'vale'
|
|
* TypeScript: 'eslint', 'tslint', 'tsserver', 'typecheck'
|
|
* Verilog: 'iverilog', 'verilator'
|
|
* Vim: 'vint'
|
|
* Vim help: 'proselint'
|
|
* XHTML: 'proselint'
|
|
* XML: 'xmllint'
|
|
* YAML: 'yamllint'
|
|
|
|
===============================================================================
|
|
3. Global Options *ale-options*
|
|
|
|
g:airline#extensions#ale#enabled *g:airline#extensions#ale#enabled*
|
|
|
|
Type: |Number|
|
|
Default: `1`
|
|
|
|
Enables or disables the |airline|'s native extension for ale, which displays
|
|
warnings and errors in the status line, prefixed by
|
|
|airline#extensions#ale#error_symbol| and
|
|
|airline#extensions#ale#warning_symbol|.
|
|
|
|
|
|
g:ale_change_sign_column_color *g:ale_change_sign_column_color*
|
|
|
|
Type: |Number|
|
|
Default: `0`
|
|
|
|
When set to `1`, this option will set different highlights for the sign
|
|
column itself when ALE reports problems with a file. This option can be
|
|
combined with |g:ale_sign_column_always|.
|
|
|
|
ALE uses the following highlight groups for highlighting the sign column:
|
|
|
|
`ALESignColumnWithErrors` - Links to `error` by default.
|
|
`ALESignColumnWithoutErrors` - Uses the value for `SignColumn` by default.
|
|
|
|
The sign column color can only be changed globally in Vim. The sign column
|
|
might produce unexpected results if editing different files in split
|
|
windows.
|
|
|
|
|
|
g:ale_echo_cursor *g:ale_echo_cursor*
|
|
|
|
Type: |Number|
|
|
Default: `1`
|
|
|
|
When this option is set to `1`, a truncated message will be echoed when a
|
|
cursor is near a warning or error. ALE will attempt to find the warning or
|
|
error at a column nearest to the cursor when the cursor is resting on a line
|
|
which contains a warning or error. This option can be set to `0` to disable
|
|
this behaviour.
|
|
The format of the message can be customizable in |g:ale_echo_msg_format|.
|
|
|
|
|
|
g:ale_echo_msg_error_str *g:ale_echo_msg_error_str*
|
|
|
|
Type: |String|
|
|
Default: `Error`
|
|
|
|
The string used for error severity in the echoed message.
|
|
Note |`g:ale_echo_cursor`| should be set to 1
|
|
Note |`g:ale_echo_msg_format`| should contain the `%severity%` handler
|
|
|
|
|
|
g:ale_echo_msg_format *g:ale_echo_msg_format*
|
|
|
|
Type: |String|
|
|
Default: `%s`
|
|
|
|
This variable defines the format of the echoed message. The `%s` is the
|
|
error message itself, and it can contain the following handlers:
|
|
- `%linter%` for linter's name
|
|
- `%severity%` for the type of severity
|
|
Note |`g:ale_echo_cursor`| should be setted to 1
|
|
|
|
|
|
g:ale_echo_msg_warning_str *g:ale_echo_msg_warning_str*
|
|
|
|
Type: |String|
|
|
Default: `Warning`
|
|
|
|
The string used for warning severity in the echoed message.
|
|
Note |`g:ale_echo_cursor`| should be set to 1
|
|
Note |`g:ale_echo_msg_format`| should contain the `%severity%` handler
|
|
|
|
|
|
g:ale_emit_conflict_warnings *g:ale_emit_conflict_warnings*
|
|
|
|
Type: |Number|
|
|
Default: `1`
|
|
|
|
When set to `0`, ALE will not emit any warnings on startup about conflicting
|
|
plugins. ALE will probably not work if other linting plugins are installed.
|
|
|
|
|
|
g:ale_enabled *g:ale_enabled*
|
|
*b:ale_enabled*
|
|
|
|
Type: |Number|
|
|
Default: `1`
|
|
|
|
When set to `0`, this option will completely disable ALE, such that no
|
|
error checking will be performed, etc. ALE can be toggled on and off with
|
|
the |ALEToggle| command, which changes this option.
|
|
|
|
ALE can be disabled in each buffer by setting `let b:ale_enabled = 0`
|
|
Disabling ALE based on filename patterns can be accomplished by setting
|
|
a regular expression for |g:ale_pattern_options|. For example: >
|
|
|
|
" Disable linting for all minified JS files.
|
|
let g:ale_pattern_options = {'\.min.js$': {'ale_enabled': 0}}
|
|
<
|
|
|
|
See |g:ale_pattern_options| for more information on that option.
|
|
|
|
|
|
g:ale_fixers *g:ale_fixers*
|
|
*b:ale_fixers*
|
|
|
|
Type: |Dictionary|
|
|
Default: `{}`
|
|
|
|
A mapping from filetypes to |List| values for functions for fixing errors.
|
|
See |ale-fix| for more information.
|
|
|
|
This variable can be overriden with variables in each buffer.
|
|
|
|
|
|
g:ale_fix_on_save *g:ale_fix_on_save*
|
|
|
|
Type: |Number|
|
|
Default: `0`
|
|
|
|
When set to 1, ALE will fix files when they are saved.
|
|
|
|
If |g:ale_lint_on_save| is set to 1, files will be checked with linters
|
|
after files are fixed, only when the buffer is open, or re-opened. Changes
|
|
to the file will be saved to the file on disk.
|
|
|
|
|
|
g:ale_history_enabled *g:ale_history_enabled*
|
|
|
|
Type: |Number|
|
|
Default: `1`
|
|
|
|
When set to `1`, ALE will remember the last few commands which were run
|
|
for every buffer which is open. This information can be viewed with the
|
|
|ALEInfo| command. The size of the buffer can be controlled with the
|
|
|g:ale_max_buffer_history_size| option.
|
|
|
|
This option can be disabled if storing a command history is not desired.
|
|
|
|
|
|
g:ale_history_log_output *g:ale_history_log_output*
|
|
|
|
Type: |Number|
|
|
Default: `0`
|
|
|
|
When set to `1`, ALE will store the output of commands which have completed
|
|
successfully in the command history, and the output will be displayed when
|
|
using |ALEInfo|.
|
|
|
|
|g:ale_history_enabled| must be set to `1` for this output to be stored or
|
|
printed.
|
|
|
|
ALE will likely consume a lot of memory if this option is on, so it should
|
|
only be used for debugging problems with linters.
|
|
|
|
|
|
g:ale_keep_list_window_open *g:ale_keep_list_window_open*
|
|
|
|
Type: |Number|
|
|
Default: `0`
|
|
|
|
When set to `1`, this option will keep the loclist or quickfix windows
|
|
event after all warnings/errors have been removed for files. By default
|
|
the loclist or quicfix windows will be closed automatically when there
|
|
are no warnings or errors.
|
|
|
|
See: |g:ale_open_list|
|
|
|
|
|
|
g:ale_list_window_size *g:ale_list_window_size*
|
|
*b:ale_list_window_size*
|
|
Type: |Number|
|
|
Default: `10`
|
|
|
|
This number configures the number of lines to set for the height of windows
|
|
opened automatically for ALE problems. The default of `10` matches the Vim
|
|
default height.
|
|
|
|
See |g:ale_open_list| for information on automatically opening windows
|
|
for quickfix or the loclist.
|
|
|
|
|
|
g:ale_lint_delay *g:ale_lint_delay*
|
|
|
|
Type: |Number|
|
|
Default: `200`
|
|
|
|
This variable controls the milliseconds delay after which the linters will
|
|
be run after text is changed. This option is only meaningful with the
|
|
|g:ale_lint_on_text_changed| variable set to `always`, `insert`, or `normal`.
|
|
|
|
|
|
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.
|
|
|
|
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.
|
|
|
|
|
|
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.
|
|
|
|
|
|
g:ale_lint_on_save *g:ale_lint_on_save*
|
|
|
|
Type: |Number|
|
|
Default: `1`
|
|
|
|
This option will make ALE run the linters whenever a file is saved when it
|
|
it set to `1` in your vimrc file. This option can be used in combination
|
|
with the |g:ale_lint_on_enter| and |g:ale_lint_on_text_changed| options to
|
|
make ALE only check files after that have been saved, if that is what is
|
|
desired.
|
|
|
|
|
|
g:ale_lint_on_text_changed *g:ale_lint_on_text_changed*
|
|
|
|
Type: |String|
|
|
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.
|
|
|
|
|
|
g:ale_lint_on_insert_leave *g:ale_lint_on_insert_leave*
|
|
|
|
Type: |Number|
|
|
Default: `0`
|
|
|
|
This option will make ALE run the linters whenever leaving insert mode when
|
|
it is set to `1` in your vimrc file.
|
|
|
|
|
|
g:ale_linter_aliases *g:ale_linter_aliases*
|
|
*b:ale_linter_aliases*
|
|
Type: |Dictionary|
|
|
Default: `{}`
|
|
|
|
The |g:ale_linter_aliases| option can be used to set aliases from one
|
|
filetype to another. A given filetype can be mapped to use the linters
|
|
run for another given filetype.
|
|
|
|
This |Dictionary| will be merged with a default dictionary containing the
|
|
following values: >
|
|
|
|
{
|
|
\ 'zsh': 'sh',
|
|
\ 'csh': 'sh',
|
|
\}
|
|
<
|
|
For example, if you wish to map a new filetype `'foobar'` to run the `'php'`
|
|
linters, you could set the following: >
|
|
|
|
let g:ale_linter_aliases = {'foobar': 'php'}
|
|
<
|
|
When combined with the |g:ale_linters| option, the original filetype
|
|
(`'foobar'`) will be used for determining which linters to run,
|
|
not the aliased type (`'php'`). This allows an aliased type to run a
|
|
different set of linters from the type it is being mapped to.
|
|
|
|
Passing a list of filetypes is also supported. Say you want to lint
|
|
javascript and css embedded in HTML (using linters that support that).
|
|
You could alias `html` like so:
|
|
|
|
`let g:ale_linter_aliases = {'html': ['html', 'javascript', 'css']}`
|
|
|
|
Note that `html` itself was included as an alias. That is because aliases
|
|
will override the original linters for the aliased filetepe.
|
|
|
|
Linter aliases can be configured in each buffer with buffer-local variables.
|
|
ALE will first look for aliases for filetypes in the `b:ale_linter_aliases`
|
|
variable, then `g:ale_linter_aliases`, and then a default Dictionary.
|
|
|
|
|
|
g:ale_linters *g:ale_linters*
|
|
*b:ale_linters*
|
|
Type: |Dictionary|
|
|
Default: `{}`
|
|
|
|
The |g:ale_linters| option sets a |Dictionary| mapping a filetype
|
|
to a |List| of linter programs to be run when checking particular filetypes.
|
|
Only the filetypes specified in the dictionary will be limited in terms
|
|
of which linters will be run.
|
|
|
|
This |Dictionary| will be merged with a default dictionary containing the
|
|
following values: >
|
|
|
|
{
|
|
\ 'csh': ['shell'],
|
|
\ 'rust': ['cargo'],
|
|
\ 'text': [],
|
|
\ 'zsh': ['shell'],
|
|
\}
|
|
<
|
|
This option can be used to enable only a particular set of linters for a
|
|
file. For example, you can enable only 'eslint' for JavaScript files: >
|
|
|
|
let g:ale_linters = {'javascript': ['eslint']}
|
|
<
|
|
If you want to disable all linters for a particular filetype, you can pass
|
|
an empty list of linters as the value: >
|
|
|
|
let g:ale_linters = {'javascript': []}
|
|
<
|
|
All linters available for a given filetype can be enabled by using the
|
|
string `'all'`: >
|
|
|
|
let g:ale_linters = {'c': 'all'}
|
|
<
|
|
Linters can be configured in each buffer with buffer-local variables. ALE
|
|
will first look for linters for filetypes in the `b:ale_linters` variable,
|
|
then `g:ale_linters`, and then a default Dictionary.
|
|
|
|
|
|
g:ale_max_buffer_history_size *g:ale_max_buffer_history_size*
|
|
|
|
Type: |Number|
|
|
Default: `20`
|
|
|
|
This setting controls the maximum number of commands which will be stored in
|
|
the command history used for |ALEInfo|. Command history will be rotated in
|
|
a FIFO manner. If set to a number <= 0, then the history will be
|
|
continuously set to an empty |List|.
|
|
|
|
History can be disabled completely with |g:ale_history_enabled|.
|
|
|
|
|
|
g:ale_maximum_file_size *g:ale_maximum_file_size*
|
|
*b:ale_maximum_file_size*
|
|
Type: |Number|
|
|
Default: `0`
|
|
|
|
A maximum file size in bytes for ALE to check. If set to any positive
|
|
number, ALE will skip checking files larger than the given size.
|
|
|
|
|
|
g:ale_open_list *g:ale_open_list*
|
|
|
|
Type: |Number|
|
|
Default: `0`
|
|
|
|
When set to `1`, this will cause ALE to automatically open a window for
|
|
the loclist (|lopen|) or for the quickfix list instead if
|
|
|g:ale_set_quickfix| is `1`. (|copen|)
|
|
|
|
The window will be kept open until all warnings or errors are cleared,
|
|
including those not set by ALE, unless |g:ale_keep_list_window_open| is set
|
|
to `1`, in which case the window will be kept open until closed manually.
|
|
|
|
The window size can be configured with |g:ale_list_window_size|.
|
|
|
|
|
|
g:ale_pattern_options *g:ale_pattern_options*
|
|
|
|
Type: |Dictionary|
|
|
Default: `{}`
|
|
|
|
This option maps regular expression patterns to |Dictionary| values for
|
|
buffer variables. This option can be set to automatically configure
|
|
different settings for different files. For example: >
|
|
|
|
let g:ale_pattern_options = {
|
|
\ '\.foo\.js$': {
|
|
\ 'ale_linters: {'javascript': ['eslint']},
|
|
\ },
|
|
\}
|
|
<
|
|
The above example will match any filename ending in `.foo.js`, and use
|
|
only `eslint` for checking those files by setting `b:ale_linters`.
|
|
|
|
Filenames are matched with |match()|, and patterns depend on the |magic|
|
|
setting, unless prefixed with the special escape sequences like `'\v'`, etc.
|
|
|
|
The patterns can match any part of a filename. The absolute path of the
|
|
filename will be used for matching, taken from `expand('%:p')`.
|
|
|
|
|
|
g:ale_pattern_options_enabled *g:ale_pattern_options_enabled*
|
|
|
|
Type: |Number|
|
|
Default: `!empty(g:ale_pattern_options)`
|
|
|
|
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.
|
|
|
|
|
|
g:ale_set_balloons *g:ale_set_balloons*
|
|
|
|
Type: |Number|
|
|
Default: `has('balloon_eval')`
|
|
|
|
When this option is set to `1`, balloon messages will be displayed for
|
|
problems. Problems nearest to the cursor on the line the cursor is over will
|
|
be displayed.
|
|
|
|
|
|
g:ale_set_highlights *g:ale_set_highlights*
|
|
|
|
Type: |Number|
|
|
Default: `has('syntax')`
|
|
|
|
When this option is set to `1`, highlights will be set for problems.
|
|
|
|
ALE will use the following highlight groups for problems:
|
|
|
|
|ALEError| - Items with `'type': 'E'`
|
|
|ALEWarning| - Items with `'type': 'W'`
|
|
|ALEInfo.| - Items with `'type': 'I'`
|
|
|ALEStyleError| - Items with `'type': 'E'` and `'sub_type': 'style'`
|
|
|ALEStyleWarning| - Items with `'type': 'W'` and `'sub_type': 'style'`
|
|
|
|
|
|
g:ale_set_loclist *g:ale_set_loclist*
|
|
|
|
Type: |Number|
|
|
Default: `1`
|
|
|
|
When this option is set to `1`, the |loclist| will be populated with any
|
|
warnings and errors which are found by ALE. This feature can be used to
|
|
implement jumping between errors through typical use of |lnext| and |lprev|.
|
|
|
|
|
|
g:ale_set_quickfix *g:ale_set_quickfix*
|
|
|
|
Type: |Number|
|
|
Default: `0`
|
|
|
|
When this option is set to `1`, the |quickfix| list will be populated with any
|
|
warnings and errors which are found by ALE, instead of the |loclist|. The
|
|
loclist will never be populated when this option is on.
|
|
|
|
|
|
g:ale_set_signs *g:ale_set_signs*
|
|
|
|
Type: |Number|
|
|
Default: `has('signs')`
|
|
|
|
When this option is set to `1`, the |sign| column will be populated with
|
|
signs marking where problems appear in the file.
|
|
|
|
ALE will use the following highlight groups for problems:
|
|
|
|
|ALEErrorSign| - Items with `'type': 'E'`
|
|
|ALEWarningSign| - Items with `'type': 'W'`
|
|
|ALEInfoSign| - Items with `'type': 'I'`
|
|
|ALEStyleErrorSign| - Items with `'type': 'E'` and `'sub_type': 'style'`
|
|
|ALEStyleWarningSign| - Items with `'type': 'W'` and `'sub_type': 'style'`
|
|
|
|
In addition to the style of the signs, the style of lines where signs appear
|
|
can be configured with the following highlights:
|
|
|
|
|ALEErrorLine| - All items with `'type': 'E'`
|
|
|ALEWarningLine| - All items with `'type': 'W'`
|
|
|ALEInfoLine| - All items with `'type': 'I'`
|
|
|
|
The markers for the highlights can be customized with the following options:
|
|
|
|
|g:ale_sign_error|
|
|
|g:ale_sign_warning|
|
|
|g:ale_sign_info|
|
|
|g:ale_sign_style_error|
|
|
|g:ale_sign_style_warning|
|
|
|
|
When multiple problems exist on the same line, the signs will take
|
|
precedence in the order above, from highest to lowest.
|
|
|
|
|
|
g:ale_sign_column_always *g:ale_sign_column_always*
|
|
|
|
Type: |Number|
|
|
Default: `0`
|
|
|
|
By default, the sign gutter will disappear when all warnings and errors have
|
|
been fixed for a file. When this option is set to `1`, the sign column will
|
|
remain open. This can be preferable if you don't want the text in your file
|
|
to move around as you edit a file.
|
|
|
|
|
|
g:ale_sign_error *g:ale_sign_error*
|
|
|
|
Type: |String|
|
|
Default: `'>>'`
|
|
|
|
The sign for errors in the sign gutter.
|
|
|
|
|
|
g:ale_sign_info *g:ale_sign_info*
|
|
|
|
Type: |String|
|
|
Default: `g:ale_sign_warning`
|
|
|
|
The sign for "info" markers in the sign gutter.
|
|
|
|
|
|
g:ale_sign_style_error *g:ale_sign_style_error*
|
|
|
|
Type: |String|
|
|
Default: `g:ale_sign_error`
|
|
|
|
The sign for style errors in the sign gutter.
|
|
|
|
|
|
g:ale_sign_style_warning *g:ale_sign_style_warning*
|
|
|
|
Type: |String|
|
|
Default: `g:ale_sign_warning`
|
|
|
|
The sign for style warnings in the sign gutter.
|
|
|
|
|
|
g:ale_sign_offset *g:ale_sign_offset*
|
|
|
|
Type: |Number|
|
|
Default: `1000000`
|
|
|
|
This variable controls offset from which numeric IDs will be generated for
|
|
new signs. Signs cannot share the same ID values, so when two Vim plugins
|
|
set signs at the same time, the IDs have to be configured such that they do
|
|
not conflict with one another. If the IDs used by ALE are found to conflict
|
|
with some other plugin, this offset value can be changed, and hopefully both
|
|
plugins will work together. See |sign-place| for more information on how
|
|
signs are set.
|
|
|
|
|
|
g:ale_sign_warning *g:ale_sign_warning*
|
|
|
|
Type: |String|
|
|
Default: `'--'`
|
|
|
|
The sign for warnings in the sign gutter.
|
|
|
|
|
|
g:ale_type_map *g:ale_type_map*
|
|
*b:ale_type_map*
|
|
Type: |Dictionary|
|
|
Default: `{}`
|
|
|
|
This option can be set re-map problem types for linters. Each key in
|
|
the |Dictionary| should be the name of a linter, and each value must be
|
|
a |Dictionary| mapping error types from one type to another. The
|
|
following types are supported:
|
|
|
|
`'E'` - `{'type': 'E'}`
|
|
`'ES'` - `{'type': 'E', 'sub_type': 'style'}`
|
|
`'W'` - `{'type': 'W'}`
|
|
`'WS'` - `{'type': 'W', 'sub_type': 'style'}`
|
|
`'I'` - `{'type': 'I'}`
|
|
|
|
For example, if you want to turn flake8 errors into warnings, you can do
|
|
the following: >
|
|
|
|
let g:ale_type_map = {'flake8', {'ES': 'WS', 'E': 'W'}}
|
|
<
|
|
If you wanted to turn style errors and warnings into regular errors and
|
|
warnings, you can use the following: >
|
|
|
|
let g:ale_type_map = {'flake8', {'ES': 'E', 'WS': 'W'}}
|
|
<
|
|
Type maps can be set per-buffer with `b:ale_type_map`.
|
|
|
|
|
|
g:ale_warn_about_trailing_whitespace *g:ale_warn_about_trailing_whitespace*
|
|
b:ale_warn_about_trailing_whitespace *b:ale_warn_about_trailing_whitespace*
|
|
|
|
Type: |Number|
|
|
Default: `1`
|
|
|
|
When this option is set to `1`, warnings relating to trailing whitespace on
|
|
lines will be shown in signs, the loclist, and echo messages, etc. If these
|
|
errors are found to be too irritating while edits are being made, and you
|
|
have configured Vim to automatically remove trailing whitespace, then you
|
|
can disable these warnings for some linters by setting this option to `0`.
|
|
|
|
Not all linters may respect this option. If a linter does not, please file a
|
|
bug report, and it may be possible to add such support.
|
|
|
|
This option may be configured on a per buffer basis.
|
|
|
|
|
|
-------------------------------------------------------------------------------
|
|
3.1. Highlights *ale-highlights*
|
|
|
|
ALEError *ALEError*
|
|
|
|
Default: `highlight link ALEError SpellBad`
|
|
|
|
The highlight used for highlighted errors. See |g:ale_set_highlights|.
|
|
|
|
|
|
ALEErrorLine *ALEErrorLine*
|
|
|
|
Default: Undefined
|
|
|
|
The highlight for lines where error signs appear. See |g:ale_set_signs|.
|
|
|
|
|
|
ALEErrorSign *ALEErrorSign*
|
|
|
|
Default: `highlight link ALEErrorSign error`
|
|
|
|
The highlight used for error signs. See |g:ale_set_signs|.
|
|
|
|
|
|
ALEInfo *ALEInfo.*
|
|
*ALEInfo-highlight*
|
|
Default: `highlight link ALEInfo ALEWarning`
|
|
|
|
The highlight used for highlighted info messages. See |g:ale_set_highlights|.
|
|
|
|
|
|
ALEInfoSign *ALEInfoSign*
|
|
|
|
Default: `highlight link ALEInfoSign ALEWarningSign`
|
|
|
|
The highlight used for info message signs. See |g:ale_set_signs|.
|
|
|
|
|
|
ALEInfoLine *ALEInfoLine*
|
|
|
|
Default: Undefined
|
|
|
|
The highlight for lines where info signs appear. See |g:ale_set_signs|.
|
|
|
|
|
|
ALEStyleError *ALEStyleError*
|
|
|
|
Default: `highlight link ALEStyleError ALEError`
|
|
|
|
The highlight used for highlighted style errors. See |g:ale_set_highlights|.
|
|
|
|
|
|
ALEStyleErrorSign *ALEStyleErrorSign*
|
|
|
|
Default: `highlight link ALEStyleErrorSign ALEErrorSign`
|
|
|
|
The highlight used for style error signs. See |g:ale_set_signs|.
|
|
|
|
|
|
ALEStyleWarning *ALEStyleWarning*
|
|
|
|
Default: `highlight link ALEStyleWarning ALEError`
|
|
|
|
The highlight used for highlighted style warnings. See |g:ale_set_highlights|.
|
|
|
|
|
|
ALEStyleWarningSign *ALEStyleWarningSign*
|
|
|
|
Default: `highlight link ALEStyleWarningSign ALEWarningSign`
|
|
|
|
The highlight used for style warning signs. See |g:ale_set_signs|.
|
|
|
|
|
|
ALEWarning *ALEWarning*
|
|
|
|
Default: `highlight link ALEWarning SpellCap`
|
|
|
|
The highlight used for highlighted warnings. See |g:ale_set_highlights|.
|
|
|
|
|
|
ALEWarningLine *ALEWarningLine*
|
|
|
|
Default: Undefined
|
|
|
|
The highlight for lines where warning signs appear. See |g:ale_set_signs|.
|
|
|
|
|
|
ALEWarningSign *ALEWarningSign*
|
|
|
|
Default: `highlight link ALEWarningSign todo`
|
|
|
|
The highlight used for warning signs. See |g:ale_set_signs|.
|
|
|
|
|
|
===============================================================================
|
|
4. Fixing Problems *ale-fix*
|
|
|
|
ALE can fix problems with files with the |ALEFix| command. When |ALEFix| is
|
|
run, the variable |g:ale_fixers| will be read for getting a |List| of commands
|
|
for filetypes, split on `.`, and the functions named in |g:ale_fixers| will be
|
|
executed for fixing the errors.
|
|
|
|
The |ALEFixSuggest| command can be used to suggest tools that be used to
|
|
fix problems for the current buffer.
|
|
|
|
The values for `g:ale_fixers` can be a list of |String|, |Funcref|, or
|
|
|lambda| values. String values must either name a function, or a short name
|
|
for a function set in the ALE fixer registry.
|
|
|
|
Each function for fixing errors must accept either one argument `(buffer)` or
|
|
two arguments `(buffer, lines)`, representing the buffer being fixed and the
|
|
lines to fix. The functions must return either `0`, for changing nothing, a
|
|
|List| for new lines to set, or a |Dictionary| for describing a command to be
|
|
run in the background.
|
|
|
|
Functions receiving a variable number of arguments will not receive the second
|
|
argument `lines`. Functions should name two arguments if the `lines` argument
|
|
is desired. This is required to avoid unnecessary copying of the lines of
|
|
the buffers being checked.
|
|
|
|
When a |Dictionary| is returned for an |ALEFix| callback, the following keys
|
|
are supported for running the commands.
|
|
|
|
`command` A |String| for the command to run. This key is required.
|
|
|
|
When `%t` is included in a command string, a temporary
|
|
file will be created, containing the lines from the file
|
|
after previous adjustment have been done.
|
|
|
|
`read_temporary_file` When set to `1`, ALE will read the contents of the
|
|
temporary file created for `%t`. This option can be used
|
|
for commands which need to modify some file on disk in
|
|
order to fix files.
|
|
|
|
*ale-fix-configuration*
|
|
|
|
Synchronous functions and asynchronous jobs will be run in a sequence for
|
|
fixing files, and can be combined. For example:
|
|
>
|
|
let g:ale_fixers = {
|
|
\ 'javascript': [
|
|
\ 'DoSomething',
|
|
\ 'eslint',
|
|
\ {buffer, lines -> filter(lines, 'v:val !=~ ''^\s*//''')},
|
|
\ ],
|
|
\}
|
|
|
|
ALEFix
|
|
<
|
|
The above example will call a function called `DoSomething` which could act
|
|
upon some lines immediately, then run `eslint` from the ALE registry, and
|
|
then call a lambda function which will remove every single line comment
|
|
from the file.
|
|
|
|
For convenience, a plug mapping is defined for |ALEFix|, so you can set up a
|
|
keybind easily for fixing files. >
|
|
|
|
" Bind F8 to fixing problems with ALE
|
|
nmap <F8> <Plug>(ale_fix)
|
|
<
|
|
Files can be fixed automatically with the following options, which are all off
|
|
by default.
|
|
|
|
|g:ale_fix_on_save| - Fix files when they are saved.
|
|
|
|
|
|
===============================================================================
|
|
5. Integration Documentation *ale-integrations*
|
|
|
|
Linter and fixer options are documented in individual help files. See the
|
|
table of contents at |ale-contents|.
|
|
|
|
Every option for programs can be set globally, or individually for each
|
|
buffer. For example, `b:ale_python_flake8_executable` will override any
|
|
values set for `g:ale_python_flake8_executable`.
|
|
|
|
*ale-integrations-local-executables*
|
|
|
|
Some tools will prefer to search for locally-installed executables, unless
|
|
configured otherwise. For example, the `eslint` linter will search for
|
|
various executable paths in `node_modules`. The `flake8` linter will search
|
|
for virtualenv directories.
|
|
|
|
If you prefer to use global executables for those tools, set the relevant
|
|
`_use_global` and `_executable` options for those linters. >
|
|
|
|
" Use the global executable with a special name for eslint.
|
|
let g:ale_javascript_eslint_executable = 'special-eslint'
|
|
let g:ale_javascript_eslint_use_global = 1
|
|
|
|
" Use the global executable with a special name for flake8.
|
|
let g:ale_python_flake8_executable = '/foo/bar/flake8'
|
|
let g:ale_python_flake8_use_global = 1
|
|
<
|
|
|
|
The option |g:ale_virtualenv_dir_names| controls the local virtualenv paths
|
|
ALE will use to search for Python executables.
|
|
|
|
|
|
===============================================================================
|
|
6. Commands/Keybinds *ale-commands*
|
|
|
|
ALEFix *ALEFix*
|
|
|
|
Fix problems with the current buffer. See |ale-fix| for more information.
|
|
|
|
A plug mapping `<Plug>(ale_fix)` is defined for this command.
|
|
|
|
|
|
ALEFixSuggest *ALEFixSuggest*
|
|
|
|
Suggest tools that can be used to fix problems in the current buffer.
|
|
|
|
See |ale-fix| for more information.
|
|
|
|
|
|
ALELint *ALELint*
|
|
|
|
Run ALE once for the current buffer. This command can be used to run ALE
|
|
manually, instead of automatically, if desired.
|
|
|
|
This command will also run linters where `lint_file` is set to `1`, or in
|
|
other words linters which check the file instead of the Vim buffer.
|
|
|
|
A plug mapping `<Plug>(ale_lint)` is defined for this command.
|
|
|
|
|
|
ALEPrevious *ALEPrevious*
|
|
ALEPreviousWrap *ALEPreviousWrap*
|
|
ALENext *ALENext*
|
|
ALENextWrap *ALENextWrap*
|
|
ALEFirst *ALEFirst*
|
|
ALELast *ALELast*
|
|
*ale-navigation-commands*
|
|
|
|
Move between warnings or errors in a buffer. ALE will only navigate between
|
|
the errors or warnings it generated, even if both |g:ale_set_quickfix|
|
|
and |g:ale_set_loclist| are set to `0`.
|
|
|
|
`ALEPrevious` and `ALENext` will stop at the top and bottom of a file, while
|
|
`ALEPreviousWrap` and `ALENextWrap` will wrap around the file to find
|
|
the last or first warning or error in the file, respectively.
|
|
|
|
`ALEFirst` goes to the first error or warning in the buffer, while `ALELast`
|
|
goes to the last one.
|
|
|
|
The following |<Plug>| mappings are defined for the commands: >
|
|
<Plug>(ale_previous) - ALEPrevious
|
|
<Plug>(ale_previous_wrap) - ALEPreviousWrap
|
|
<Plug>(ale_next) - ALENext
|
|
<Plug>(ale_next_wrap) - ALENextWrap
|
|
<Plug>(ale_first) - ALEFirst
|
|
<Plug>(ale_last) - ALELast
|
|
<
|
|
For example, these commands could be bound to the keys Ctrl + j
|
|
and Ctrl + k: >
|
|
|
|
" Map movement through errors without wrapping.
|
|
nmap <silent> <C-k> <Plug>(ale_previous)
|
|
nmap <silent> <C-j> <Plug>(ale_next)
|
|
" OR map keys to use wrapping.
|
|
nmap <silent> <C-k> <Plug>(ale_previous_wrap)
|
|
nmap <silent> <C-j> <Plug>(ale_next_wrap)
|
|
<
|
|
|
|
ALEToggle *ALEToggle*
|
|
ALEEnable *ALEEnable*
|
|
ALEDisable *ALEDisable*
|
|
|
|
Enable or disable ALE, including all of its autocmd events, loclist items,
|
|
quickfix items, signs, current jobs, etc. Calling this option will change
|
|
the |g:ale_enabled| variable.
|
|
|
|
|
|
ALEDetail *ALEDetail*
|
|
|
|
Show the full linter message for the current line. This will only have an
|
|
effect on lines that contain a linter message.
|
|
|
|
A plug mapping `<Plug>(ale_detail)` is defined for this command.
|
|
|
|
|
|
ALEInfo *ALEInfo*
|
|
ALEInfoToClipboard *ALEInfoToClipboard*
|
|
|
|
Print runtime information about ALE, including the values of global and
|
|
buffer-local settings for ALE, the linters that are enabled, the commands
|
|
that have been run, and the output of commands.
|
|
|
|
ALE will log the commands that are run by default. If you wish to disable
|
|
this, set |g:ale_history_enabled| to `0`. Because it could be expensive, ALE
|
|
does not remember the output of recent commands by default. Set
|
|
|g:ale_history_log_output| to `1` to enable logging of output for commands.
|
|
ALE will only log the output captured for parsing problems, etc.
|
|
|
|
The command `:ALEInfoToClipboard` can be used to output ALEInfo directly to
|
|
your clipboard. This might not work on every machine.
|
|
|
|
|
|
===============================================================================
|
|
7. API *ale-api*
|
|
|
|
ale#Queue(delay, [linting_flag]) *ale#Queue()*
|
|
|
|
Run linters for the current buffer, based on the filetype of the buffer,
|
|
with a given `delay`. A `delay` of `0` will run the linters immediately.
|
|
The linters will always be run in the background. Calling this function
|
|
again from the same buffer
|
|
|
|
An optional `linting_flag` argument can be given. If `linting_flag`
|
|
is `'lint_file'`, then linters where the `lint_file` option is set to `1` will be
|
|
run. Linters with `lint_file` set to `1` are not run by default.
|
|
|
|
|
|
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.
|
|
|
|
It is advised to only call this function from a callback function for
|
|
returning a linter command to run.
|
|
|
|
|
|
ale#engine#EscapeCommandPart(command_part) *ale#engine#EscapeCommandPart()*
|
|
|
|
Given a |String|, return a |String| with all `%` characters replaced with
|
|
`%%` instead. This function can be used to escape strings which are
|
|
dynamically generated for commands before handing them over to ALE,
|
|
so that ALE doesn't treat any strings with `%` formatting sequences
|
|
specially.
|
|
|
|
|
|
ale#engine#GetLoclist(buffer) *ale#engine#GetLoclist()*
|
|
|
|
Given a buffer number, this function will rerurn the list of warnings and
|
|
errors reported by ALE for a given buffer in the format accepted by
|
|
|setqflist()|.
|
|
|
|
|
|
ale#engine#ManageFile(buffer, filename) *ale#engine#ManageFile()*
|
|
|
|
Given a buffer number for a buffer currently running some linting tasks
|
|
and a filename, register a filename with ALE for automatic deletion after
|
|
linting is complete, or when Vim exits.
|
|
|
|
If Vim exits suddenly, ALE will try its best to remove temporary files, but
|
|
ALE cannot guarantee with absolute certainty that the files will be removed.
|
|
It is advised to create temporary files in the operating system's managed
|
|
temporary file directory, such as with |tempname()|.
|
|
|
|
Directory names should not be given to this function. ALE will only delete
|
|
files and symlinks given to this function. This is to prevent entire
|
|
directories from being accidentally deleted, say in cases of writing
|
|
`dir . '/' . filename` where `filename` is actually `''`, etc. ALE instead
|
|
manages directories separetly with the |ale#engine#ManageDirectory| function.
|
|
|
|
|
|
ale#engine#ManageDirectory(buffer, directory) *ale#engine#ManageDirectory()*
|
|
|
|
Like |ale#engine#ManageFile()|, but directories and all of their contents
|
|
will be deleted, akin to `rm -rf directory`, which could lead to loss of
|
|
data if mistakes are made. This command will also delete any temporary
|
|
filenames given to it.
|
|
|
|
It is advised to use |ale#engine#ManageFile()| instead for deleting single
|
|
files.
|
|
|
|
|
|
ale#fix#registry#Add(name, func, filetypes, desc) *ale#fix#registry#Add()*
|
|
|
|
Given a |String| `name` for a name to add to the registry, a |String| `func`
|
|
for a function name, a |List| `filetypes` for a list of filetypes to
|
|
set for suggestions, and a |String| `desc` for a short description of
|
|
the fixer, register a fixer in the registry.
|
|
|
|
The `name` can then be used for |g:ale_fixers| in place of the function
|
|
name, and suggested for fixing files.
|
|
|
|
|
|
ale#linter#Define(filetype, linter) *ale#linter#Define()*
|
|
|
|
Given a |String| for a filetype and a |Dictionary| Describing a linter
|
|
configuration, add a linter for the given filetype. The dictionaries each
|
|
offer the following options:
|
|
|
|
`name` The name of the linter. These names will be used by
|
|
|g:ale_linters| option for enabling/disabling
|
|
particular linters.
|
|
|
|
This argument is required.
|
|
|
|
`callback` A |String| or |Funcref| for a callback function
|
|
accepting two arguments (buffer, lines), for a
|
|
buffer number the output is for, and the lines of
|
|
output from a linter.
|
|
|
|
This callback function should return a |List| of
|
|
|Dictionary| objects in the format accepted by
|
|
|setqflist()|. The |List| will be sorted by line and
|
|
then column order so it can be searched with a binary
|
|
search by in future before being passed on to the
|
|
|loclist|, etc.
|
|
|
|
This argument is required.
|
|
|
|
The keys for each item in the List will be handled in
|
|
the following manner:
|
|
|
|
`text` - This error message is required.
|
|
`lnum` - The line number is required. Any strings
|
|
will be automatically converted to numbers by
|
|
using `str2nr()`.
|
|
|
|
Line 0 will be moved to line 1, and lines beyond
|
|
the end of the file will be moved to the end.
|
|
`col` - The column number is optional and will
|
|
default to `0`. Any strings will be automatically
|
|
coverted to number using `str2nr()`.
|
|
`bufnr` - The buffer number should match the buffer
|
|
being checked, and this value will default to
|
|
the buffer being checked.
|
|
`vcol` - Defaults to `0`.
|
|
`type` - Defaults to `'E'`.
|
|
`nr` - Defaults to `-1`.
|
|
|
|
`executable` A |String| naming the executable itself which
|
|
will be run. This value will be used to check if the
|
|
program requested is installed or not.
|
|
|
|
Either this or the `executable_callback` argument
|
|
must be provided.
|
|
|
|
`executable_callback ` A |String| or |Funcref| for a callback function
|
|
accepting a buffer number. A |String| should be
|
|
returned for the executable to check. This can be
|
|
used in place of `executable` when more complicated
|
|
processing is needed.
|
|
|
|
`command` A |String| for an executable to run asynchronously.
|
|
This command will be fed the lines from the buffer to
|
|
check, and will produce the lines of output given to
|
|
the `callback`.
|
|
|
|
`command_callback` A |String| or |Funcref| for a callback function
|
|
accepting a buffer number. A |String| should be
|
|
returned for a command to run. This can be used in
|
|
place of `command` when more complicated processing
|
|
is needed.
|
|
|
|
If an empty string is returned from the callback,
|
|
no jobs for linting will be run for that linter.
|
|
This can be used for skipping a linter call,
|
|
say if no configuration file was found.
|
|
|
|
*ale-command-chain*
|
|
`command_chain` A |List| of |Dictionary| items defining a series
|
|
of commands to be run. At least one |Dictionary|
|
|
should be provided. Each Dictionary must contain the
|
|
key `callback`, defining a |String| or |Funcref| for
|
|
a function returning a |String| for a command to run.
|
|
|
|
The callback functions for each command after the
|
|
first command in in the chain should accept two
|
|
arguments `(buffer, output)`, a buffer number and a
|
|
|List| of lines of output from the previous command
|
|
in the chain.
|
|
|
|
The first callback function in a chain accepts only
|
|
a `(buffer)` argument, as there are no previous
|
|
commands to run which return `output`.
|
|
|
|
If an empty string is returned for a command in a
|
|
chain, that command in the chain will be skipped,
|
|
and the next function in the chain will be called
|
|
immediately instead. If the last command in a chain
|
|
returns an empty string, then no linting will be
|
|
performed.
|
|
|
|
Commands in the chain will all use the
|
|
`output_stream` value provided in the root
|
|
|Dictionary|. Each command in the chain can also
|
|
provide an `output_stream` key to override this value.
|
|
See the `output_stream` description for more
|
|
information.
|
|
|
|
Commands in the chain all behave as if `read_buffer`
|
|
is set to `0` by default, except for the last command
|
|
in the chain, which uses the value set for
|
|
`read_buffer` in the root |Dictionary|. Each command
|
|
in the chain can also provide a `read_buffer` key
|
|
to override these values.
|
|
See the `read_buffer` description for more
|
|
information.
|
|
|
|
`output_stream` A |String| for the output stream the lines of output
|
|
should be read from for the command which is run. The
|
|
accepted values are `'stdout'`, `'stderr'`, and
|
|
`'both'`. This argument defaults to `'stdout'`. This
|
|
argument can be set for linter programs which output
|
|
their errors and warnings to the stderr stream
|
|
instead of stdout. The option `'both'` will read
|
|
from both stder and stdout at the same time.
|
|
|
|
`read_buffer` A |Number| (`0` or `1`) indicating whether a command
|
|
should read the Vim buffer as input via stdin. This
|
|
option is set to `1` by default, and can be disabled
|
|
if a command manually reads from a temporary file
|
|
instead, etc.
|
|
|
|
*ale-lint-file*
|
|
`lint_file` A |Number| (`0` or `1`) indicating whether a command
|
|
should read the file instead of the Vim buffer. This
|
|
option can be used for linters which must check the
|
|
file on disk, and which cannot check a Vim buffer
|
|
instead.
|
|
|
|
Linters set with this option will not be run as a
|
|
user types, per |g:ale_lint_on_text_changed|. Linters
|
|
will instead be run only when events occur against
|
|
the file on disk, including |g:ale_lint_on_enter|
|
|
and |g:ale_lint_on_save|. Linters with this option
|
|
set to `1` will also be run when linters are run
|
|
manually, per |ALELint-autocmd|.
|
|
|
|
When this option is set to `1`, `read_buffer` will
|
|
be set automatically to `0`. The two options cannot
|
|
be used together.
|
|
|
|
`aliases` A |List| of aliases for the linter name.
|
|
|
|
This option can be set with alternative names for
|
|
for selecting the linter with |g:ale_linters|. This
|
|
setting can make it easier to guess the linter name
|
|
by offering a few alternatives.
|
|
|
|
Only one of `command`, `command_callback`, or `command_chain` should be
|
|
specified. `command_callback` is generally recommended when a command string
|
|
needs to be generated dynamically, or any global options are used.
|
|
`command_chain` is recommended where any system calls need to be made to
|
|
retrieve some kind of information before running the final command.
|
|
|
|
If temporary files or directories are created for commands run with
|
|
`command_callback` or `command_chain`, then these tempoary files or
|
|
directories can be managed by ALE, for automatic deletion.
|
|
See |ale#engine#ManageFile()| and |ale#engine#ManageDirectory| for more
|
|
information.
|
|
|
|
*ale-command-format-strings*
|
|
|
|
All command strings will be formatted for special character sequences.
|
|
Any substring `%s` will be replaced with the full path to the current file
|
|
being edited. This format option can be used to pass the exact filename
|
|
being edited to a program.
|
|
|
|
For example: >
|
|
'command': 'eslint -f unix --stdin --stdin-filename %s'
|
|
<
|
|
Any substring `%t` will be replaced with a path to a temporary file. Merely
|
|
adding `%t` will cause ALE to create a temporary file containing the
|
|
contents of the buffer being checked. All occurrences of `%t` in command
|
|
strings will reference the one temporary file. The temporary file will be
|
|
created inside a temporary directory, and the entire temporary directory
|
|
will be automatically deleted, following the behaviour of
|
|
|ale#engine#ManageDirectory|. This option can be used for some linters which
|
|
do not support reading from stdin.
|
|
|
|
For example: >
|
|
'command': 'ghc -fno-code -v0 %t',
|
|
<
|
|
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.
|
|
|
|
*ale-linter-loading-behaviour*
|
|
|
|
Linters for ALE will be loaded by searching |runtimepath| in the following
|
|
format: >
|
|
|
|
ale_linters/<filetype>/<linter_name>.vim
|
|
<
|
|
Any linters which exist anywhere in |runtimepath| with that directory
|
|
structure will be automatically loaded for the matching |filetype|. Filetypes
|
|
containing `.` characters will be split into individual parts, and files
|
|
will be loaded for each filetype between the `.` characters.
|
|
|
|
|
|
ale#linter#Get(filetype) *ale#linter#Get()*
|
|
|
|
Return all of linters configured for a given filetype as a |List| of
|
|
|Dictionary| values in the format specified by |ale#linter#Define()|.
|
|
|
|
Filetypes may be dot-seperated to invoke linters for multiple filetypes:
|
|
for instance, the filetype `javascript.jsx` will return linters for both the
|
|
`javascript` and `jsx` filetype.
|
|
|
|
Aliases may be defined in as described in |g:ale_linter_aliases|. Aliases
|
|
are applied after dot-seperated filetypes are broken up into their
|
|
components.
|
|
|
|
|
|
ale#statusline#Count(buffer) *ale#statusline#Count()*
|
|
|
|
Given the number of a buffer which may have problems, return a |Dictionary|
|
|
containing information about the number of problems detected by ALE. The
|
|
following keys are supported:
|
|
|
|
`error` -> The number of problems with type `E` and `sub_type != 'style'`
|
|
`warning` -> The number of problems with type `W` and `sub_type != 'style'`
|
|
`info` -> The number of problems with type `I`
|
|
`style_error` -> The number of problems with type `E` and `sub_type == 'style'`
|
|
`style_warning` -> The number of problems with type `W` and `sub_type == 'style'`
|
|
`total` -> The total number of problems.
|
|
|
|
|
|
ALELint *ALELint-autocmd*
|
|
|
|
This |User| autocommand is triggered by ALE every time it completes a lint
|
|
cycle. It can be used to update statuslines, send notifications, or
|
|
complete any other operation that needs to be done after linting has been
|
|
performed.
|
|
|
|
For example, you can echo a message when linting is complete like so:
|
|
>
|
|
autocmd User ALELint echom "ALE run!"
|
|
<
|
|
|
|
===============================================================================
|
|
8. Special Thanks *ale-special-thanks*
|
|
|
|
Special thanks to Mark Grealish (https://www.bhalash.com/) for providing ALE's
|
|
snazzy looking ale glass logo. Cheers, Mark!
|
|
|
|
===============================================================================
|
|
9. Contact *ale-contact*
|
|
|
|
If you like this plugin, and wish to get in touch, check out the GitHub
|
|
page for issues and more at https://github.com/w0rp/ale
|
|
|
|
If you wish to contact the author of this plugin directly, please feel
|
|
free to send an email to devw0rp@gmail.com.
|
|
|
|
|
|
Please drink responsibly, or not at all, which is ironically the preference
|
|
of w0rp, who is teetotal.
|
|
|
|
|
|
|
|
vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:
|