This adds Yara support to ALE using Avast's language server for Yara:
https://avast.github.io/yls/
A ".git" folder is used to determine the project_root so this means the
Yara rules must be in a git repo for the integration to work.
The server only have 1 optional argument (-v, --verbose). Since this is
the case, no additional configuration options are available.
---------
Co-authored-by: w0rp <w0rp@users.noreply.github.com>
`ModeChanged` looks like a more reliable way to detect an "exit insert mode" event and is a lot simpler (doesn't need a timer). Also, it can detect some other transitions like `\<C-o\>` in insert mode.
The `ModeChanged` event is available in:
* [Vim 8.2.3430](f1e8876fa2)
* [NeoVim 0.7.0](69bd1e4e36)
---------
Co-authored-by: Dmitry Zolotukhin <zlogic@gmail.com>
* Add support for the [djlinter](https://www.djlint.com/)
* Add documentation and tests.
* Fix the name of the variable for the executable name.
* Correct the name of the handler in the test.
* Correct the test adding the value of vcol.
* Format djlint.vim according to formatting rules.
Sometimes `s:HandleExit` can execute a deferred linter callback, which
ends up setting the `l:loclist` that's passed into
`ale#engine#HandleLoclist` at the end of `s:HandleExit` to a dictionary.
This dictionary cannot be iterated over, and thus errors out.
Guard against trying to iterate over values that don't make sense.
Co-authored-by: Alexander Huynh <git@e.sc>
* Fixed the issue with Black ignoring files is being processed. (#3406)
Add test for stdin-filename on test/fixers/test_ruff_format_fixer_callback.vader
* Fixed the issue with Black ignoring files is being processed. (#3406)
Fixed the problem on Windows's tests.
* Fixed the issue with Black ignoring config file to tell it which file is being processed. Trailing whitespace removed
Resolves#4314.
Add a fixer that's built into python for json formatting. Include a
couple arguments in docs to make these features more discoverable.
Uses stdin-based fixing so you don't need to save the file to fix.
In the vein of commit ea72d66b "Verilator current file search path (#3500)"
This includes the directory of the current file in the library
search path. From `man iverilog`:
-ylibdir
Append the directory to the library module search
path. When the compiler finds an undefined module, it
looks in these directories for files with the right name.
This might only be a problem for newer phpstan versions (2.1.1 here).
If you try to run `phpstan` the way ale will when it builds the option, you will get something like:
```
The "--memory-limit" option requires a value.
```
It wants you to use `--memory-limit=-1` instead.
The current xmllint fixer reads and formats the file that a buffer is
associated with from disk instead of accepting input from stdin. This
has the side effect that if the filename is changed in the buffer, but
not saved yet, the fixer discards all the pending changes and replaces
the buffer contents with the formatted text from the file contents on
disk.
* Add support for c3-lsp linter
Add support for c3-lang with the c3-lsp language server.
Link: http://github.com/pherrymason/c3-lsp
Link: http://c3-lang.org
* fix linter error
* fix: consistent use of the executable name
Consistently use the executable name 'c3lsp' instead of the project name
'c3-lsp'.
* c3lsp: add command line arguments to executable
* Add erlfmt fixer to the registry
Without this, the fixer will not appear in the list of suggested tools
and cannot be used without additional configuration.
* Handle stdin in the erlfmt fixer command
Previously, the full path to the file being edited was used, which
resulted in the loss of unsaved changes.
* Add executable selection tests for erlfmt fixer
Users can set the DOCKER environnement variable to select Docker or
Podman to run the tests.
Co-authored-by: L'HOSPITAL Logan <lhospitallogan@gmail.com>
* Added jq support
Cleaned up yq.vim file
* Updated docs
* Updated supported-tools.md
* Added yq tests
* Fix python linting/formatting error when in virtual environment (#4865)
Python fixers and linters were failing when vim is running in a virtual
environment that's located in a path containing text `poetry`. The cause
of this was the regular expression `poetry\|pipenv\|uv$` which matches
`poetry` and `pipenv` if they appear anywhere in the virtualenv path.
* Add cljfmt fixer for clojure files (#4860)
* When using `actionlint` look for & use a config file (#4858)
Actionlint supports a config file and it lives in a very searchable
path, as the only files it acts on are in the `.github` directory
already.
Look for an `actionlint.yml` and `.yaml` in that path, and use the
config if its there.
* Fix linting with jq (#4765) (#4862)
With the 1.6 version of jq the error message start with "parse error".
With the last version of jq the error message start with "jq: parse error".
Fix it by using a regular expression that works in both cases.
* Properly handle optional end_line_no/end_line_pos in sqlfluff (#4867)
end_line_no/end_line_pos are optional. Example SQL:
`SELECT NULL FROM {{ a_jinja_templated_table }};`
`sqlfluff lint --dialect ansi --format json` gives the following error
among others:
```
{"start_line_no": 1, "start_line_pos": 21, "code": "TMP", "description":
"Undefined jinja template variable: 'a_jinja_templated_table'", "name":
"", "warning": false}
```
As one can see there is no end_line_no/end_line_pos.
* Add golangci-lint fixer (#4853)
Closes#4616
* Fixed copy-paste misstakes and added filter to docs
* Added test vader file for yq
* Fixed and updated the test case
---------
Co-authored-by: Walter Kaunda <14844142+kwalter94@users.noreply.github.com>
Co-authored-by: rudolf ordoyne <49649789+casens5@users.noreply.github.com>
Co-authored-by: Bea Hughes <108035665+beahues@users.noreply.github.com>
Co-authored-by: benjos1234 <legrimlvl24@gmail.com>
Co-authored-by: Coacher <Coacher@users.noreply.github.com>
Co-authored-by: Ian Stapleton Cordasco <graffatcolmingov@gmail.com>
* fix ale_python_auto_virtualenv to correctly set virtualenv env vars
According to the documentation, `ale_python_auto_virtualenv` should automatically set environment variables for commands, but previously the variables were not set completely or correctly.
Before:
`PATH` variable was expanded to include `/path/to/venv`
After:
`PATH` variable is expanded to include `/path/to/venv/bin`
`VIRTUAL_ENV` variable is set to `path/to/venv`
This mimics exactly what the `activate` scripts do, and allows the configuration knob to work as expected.
For example, after this change, `jedi-language-server` can be installed globally (instead of inside every venv), and it will "just work" (e.g. find references to dependencies in the venv) when editing a file in a project that uses a venv, because the correct variables are set.
* fix test_python_virtualenv.vader test to expect output with both virtualenv vars
* remove unnecessary non-escape in test_python_virtualenv.vader
* fix accidentally removed space in windows test_python_virtualenv.vader
In addition to errors Zeek's parsing can also expose warning messages,
e.g., for the following code
```zeek
event http_stats(c: connection, stats: http_stats_rec) {
c$removal_hooks;
}
```
a warning is emitted
```
warning in /tmp/foo.zeek, line 2: expression value ignored (c$removal_hooks)
```
This patch adds parsing and propagation of these warning messages.
end_line_no/end_line_pos are optional. Example SQL:
`SELECT NULL FROM {{ a_jinja_templated_table }};`
`sqlfluff lint --dialect ansi --format json` gives the following error
among others:
```
{"start_line_no": 1, "start_line_pos": 21, "code": "TMP", "description":
"Undefined jinja template variable: 'a_jinja_templated_table'", "name":
"", "warning": false}
```
As one can see there is no end_line_no/end_line_pos.
With the 1.6 version of jq the error message start with "parse error".
With the last version of jq the error message start with "jq: parse error".
Fix it by using a regular expression that works in both cases.
Actionlint supports a config file and it lives in a very searchable
path, as the only files it acts on are in the `.github` directory
already.
Look for an `actionlint.yml` and `.yaml` in that path, and use the
config if its there.
Python fixers and linters were failing when vim is running in a virtual
environment that's located in a path containing text `poetry`. The cause
of this was the regular expression `poetry\|pipenv\|uv$` which matches
`poetry` and `pipenv` if they appear anywhere in the virtualenv path.
This fixer performs indentation with the Erlang mode for Emacs.
The Erlang mode is maintained in the Erlang/OTP source tree. It indents
some things differently than the Vim indent plugin, and provides more
customization options.
* Prefix user-defined commands with colons
This is consistent with Vim's own :help pages.
* Remove dot hack
Now that we have `:ALEInfo` and `ALEInfo`, we don't need `ALEInfo.` any
more to disambiguate them.
* Use colons in references
* Use angle brackets for command arguments
* Use `:Command` for command references
* Use a non-command reference for tsserver
* Prefix highlight references with hl-
* Fix some references into Vim's own :help
E.g. location-list or +features
* Misc hotlink improvements
* Undo previous changes to tsserver
Just leave it in backticks - even though I don't like it.
* Use bars for a command for consistency
* Append hotlinks to hl-groups
Remove minuses to make tables look more like in Vim's own :help
* Prefix features with +
* Provide full hotlink to ale.txt
* Fix double pipe typo
* Capitalize Error highlight
There seems to be no hotlink in Vim's own documentation for this.
I would have expected *hl-Error* - no such thing :-(
* Right align tags to col 79
Make ale#floating_preview#Show more similar to popup_create and return
the id of the window so it's easy to set the filetype of the resulting
buffer.
Update test stub version of Show() to return a win id (the current window
since it's not actually creating a window).
Test
* both tests still pass
The only option available to biome's `lsp-proxy` command used for
linting is `--config-path`. However, we are using ALE to find and set
the project root, and have a way to manually override, so that is no
longer necessary.
The LSP proxy also used the `g:ale_biome_options` config, which is
shared with the fixer's `check` command, but `lsp-proxy` will throw an
error if unknown options are included, making it so that option is only
useful to set the project root.
BREAKING CHANGE: We are no longer passing options to the biome LSP
proxy, but we can still set the project root with
`g:ale_biome_lsp_project_root`.
Since biome supports either `biome.json` or `biome.jsonc` config files,
we need to look for both when searching for the LSP project root. We can
also look for a package.json or .git folder to use. This uses mostly the
same logic as deno.
* Add Ruby linter with Steep
Fixes#3254
* Run steep instead of using language server
LSP presents a few issues and this works around those.
* Work around Steep path issue
See https://github.com/soutaro/steep/pull/975
* Add simple tests for steep
* Add steep to supported tools
* Pass linter
* Add a comment regarding Steep's column counting
* Make lnum an integer
* Add Steep handler test
* Fix separator for Windows
* Escape Windows path separators for substitute()
* Use ALEInfo (I) group
* Use fnameescape instead of quotes
* Skip linting for files not under steep root
* Add and pass tests covering proper steep root lookup
* Fix separator discrepancy
* Use strict operators (match case)
* Fix ordering
* Use `is#` instead of `==#`
Since Biome understands `typescriptreact` and `javascriptreact` as
languages, we can send the `filetype` to the LSP, rather than only
sending `typescript` for both `ts` and `tsx` files, or `javascript` for
`js` and `jsx` files.
fixes: #4752
biome handles utf8 characters differently between files and stdin, and
in some cases can replace emojis with ascii characters when using stdin
refs: biomejs/biome#2604
* Update dart analysis_server command
In 2021 the dart team added a new sub-command `language-server` to
replace the original `./snapshots/analysis_server.dart.snapshot --lsp`
convention for starting the language server.
c224cc2e0d
* Add ale_dart_analysis_server_enable_language_server option
This allows users to opt-in to the new `dart language-server` command.
* Enable ale_dart_analysis_server_enable_language_server option by default
* Update doc/ale-dart.txt
Include the dart version number where the `dart language-server` command
was added.
this commit is to fix#4756 which suggests to force disable applying
fixes when linting, particularly when `fix = true` was set in project
`pyproject.toml` file.
The flag `--no-fix` was added without checking the version of `ruff` at
this moment as it seems to be available in a quite early version.
php-cs-fixer command line options are ordered. Options that appear after the
main command are applied to the main command. Options that appear after the
subcommands are applied to the subcommands. This change enables a user to
specific fix options (like --config). This change also sets the plugin to
find the the configuraiton file in the current project tree. This matches
the default behavior of other linters like eslint.
As stated in the changelog:
"the original fields of line_pos and line_no have been renamed to start_line_pos and start_line_no, to distinguish them from the new fields starting end_*"
This commit appends `check` to the ruff executable if the version of
specified ruff executable is `>= 0.3.0`, as ruff version `0.3.0`
deprecates `ruff <path>` in favor of `ruff check <path>`:
https://github.com/astral-sh/ruff/releases/tag/v0.3.0
Checking whole packages instead of individual files is more sensible
default for golang projects. Without this we get many cryptic
`typecheck` errors in ALE that do not show when running in terminal or
CI.
* Fix '-s' to be '-S' when setting 'TabSize=1' for chktex
Fixes#4712Closes#4725
* Check if chktex's -S option is available
* Check chktex version instead of trying -S option
Most of the time it works to assume that the current working
directory is the root of the project. However, this is not the case
for Rebar3 checked out dependencies, for example.
It's also worth noting that because of the way Elvis handles file
patterns, and because directories in configuration are relative to the
project root, the path supplied to command must be also relative.
* super hacky way to get ember template lint to work on gjs files
* Clean up code so we use a handler which means we reuse all the config
also moves handler to the glimmer directory so it only fires
for gjs files
* fix tests
* PHPStan is now working with filename-mapping
See help ale-lint-other-machines for more info about filename-mapping.
* Add two tests to show and test what is expected
* Missed this update while creating previous commit
* Simplified the update
We only needed to refactor the processing loop.
No extra test are needed.
I have an LSP that is returning markdown code blocks on Hover with no
language specified, e.g.
````
```
Foobar
```
````
As a result, you get "```" in the message line which is not that useful.
I made the regex to catch the first code fence accept empty language as
well, and if it's empty, we set it to "text".
This makes it so that LSPs that return no language still produce legible
restuls on the message line.
Co-authored-by: Oliver Ruben Albertini <ora@fb.com>
* Fix chktex highlighting wrong column when using tabs instead of spaces
Fixes#723
chktex implemented feature request [1] for allowing setting options from
the command line. Thanks to that we can tell it to treat tab character
as of one space width, i.e. one char. That means, after we translate the
output back to Vim columns, we get correct numbers.
[1]: https://savannah.nongnu.org/bugs/?56486
* Add test_tex_chktex.vader
* Use functions to set g: variables in ale_linters/tex/chktex.vim
* Update ale_linters#tex#chktex#GetCommand() to use '%e'
[rubyfmt](https://github.com/fables-tales/rubyfmt) is a formatter for
`ruby` code.
This commit adds support for `rubyfmt` as a `ruby` fixer (#2991),
together with some tests and documentation.
* Add end_col and end_lnum to ShellCheck
ShellCheck supports a JSON format mode which includes an 'endLine' and
'endColumn' field.
We must use the newer 'json1' format as it properly treats tabs as a
single character. 'json1' was not supported until v0.7.0 in 2019[1], so
we maintain support for the older GCC based format.
[1] https://github.com/koalaman/shellcheck/blob/v0.9.0/CHANGELOG.md?plain=1#L121
* Add wiki link to ShellCheck json output
Since Neovim commit c4afb9788c4f139eb2e3b7aa4d6a6a20b67ba156, the sign
API uses extmarks internally. Virtual text is already rendered using
extmarks. ALE uses the same group name for both signs and virtual text
and as a result, both are placed in the same extmark group. Since ALE
deletes all extmarks in the virtual text group after all signs have been
placed, no signs are ever shown. This commit fixes this by renaming the
sign group from `ale` to `ale_signs`.
* Ruff use json-lines output format
* Fix Ruff: add -q to prevent non json output
Using the json-lines output format allows for setting of the end_line,
end_col and code field of the handle output.
Additionally, the first letter of the code is used to determine the type
field.
Co-authored-by: w0rp <w0rp@users.noreply.github.com>
Nickel(https://nickel-lang.org/) is a configuration language, like
Jsonnet, Cue, Dhall.
`nickel`(https://github.com/tweag/nickel) is the main command to run,
export and also format Nickel code.
this commit adds `nickel format` as a Nickel fixer, together with some
tests and documentation.
Fix solhint for versions >= 3.4.0, while still supporting older
versions.
The solhint linter code has been moved out of the `handlers` directory
as it does not need to be shared between different filetypes. Code has
been simplified.
Co-authored-by: Henrique Barcelos <16565602+hbarcelos@users.noreply.github.com>
We weren't joining and returning paths correctly for detecting project
roots for Haskell projects, and now we are.
Co-authored-by: Rodrigo Mesquita <rodrigo.m.mesquita@gmail.com>
* Remove some tests we no longer need
* Delete blocks of redundant code
* Compress some tests together to simplify them
* Remove a little code for ancient linter versions
* Escape more executables we didn't escape before
* Rename a deno option that didn't match our conventions
Add an ALEStopLSP command to stop all language servers that match a
given name. Completions are available for the command. This makes it
possible to keep other language servers running other than the one
you're interested in stopping.
Default `g:ale_disable_lsp` to a new mode `'auto'` by default. With this
setting applied, ALE will now check for the presence of nvim-lspconfig
and automatically turn off particular LSP linters if already configured
via nvim-lspconfig.
For users that do not use `nvim-lspconfig`, everything should work as
before.
Fix the ordering of virtualtext so we print the most severe problem on a
line. If two problems are the most severe, we will print the left-most
problem.
Show only a single virtualtext message per line by default. The setting
can be configured to whatever the user wants. This default prevents
several linters from spamming the editor with messages that run off into
the right margin.
Documentation now clarifies that problems have a predictable order, and
which message will come first.
.venv was going to be the officially recommended default virtualenv
directory name in PEP 704, which was not accepted. Still, poetry uses
this name by default, as do other projects. We can deem it the first
name we should try to search for.
ve-py3 was a directory name I can't find mentions of online, and was
used in my own projects during the days of migrating from Python 2 to 3.
We can just drop it, and people can update their settings if they still
need it.
Use Neovim's diagnostics API by default in recent enough Neovim
versions. This will make problems found by ALE play nicely with problems
found by other tools.
Use a repeating timer to emulate InsertLeave mode for users who have not
rebound <C-c> to <Esc>, like many experienced Vim users do. This allows
ALE to start linting when you finish typing by default without having
to know about this quirk in Vim or Neovim.
Make a series of sweeping changes to make :ALEInfo more useful.
1. Deprecate :ALEInfoToClipboard and support :ALEInfo -clipboard
2. Permit :ALEInfo -clip as a shorthand for :ALEInfo -clipboard
3. Support :ALEInfo -preview to render in the preview window
4. Support :ALEInfo -echo for the classic :ALEInfo mode
5. Change the default mode to 'preview', and make it configurable
6. Add syntax highlighting for ALEInfo in preview mode
7. Add a convenience to look up documentatation that explains itself
8. Don't show an empty 'Linter Variables' section
When commands are run, it can be useful to just save the hidden buffers
so language servers immediately get updated with changes to files
without you having to manually save each file. You can now enable this
by setting `g:ale_save_hidden` to `1`.
* Avoid performance problems with setbufline() and Treesitter
Call nvim_buf_set_lines() instead.
Since this is a performance problem only in Neovim (Treesitter is only
available there), it doesn't matter that this API is unavailable in Vim.
Note: nvim_buf_set_lines() returns E5555, when set nomodifiable is on.
Fixes#3669
* Avoid sign flickering
The signs flickered because nvim_buf_set_lines() removes all signs from
lines that it touches, which will immediately be readded by Ale (causing
the brief flicker). This is intended behaviour in neovim [0].
Neovim itself faced this problem in their own LSP formatting sync,
although they had the problem with marks instead of signs [1].
Similar to how neovim fixed it by storing and restoring the marks [2],
we can do the same thing with signs.
In fact it is easier with signs, because sign_placelist() will just
ignore and skip invalid line numbers, so we don't need to filter signs
that are not valid anymore.
[0] https://github.com/neovim/neovim/issues/10880#issuecomment-526466042
[1] https://github.com/neovim/neovim/issues/14307
[2] https://github.com/neovim/neovim/pull/14630
rust-analyzer sometimes returns a hover result with language being
"text", but there's no syntax/text.vim, so this would fail with:
Error detected while processing function <SNR>150_VimOutputCallback[6]..<lambda>8[1]..ale#lsp#HandleMessage[30]..ale#hover#HandleLSPResponse[42]..ale#floating_preview#Show[13]..<SNR>161_VimShow:
line 13:
E484: Cannot open file syntax/text.vim
Only including the file when it actually exists fixes this.
In #2637, support for numhl highlights was added for nvim.
In the meantime, vim added support for numhl highlights in patch 8.2.3874.
This patch allows numhl highlights to be enabled in ALE for vim >= 8.2.3874 too.
* fixed parsing errors when certain options are used in glslang
* Update glslang.vim
set column number to 0 like it is always set by glslangValidator
* Added a test for the handler of glslangValidator
* Fix a Ruby deprecation warning in the ERB linter
Before, the ERB linter used positional arguments. Newer versions of Ruby
have deprecated this method signature. We fixed the linter to use
keyword arguments.
* fixup! Fix a Ruby deprecation warning in the ERB linter
* Add fourmolu fixer
Fourmolu is aversion of Ormolu that supports configuration. This fixer
was modeled after the Ormolu one, but using the "stack executable"
approach of the Brittany and Stylish Haskell fixers.
* Sort supported-tools.md
* Add support for Bicep when installed as a plugin to Azure CLI
The compiler for Microsoft's DSL Bicep can be installed both
independently and as a plugin to Azure CLI. The latter is probably how
most people install it.
The program output is the same but Azure CLI wraps the arguments and has
a slightly different interface, hence I opted to copy the old linter and
modify it to match the plugin arguments.
* Fix bicep/az_bicep tests, arguments and parsing
* Actually test the ale_linters#bicep#az_bicep#Handle function in the
test that should test that function, not
ale_linters#bicep#bicep#Handle.
* Use the same method as in bicep/bicep for discarding output file, i.e.
by specifying --outfile to a null file.
* Fix parsing of occasionally occurring leading error type (such as
'ERROR: ').
* Correct option defaults for bicep & az_bicep specified in documentation
* Fix error from ansible-lint versions >=6.11.0.
The JSON output format of ansible-lint has changed since
6.11.0. Issue locations can have either a 'positions' or
a 'lines' member, rather than just a 'lines' member as it
was before. This fix checks which member is present, and
passes that member name to subsequent dictionary lookups.
The error was caused by the following change:
https://github.com/ansible/ansible-lint/pull/2897
* Add ansible-lint test to check each type of ansible-lint issue json.
* Change long single-line JSON in ansible test into multiline JSON.
* Fix linting errors in ansible_lint.vim.
When running the tests on aarch64, the run-tests script tries to
download a pre-built image that is built for x86-64, and thus does not
run.
This change adds a check for the Docker daemon host platform and only
downloads the image if it will run.
Furthermore, the image dependency testbed/vim:24 is also built unless
the platform is x86_64, since it is also only provided for this
platform.
PHPStan will only detect a configuration file in the current working
directory, so set that to the directory in which ALE finds the
configuration file.
Support replacing ALE's display of problems with sending problems to the Neovim diagnostics API.
:help g:ale_use_neovim_diagnostics_api
Co-authored-by: David Balatero <dbalatero@users.noreply.github.com>
Co-authored-by: Georgi Angelchev <angelchev@live.co.uk>
Co-authored-by: w0rp <devw0rp@gmail.com>
I am the President and Treasurer of Dense Analysis, and through my sole authority I transfer the copyright of ALE to my own nonprofit organisation, so it can live on throughout history as a protected FOSS project after I am dead. Nuff said.
Default virtual-text to the Comment highlight group and prefix
virtual-text messages with comment text for each language by default.
Messages can now be formatted with `%type%` to print the error type.
The Vim 9.0 version has been updated in the Docker image to add test
coverage for virtual-text.
Add functions to compute the cwd to be the same as the project root for
pylsp and Pyright to work around issues in each language server when
they encounter modules that share the same name as first or third party
libraries.
* Handle empty answer of ansible-lint
The variable a:lines might be empty if ansible-lint exited early, in
that case json_decode would trow an error.
* Use ales JSON decode function
this commit adds refurb as a Python linter, together with some tests
and documentation. it should fix issue: #4362
refurb repo: https://github.com/dosisod/refurb
`checkmake` by default checks config file "in the same folder it's
executed in" unless `--config` option is set.
This commit allows setting the `--config` option with an option
variable (with documentation updated).
Consider a file like
```
#lang racket
(require racket/gui)
```
Type `Go(eventspace-`.
Pressing <C-x><C-o> to trigger omnicomplete should suggest
```
eventspace-handler-thread
eventspace-shutdown?
eventspace-event-evt
```
It does not (instead producing "top-level" completions, as if
`(eventspace-` wasn't even there).
Debugging, place the cursor on a space _after_. Now
`ale#completion#OmniFunc(1, '')` correctly returns `1`, but when given
`(0, 'eventspace-')` it returns either the empty list or generic
completion results as described above. I'm not entirely sure of the
mechanism, but it seems that `b:ale_completion_info.prefix` is the key,
and that this is set by `ale#completion#GetPrefix`. Calling
`ale#completion#GetPrefix('racket', line('.'), col('.'))` returned `''`!
Now, it returns `eventspace-` and the completions work correctly again.
Ref #4293, #4186, #3870
- Add this option so command line arguments can be supplied to hadolint
- This will be respected when running in docker and via the executable
- Preserve the --no-color and - flags, and add these to the list
- Add to docs and tests
* ale.txt: fix indentation
* ale.txt: fix Type and Default markup
* ale.txt: use `not set` instead of `undefined`
This matches the way the variables are referenced in prose about
existence state.
Gcc does not support `x c*-header` when using `-` as input filename,
which is what ALE does.
Rework the feature to only use `-x c*-header` flag when using Clang and
not GCC.
The feature is now also controlled with the variable
`g:ale_c_cc_use_header_lang_flag` and
`g:ale_cpp_cc_use_header_lang_flag`.
Add configuration files for pyright (JSON and TOML) to list of files
which identify a project root directory. Update documentation
accordingly.
Co-authored-by: Andreas Doll <andreas.doll@posteo.de>
When linting an header file in C or C++, `-x c-header` or
`-x c++-header` should be used instead of `-x c` or `-x c++`.
Using `-x c` or `-x c++` for headers files can lead to unused variables
and functions marked as static inlined as seen in #4096.
Using `-x c-header` or `-x c++-header` solve these issues.
The list of file extensions that are considered as header files can be
configured with the variables `g:ale_c_cc_header_exts` and
`g:ale_cpp_cc_header_exts`.
I discovered that references to other Bicep files (modules) will be
broken if running on a temporary file in a different location. I've
found no way of providing an alternate path when invoking the command.
* Add support for Microsoft's DSL Bicep
The compilation command 'bicep build' catches compilation errors as well
as providing some lint warnings.
Repository for Bicep: https://github.com/Azure/bicep
* Different null file on Windows & hardcode commands
Deno LSP automatically detects config files named deno.json or
deno.jsonc since version 1.18.
For Deno 1.18+ this means that ALE no longer needs to resolve the
project root. However, removing the project root logic from ALE means
breaking changes for people that are still using an older version.
Adding deno.json to the list of looking files to look for will keep the
behavior consistent and compatible with the Deno config file naming
convention.
See also:
https://deno.com/blog/v1.18#auto-discovery-of-the-config-file
* Remove virtual text via types-filter
This is more robust and has the additional sideeffect that it will make
it easier to implement showing virtual text for all warnings
simultaneously.
We definitely do not want to do a call to prop_remove() for every
virtual text as that will cause noticeable lag when many warnings are
present, thus we can use this to remove all virtual text lines with one
call in the future.
Fixes#4294
refs: https://github.com/vim/vim/pull/10945
* Allow virtual text to appear for all warnings of the buffer
This can be enabled with:
let g:ale_virtualtext_cursor = 2
It is implemented both for neovim and vim 9.0.0297.
Note that sometimes it may appear like some warnings are displayed
multiple times. This is not a bug in the virtual text implementation,
but a sideeffect of multiple linters returning similar results.
For example for Rust, the 'cargo' and 'rls' linters appear to be
activated at the same time, but they sometimes return identical errors.
This causes the virtual text to show the same warning twice.
In the future we can mitigate this problem by removing duplicate errors
from our internal location list.
However users can also achieve cleaner warnings simply by activating
only one linter for each language (or multiple unambiguous linters).
For example for Rust, the problem could be solved with:
let g:ale_linters = {'rust': ['analyzer']}
Fixes#2962Fixes#3666
Regression was introduced in d93bc2baf7
The problem was that we did not handle the edge case where there is no
last popup to close, which caused old vim versions to enter code by
accident that was only supposed to be run by vim 9.
We fix this by guarding the if condition for vim 9.
Fixes#4290
* Add extra config options for virtualtext
* Undo virtualtext changes and move to floating preview
* revert changes to pass hightlight group to floating preview
* rename var
* Document changes
* Add updates based on feedback
* Check for string type and attempt to call the function
* Fix lint errors
Co-authored-by: Shaun Duncan <shaun@speedscale.com>
Our current virtual text implementation for vim emulates it by abusing
the textprop and popupwin feature from vim 8.2 (for more details see
commit 708e810414).
This implementation sometimes is janky, for example the popups may leak
into other vim windows next to the current window.
Luckily, vim just got native virtual-text support as a proper subtype to
the prop_add() function. By using the 'text' option, the text property
automatically becomes virtual text that is appended to the current line
if col is zero.
Note that the prop_add() method now returns negative IDs for virtual
text properties.
This feature was added in vim 9.0.0067, but it got a lot of bugfixes
which is why we only use this new API if vim has at least version
9.0.0214.
However, there are still some minor bugs with vim's native virtual text,
so we might have to bump the version check again in the future.
Also see #3906.
Now with proper virtual text support for both vim and neovim available,
we can tackle #2962 in the future by simply tracking multiple virt-texts
instead of just the last one.
In the future we might also want to disable our virtual text emulation
support for vim, as it is a total hack, but for now we should keep it
for backwards compatibility.
When 'close_cb' is set for job_start(), but out_cb or err_cb isn't, vim
buffers data instead of dropping it (in case someone wanted to read and
process it in close_cb), and additionally polls for new data every 10
milliseconds, causing excessive wakeups and CPU usage. Since we don't
read the data anywhere outside of out_cb/err_cb, any LSP that prints an
error to stderr triggers this and vim keeps spinning until :ALEStopAllLSPs.
Fix this by always setting both callbacks, thus dropping any data we're
not interested in.
See https://github.com/vim/vim/issues/10758 for an upstream report of
the excessive polling. It's possible this is intentional, I dunno.
Fixes: b42153eb17 ("Fix #4098 - Clear LSP data when servers crash")
In #4231 some code was added to stop the completion menu if any when
opening a new one. This resulted in an issue in Vim that fills the
buffer with Ctrl-Z characters when deleting to the end of a line in a
position that triggers auto-completion.
Since auto-completion seems to work fine on all my tests I am reverting
this specific change.
* add support, docs, tests for Laravel Pint
* fix php-cs-fixer link
* add missing project-without-pint
* fix indentation
* fix pint executable in pint fixer test
* fix variables, docs related to pint support
* fix: added support for local solhint executable
* feat: added support for matching parse errors
* test: added test for solhint command callback and handler
* chore: removed command callback test
* refactor: made solhint handler structure closer to eslint
* refactor(shfmt-fixer): remove derivation of default CLI arguments
The default `omni_start_map` is too restrictive for Lisps and Schemes
like Racket, which permit hyphens (among other special characters).
As recorded in #3870, trying to complete `file-name-from-path` when
typing `file-name<C-x><C-o>` would give completions like `namespace`
because the hyphen is ignored to find the start of the word for
completion.
Now the racket filetype searches for the start using the keyword class
`\k`, which is more precise.
* Allow customization of all floating window borders
Users may not necessarily want the same border character for top+bottom
or left+right, so allow all eight border characters to be configured in
g:ale_floating_window_border.
For backwards compatibility, the old rules are still applied if only six
elements are given.
* Reorder popup border array for compatibility
* Add support for HashiCorp Packer
* Add test for packer fmt
* Add doc for HCL/Packer
* Add link to Packer doc
* Also suggest packer fix for packer ft
* Add more links to TOC
* vscode-json-languageserver-bin support
VSCode JSON languageserver has schema support for linting and
completions.
I have enabled snippets support (`snippetSupport`) even if it is not
fully supported. `label` that comes with completions response can be
used as well.
* Test fix.
* vscode-json-languageserver instead of vscode-json-languageserver-bin
vscode-json-languageserver is more up-to-date (about 1 year old),
vscode-json-languageserver-bin is 4 years old.
* Use git root.
* Documentation update.
* Trying to sort ordering issue.
* One more attempt
* One more attempt
* Uppercase seems to win.
* Clean-up
* Clean-up 2
* Test removed.
The previous linter rule about stray echo lines has been restored, and
now all problems for custom linting rules can be ignored by adding a
comment above problem lines.
* rust-analyzer in non-cargo projects
rust-analyzer can also be used in non-cargo projects. This requires a
rust-project.json file in the project root [1].
Make the rust-analyzer linter search for a rust-project.json file if no
Cargo.toml file could be found.
[1]: https://rust-analyzer.github.io/manual.html#non-cargo-based-projects
* Document rust-analyzer without cargo
* Test rust-analyzer with non-cargo projects
Change the other rust tests to match the new directory structure of the
test files.
Currently, it's not possible to override the awk `--lint` option with
```viml
let g:ale_awk_gawk_options = '--lint=no-ext'
```
although this could be useful for those who only use gawk and don't want to get these lint errors:
> FEATURE X is a gawk extension
The idea is to move the default `--lint` option before the `awk_gawk_options` in the gawk.vim code to give the custom `--lint=...` option a higher precedence.
Co-authored-by: Barnabás Ágoston <barna@agoston.dev>
This patch adds support for opening jdt:// links on "go to definition" requests returned by Java language servers.
Co-authored-by: w0rp <devw0rp@gmail.com>
* Dispatch textDocument/didChange after rename
Previously whenever we renamed a symbol that was referenced from other
files we'd just edit those files in the background, and the LSP wouldn't
know about these changes. If we tried to rename the same symbol again,
the renaming would fail. In some scenarios, the operation would just be
wrong. Here is an attempt to fix this issue.
I also noticed another bug when using Go with `gopls` LSP and the `gofmt`
fixer. Whenever the file was saved, the `gofmt` would run and reformat
the file. But it seems there was some kind of a race condition so I
disabled saving for now, and all of the modified files will be unsaved,
so the user should call `:wa` to save them. I personally like this even
better because I can inspect exactly what changes happened, and I
instantly see them in the other opened buffers, which was previously not
the case.
Fixes#3343, #3642, #3781.
* Address PR comments
* Remove mode tests in corner case tests
* Address PR comments
* Save after ALERename and ALEOrganizeImports
Also provide options to disable automatic saving, as well as instructions to
enable `set hidden` before doing that.
* Fix broken test
* Save only when !&hidden
* Update doc
* Update doc
* Add silent
Unimport (https://github.com/hakancelik96/unimport/) is a linter,
formatter for finding and removing unused import statements.
This introduces linting support, although fixer support could come
later.
* Allows to use quickfix for references.
E.g. following mapping could be used to find references for item under
cursor and put result into quickfix list:
```
nnoremap <leader>af :ALEFindReferences -quickfix<CR>
```
Fixes#1759
* Documentation update.
Only open list window if the number of warnings or errors equals to or
exceeds the value of ale_open_list. No change when set to `1`.
Co-authored-by: cos <cos>
Closes#1810
Add ALEPopulateQuickfix and ALEPopulateLocList. They're not very useful
with ale's default auto-populate behaviour, so their useful configuration
is described in help.
Previously, it would not generate any lint messages for nix 2.5.
Moreover, it would cause this error whenever the nix command is
invoked, when paired with a custom `g:ale_command_wrapper`:
Error detected while processing function <SNR>92_NeoVimCallback[29]..<lambda>27[
1]..<SNR>90_ExitCallback[28]..ale_linters#nix#nix#Command:
line 1:
E684: list index out of range: 0
* Fix 4004 - Disable eslint by default for json.
This PR disables, or more correctly, excludes eslint from the list of
default linters for json files.
Also fixes elixir, go, json5, and jsonc files documentation and default
linters to make them consistent.
* Fix and improve tests
* ALEFileRename command added.
This command renames file and uses tsserver `getEditsForFileRename` to
fix import paths in Typescript files.
* ale#util#Input fix
* Even more fixes.
* Linting error fix.
When `let g:ale_ruby_reek_show_wiki_link = 1`, Reek linter is crashed
because `wiki_link` attribute does not exist in result.
It seems that `wiki_link` is now replaced with `documentation_link` in
recent version of Reek
* add support for checkov for terraform
* add tests for checkov handler
* add basic linter config tests for checkov
* update supported tools and languages lists
* simplify ale_linters#terraform#checkov#Handle
* ensure "-o json --quiet" is always set for checkov
* add documentation for checkov including config options
* fix tests after changing handling of default options for checkov
* add checkov to list of tools in doc/ale.txt
If virtualtext.vim is autoloaded first, it will link
ALEVirtualTextWarning to ALEWarning. But ALEWarning is not initialized
yet, so it will create ALEWarning, but with no color definition set.
Shortly after, highlight.vim is autoloaded, which would usually link
ALEWarning to SpellCap, but only if ALEWarning is not already set.
However since ALEWarning is already initialized due to the previous
link, we skip this and never actually come around to properly
initializing it.
We fix this by initializing all highlight groups in highlight.vim, thus
satisfying the dependency of ALEVirtualTextWarning being initialized
after ALEWarning.
Fixes#3585
* Add cppcheck handler match on misra msg
* Fix cppcheck --file-filter setting
This time, the tests and actually usage both work.
Co-authored-by: Dan George <dgeorge@anduril.com>
* Add cspell linter
Add cspell linter, with the languages it supports.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Add cspell Global Variables Documentation
Add documentation to /doc/ale.txt with cspell configuration options.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Add cspell to docs, Minor Cleanup
Add cspell for each supported language, adding some spaces and removing
others when caught navigating the file.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Add cppcheck handler match on misra msg
* Use --file-filter cppcheck option
Cppcheck recently added --file-filter so that cppcheck only checks the
filtered files, even when using --project option, which checks all files
in the project, by default. The --ccpcheck-build-dir option didn't help
enough (at all?).
* Added C test cases
Also fixed and assumed typo: foo.c, instead of foo.cpp
* Replace hard-coded full path filenames
Attempt to fix the windows platform test execution.
* Fix typo - foo.c, instead of foo.cpp
* Reset buffer var between tests
* Handle header files in cppcheck
Cppcheck isn't designed to check header files, stand-alone. Daniel
Marjamäki suggested using --suppress options to avoid FPs.
* Fix Vint complaint in cppcheck handler.
* Fix file path in cppcheck handler
Co-authored-by: Dan George <dgeorge@anduril.com>
Since having been added, the `alex` tool has added support for linting
on stdin. Rewrite this integration to reduce the number of tools
requiring disk-write access.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Adds phpactor lsp linter
* Fixes missing comma
* Adds tests for phpactor lsp linter
* Adds note that this part is not my own work
* Removes unused variable
* Adds phpactor to supported tools list
* Fixes doc sorting
* Wraps phpactor in code tags
* Add support for AVRA linting
* Add tests for AVRA linting and improve code
* Fix test
* Fix warning detection
* Fix test
* Fix test
* Add AVRA as a supported language in docs
* Adds --memmory-limit option for PHPStan linter
* Updates docs for phpstan --memory-limit option.
* Adds Arizard to authors
* Adds test for phpstan memory limit parameter
* Fixes order of parameters in test
* Changes dash to underscore
* Add Statix for Linting
Add `statix check` as a linter. Provides a simple set of definition
tests additionally. Variable names specify "check" to allow for later
addition of `statix fix` as a formatter once stream support is added.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Fixup Supported Tools List
I didn't realise there were two separate lists of tools, so add statix
to the other list. Also, remembered "S" comes after "R", and so
re-ordered it.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Fix statix Test File
I refactored the variables for statix to allow for writing a fixer
later, and forgot to update them in the test, so update them now. Also
remove a stray "i", add missing space before checks
Signed-off-by: David Houston <houstdav000@gmail.com>
* Update Output Stream for v0.4.0
statix v0.4.0 provides a breaking change of output stream from stderr to
stdout.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Add statix fix Fixer
Implement statix fix as a fixer for simple Nix antipatterns.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Fix statix Fixer Tests
Fix the statix fixer tests by removing the unnecessary
'read_temporary_file' value from the command, since it simply uses the
default value.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Add statix Handler Test
Add a test for the statix handler per @hsanson's request.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Fix to run only on stdin for linting
Signed-off-by: David Houston <houstdav000@gmail.com>
* Implement gofumpt Fixer
Add an implementation with test and documentation for the gofumpt go
code formatter, a stricter formatter than your standard "go fmt".
Signed-off-by: David Houston <houstdav000@gmail.com>
* Add gofumpt to ale.txt TOC
Forgot to add gofumpt to the ALE vim help Table of Contents, so do so.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Fix Test Setup Method Capitalization
I had put "Setup" instead of "SetUp" for "ale#assert#SetUpFixerTests".
Fix such.
Signed-off-by: David Houston <houstdav000@gmail.com>
* Fix typos
Add a missing space, remove an extra bracket by actually running tests
locally first. Would've been smart to do that from the beginning...
Signed-off-by: David Houston <houstdav000@gmail.com>
There is no need to filter for references in such a complicated way.
docker images already works if you just pass the image and tag as
an argument.
This caused problems if one was using podman with its docker-compatible
interface.
Previously podman would return the following error:
Error: cannot specify an image and a filter(s)
With this new method podman does not return an error anymore, causing
the image to not be redownloaded every time and it still works with
normal Docker.
Before this patch multiline warnings would appear in a single line with
'^@' as separator.
Now we use whitespace as separator to improve the appearance.
Also strip trailing whitespace, newlines, etc...
Fixes#3939
The `-T` option (for "taint checking") was deprecated in ruby 2.7
and removed entirely in ruby 3.0. This causes the linter to fail
entirely for users of ruby 3.0.
This was reported in #3537, and then fixed in #3538 - but it seems as
though in 9fe7b1fe6a, it was accidentally
and entirely undone.
This commit is essentially identical to #3538, aside from a path change
for the tests.
According to
https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#textDocument_codeAction,
the response to textDocument/codeAction is:
(Command | CodeAction)[] | null
and the code only handled the case where it was a CodeAction that either
specified an edit or a command, but didn't handle a direct Command.
Note that the specification also says that both can be specified and
then the edit is applied first, then the command. Furthermore, there
seems to be some hacky code handling arguments directly, which I suspect
is non-standard and only works with a specific LSP server that happens
to pass the edits in the arguments unmodified.
It is easier to explain this fix with an example:
* tsserver and LSPs ask for error information when you want to fix
error. tsserver `ts@getCodeFixes` command needs tsserver error code.
* now let's imagine that user has eslint and tsserver in use. Sometimes
both can report same error in different way.
* Now there is no guarantee which error will come first and if eslint
error comes first then tsserver will not return code fixes as we are
passing wrong error code to it.
This fix will return proper error code based on linter.
Without this, we have one `pyre` process running across different pyre
projects. With this change, files in different projects can be linted
with pyre at the same time.
Co-authored-by: Oliver Ruben Albertini <ora@fb.com>
It's necessary to provide a `-l` option to pyre with the closest parent
directory containing a `.pyre_configuration.local` file, or simply
change directory (cwd) to the root of the pyre project. Thanks to Ken
Verbosky for the code that fixes this.
Error seen when not using such a solution:
```
1031.473923 on 6: Dropping message 'ƛ Background task unexpectedly quited: Invalid configuration: Cannot find any source files to analyze. Either `source_directories` or `targets` must be specified.
```
Issue with this approach is that if you are editing files under
different projects, the `pyre persistent` process is not re-created for
each file. We have to do `:ALEStopAlllsps` in order for the process to
start with the new working directory.
Co-authored-by: Oliver Ruben Albertini <ora@fb.com>
More recent versions of thriftcheck use a more compliant GCC-style
output format which includes a space before the "severity" group.
This matches similar tools, like shellcheck.
This change adjusts the handler's pattern to parse this format in a
backwards-compatible way (even though backwards compatibility isn't
critical long-term as thriftcheck itself is close to its 1.0 release).
* Fix truncated echo
In typescript, when putting the cursor on a `>` character of an arrow
function, the displayString body comes back as an empty string, and
means the split operation has 0 items, causing a failure when attempting
to call TruncatedEcho.
Even if there's a better fix, I'd assume this is a good safety since we
are injesting external data.
* Convert to use `empty()`
This User autocommand is trigged immediately after an LSP process is
successfully initialized. This provides a way to perform any additional
initialization work, such as setting up buffer-level mappings.
* Add eslint as linter for JSON, JSONC and JSON5
Use the same lint configuration as eslint for javascript.
* Add documentation for JSON* eslint support
* Fix spacing in documentation
* Update docs to be unopinionated about plugins
Remove any preference for eslint plugins, since there are more thant one
that would work
* Reorder languages and tools in alphabetic order
* Fix misalignment
* Change orders to pass the tests
Look for all linters that have "lint_file" set to 1 and verify tools
that have it have the :floopy_disk: icon set and those that don't do not
have it.
Correspondingly added/removed !! on
ale-supported-languages-and-tools.txt file.
Co-authored-by: Horacio Sanson <horacio@allm.inc>
- Add .vintrc.yaml configuration that disables the scriptencoding check
(ProhibitMissingScriptEncoding) that is raised randomly.
- Upgrade vint to 0.3.21. Project seems to have stopped here and 0.4.0
was never released.
- Ensure the run-test scripts use the correct docker image (e.g. add tag)
.
Co-authored-by: Horacio Sanson <horacio@allm.inc>
For some reason CI tests started failing with these errors:
> ale_linters/eruby/erb.vim:1:1: Use scriptencoding when multibyte char exists (see :help :scriptencoding)
> ale_linters/mail/languagetool.vim:1:1: Use scriptencoding when multibyte char exists (see :help :scriptencoding)
Not sure at which point or what changed for this to happen but this MR
fixes it by removing the multibyte chars present on the problem files.
Co-authored-by: Horacio Sanson <horacio@allm.inc>
md5sum isn't available by default on macOS. Instead, it ships the
BSD-style md5(1) command, which does the same thing but with different
arguments.
With this change, run-tests works out-of-the-box on macOS.
* feat(deno): move init options to handlers
* feat(deno): add deno lsp support for js files
* feat(deno): use default map option
* feat(docs): add deno import map option
* feat(deno): add tests for importMap option
* fix(deno): use full path in importMap
* feat(deno): remove deno as linter for js, separate PR
* fix(deno): test for executable
* fix(deno-test): include filename to simplify function
* Add poetry support to python linters and black fixer.
* Update python.vim to detect poetry project.
* Update ale.vim, add an option for poetry `g:ale_python_auto_poetry`.
* Update ale-python.txt, add poetry support.
* Add and update poetry related tests.
Co-authored-by: unc0 <unc0@users.noreply.github.com>
* implement vim popups for preview
Details on implementation
-------------------------
- we make use of the |popupwin| api
- we split implementations (Nvim* vs. Vim* prefix) and call the right
one based on has('nvim')
- we follow a similar structure in each function, using the relevant API
- popup_list, win_execute, popup_settext in VimShow
- popup_create in VimCreate
- popup_close in VimClose
Some differences
----------------
- we DON'T have VimPrepareWindowContent because we use arguments to
popup_create for borders, padding, etc., and it also takes care of
buffer creation.
- we follow the protocol of setting and using w:preview for information,
but we only need the ID
- InsertEnter is the only autocommand required, because of
popup_create's moved argument. Any cursor movement with 'any' will
close the popup. This in turns means VimClose is only called from
InsertMode, so no mode-restoration necessary
- we don't tweak too much in the buffer because vim's popup buffers
already have most relevant settings and aren't editable without
calling popup functions.
- I enabled scrollbars, close buttons, dragging, and resizing
- vim popups get as big as they need to by default, so no worrying about
truncating/hiding/size
Note: we might want to consider changing w:preview to w:ale_preview to
avoid clashes if someone else tries to use the same variable
* floating window: document that vim supports it
* lint: fix indent/cont. lines
* Fix 3801 - Add ALEDummySign some width.
Due to changes in NeoVim 0.5 the g:ale_sign_column_always configuration
stopped working.
This PR sets the ALEDummySign to a blank space so when g:
ale_sign_column_always is set we have a sign with 1 width allowing the
configuration to work as before.
https://github.com/neovim/neovim/issues/13635
* Fix visual artifact on dummy sign
* Fix visual artifact on dummy sign (attempt 2)
Co-authored-by: Horacio Sanson <horacio@allm.inc>
* Correct typo in a config file filename.
.tool_versions should be .tool-versions
* Correct typo in config file names.
.tool_versions should be .tool-versions
* racket: support racket-langserver lsp
* racket-langserver: find highest dir with init.rkt
* autoload/ale/racket: re-indent to 4 spaces
* racket: lint: sort supported tools
* racket: lint: function!
This is _not_ needed anymore, but the lint wants it. See :help E127
* racket-langserver: do not use new dict format
* racket: lint: use snake_case
* add tests for racket-langserver
* racket-langserver tests: correct result values
* Also check for asdf-vm's .tool_versions file
A minimal python project may only be specifying a python version using a version management tool like asdf-vm, without providing other common python project configuration files. asdf-vm creates a single .tool_versions file in the managed directory. By checking for .tool_versions in addition to other common python config files we ensure that python linters (whose behaviour typically depends on a particular python version) will run with the same version of python used by the project. This will also be the same python version used by vim itself when it is run from inside the project's directories.
* add .tool_versions to ale-python-root documentation
This reflects the corresponding change to autoload/ale/python.vim
* Add yosys for verilog files.
* Add handler test for yosys.
* fix typo in yosys handler test
* fix array order in yosys handler test
* add yosys linter to filetype defaults test
* fix duplicate tag
* add 'yosys' to 'ale-supported-languages-and-tools.txt'
This is achieved by switching to JSON, which makes it much easier to
avoid confusion between an error message and the next one. It also
spares us from having to deal with regular expressions, and eliminates
some edge cases that no longer need to be tested.
- Show hadolint rule number in vim gutter in addition to `ALEDetails`
- Capture and show error in case of syntax errors
- Add tests for error capture
- Adapt existing tests
fixes: #2333fixes: #958
Both '-include' and '-imacros' take a file as an argument that will then
be searched in the include path like a regular '#include "..."'
statement in a source file. As such, they should not have their path
converted to an absolute path.
Signed-off-by: Michael Jeanson <mjeanson@efficios.com>
The -o/--option flag was removed in version 2.0.0 of rpmlint. Providing
this causes rpmlint to fail and provide no output. Only provide this
flag to rpmlint if the version is less than 2.0.0.
This allows the location list from one buffer to point to an issue in
another; previously, the error message would be shown but with no way to
jump to it.
The ocaml filetype is currently used for several, different file
formats. This causes problems as not all tools support all formats.
New filetypes are introduced to support this separation, this needs some
changes in ale that are fortunately backwards-compatible.
These change add ocamlinterface file support for ocp-indent, merlin,
ocamlformat and ocaml-lsp. For ocaml-lsp I took the liberty to
add all recognised language ids, even if they are not supported.
ols has not been changed as the project has been abandoned since 2019.
cmake-format added support for reading from/outputting to stdin/out as
of v0.3.6, released 2018-04-10 (commit 2e2aff2) [0].
Reading from stdin is preferable over reading from a temporary file
because when given a concrete file cmake-format will look for its config
file (.cmake-format.py or similar) in the parent directories of the
provided file. If the temporary file is off in a tmpdir somewhere (e.g.,
/tmp on *nix), cmake-format will almost certainly not come across the
user's intended format configuration file, making it appear that
cmake-format is ignoring the config file.
If cmake-format reads from stdin, though, it'll look for its config file
in its current working directory and its parent directories, in a
similar manner to clang-format. This has a much higher chance of running
across the intended config file.
[0]: https://github.com/cheshirekow/cmake_format/releases/tag/v0.3.6
Co-authored-by: Alex Wang <ts826848@gmail.com>
* fix: added support for local solhint executable
* feat: added support for matching parse errors
* test: added test for solhint command callback and handler
* chore: removed command callback test
* refactor: made solhint handler structure closer to eslint
* improve DMD handler
- ignore errors from other files
- catch 'Deprecation' as warning
- add tests
* adding filename key instead of filtering
* update dmd test
* fix test dmd windows
Buildifier offers a -path command line option:
> Buildifier's reformatting depends in part on the path to the file
> relative to the workspace directory. Normally buildifier deduces
> that path from the file names given, but the path can be given
> explicitly with the -path argument. This is especially useful when
> reformatting standard input, or in scripts that reformat a temporary
> copy of a file.
This lets us drop our `-type`-guessing logic.
For the moment, we rely on the buffer filename being "relative to the
workspace directory", which it generally is, but in a future change, we
should introduce logic that will locate the WORKSPACE file and adjusts
the filename relative to that directory. This could be complicated based
on the working directory in which `buildifier` is executed, so a little
more research is necessary to implement that logic correctly.
* add support for svelte via svelteserver language server
* svelte: fix Vint error and add a `svelteserver` simple test.
Co-authored-by: Joakim Repomaa <mail@j.repomaa.com>
Co-authored-by: Joakim Repomaa <mail@jreinert.com>
* Fix texlab GetProjectRoot
* Fix indents in texlab#GetProjectRoot
* Prevent texlab from starting on every tex file
* Update texlab Vader tests
* Fix GetProjectRoot to return parent of .git
Previously, the function returned `../.git/`. We want the function to return the parent directory above that as the project root. This should help pass Vader tests.
The `ale_lsp_root` setting is now deprecated, and `ale_root` should be
used instead. The setting will be used for both setting the root easily
for LSP linters, and for running other linters over whole projects.
Working directories are now set seperately from the commands so they
can later be swapped out when running linters over projects is
supported, and also better support filename mapping for running linters
on other machines in future.
* Fix ansible-lint linter definition.
Use ansible-lint's feature auto-detection instead of temporary file.
For auto-detection to work, ansible project has to be also a git repository.
Don't use yaml rules. These are checked by yamllint.
Refactor pattern to work with ansible-lint >=5.0 version.
Clean-up obsolete test cases.
* Pull Request changes
This fixer enables buildifier's formatting and "lint fix" modes.
Additional options can be provided via `bazel_buildifier_options`.
It also implements some basic logic for guessing the file's type.
buildifier itself usually does this based on the filenames provided on
the command line, but because we're piping our buffer via stdin, we need
to do this manually.
* Allow clangformat to use a local style file.
* Add tests.
* Fix Vint issue.
* Improve explanation of feature in documentation.
* Fix failing test.
The test was checking the wrong directory.
* Simplify verilator linter using ale command format strings
* Verilator Linter: Restructure linter command tests
* Verilator Linter: adds to the handler test the returned filename
* Verilator Linter: add the current file path to the search path
* Verilator Linter: Add the search path to the tests
Co-authored-by: TG <tarik.graba@telecom-paris.fr>
Makefiles using GNU-make features might be called "GNUmakefile" instead
of "Makefile". This commit teaches the `c_parse_makefile` feature to
look for a GNUmakefile file if a Makefile is not present.
* The build status badge is now for GitHub Actions.
* The documentation now mentions GitHub instead.
* Warnings in the YAML file have been fixed or ignored.
* Add vim82 and neovim04 to CI tests.
* Fix test_sign_column_hightlighting test.
In vim82 with verbose=1 the output of highlight command changes breaking
the ale#sign#SetUpDefaultColumnWithoutErrorsHighlight(). This commit
forces verbose=0 when the method starts and restores the previous value
before exiting.
* No return values in vim82 returns a numeric value instead of a empty string.
* Fix test_reek_handler test
The FuzzyJSONDecode() method catches E474 when it fails to parse the
input as JSON but Vim8.2 throws E491 instead. This commit modifies the
function to catch both E474 or E491.
* Fix perl6 handler test.
Perl6 handler catches json parse errors using the E474 error but in
Vim82 it changed to E491. This commit modifies the handler so both
errors are considered.
* Fix list opening tests.
In Vim 8.2 the call `range(1, bufnr('$'))` always returns quickfix
buffers no matter if they are closed or not. Using `ls` does not show
them but the above range will always include them.
This new behavior breaks the ale#list#IsQuickfixOpen() method that in
turn breaks many other things. This commit fixes this by using the
getqflist() and getloclist() methods instead.
* Fix test updates loclist test.
For some reason in Vim 8.2 the sign offset seems to not reset between
tests causing the sign_id to not match in the Assert. When the test is
run individually it passes but when run as part of the whole suite the
sign_id is off by one.
Forcing the offset in the test setup seems to fix the issue.
* Fix omnifunc completion test.
For unknown reasons the SetCompletionResponse tests fail in Neovim 0.2
and 0.4. Unfortunatelly the only solution I found is to disable them
for neovim.
* Fix linter warnings
* Fix smoker test.
Add vim 8.2 to the list of versions that need some retires due to
randomly failing tests.
* Add docker image build job.
Trying some clever trick to build the docker image if not available
locally or in Docker hub. It uses the Dockerfile md5 checksum as tag so
only when changes on that file occur will the image be downloaded or
build.
* Add labels to Docker image
* Remove tests for middle versions 8.1 and 0.3.5
* Use same vader commit as appveyor
* Implement image push to Docker Hub
Co-authored-by: Horacio Sanson <horacio@allm.inc>
In the (unreleased) Nix 2.4 the error-messages have been reformatted[1].
This patch aims to retain proper `.nix`-support in `ale`, for both
stable Nix (2.3 and older) and unstable Nix (2.4 and newer).
[1] https://github.com/NixOS/nix/pull/3590
* master: (133 commits)
Add rnix-lsp for Nix diagnostics and completion
add spectral support for json
add spectral handler
add spectral linter for yaml
doc: Fix linter issues
doc: Add documentation for Deno
feat: Add Deno lsp support
feat: Add Deno fmt fixer
Add document for apkbuild filetype
Add tests for atools handler, basic and dealing with Error and Warning
Test default linters for apkbuild
Document new default linters for apkbuild
Make apkbuild_lint and secfixes_check default for apkbuild filetype
document support for apkbuild-lint and secfixes-check for apkbuild
Add linters for apkbuild-lint and secfixes-check from atools
Add handler for the output of atools
Fix typos
Add command callback tests
Add support for standalone files
Fix linting errors
...
atools is a collection of tools written in ash shell and Lua that
provide linting for Alpine Linux's APKBUILD.
APKBUILDs are build recipes used by Alpine Linux's build system, abuild,
an equivalent would be Arch Linux's PKGBUILD and Gentoo's ebuild.
Seems standardrb fails to properly use the --config option when using
temporary files but works fine when reading from stdin. This commit
changes the fixer so it uses stdin instead of temporary files.
* Fix 354 - Migrate CI from travis to Github Actions
* Use matrix strategy for parallel tests
* Don't build image on each run
* Add push trigger on tags
Co-authored-by: Horacio Sanson <horacio@allm.inc>
* Add nvim floating window hover support
* Add configuration for float to replace preview
* preview#ShowFloating: qualify local variables
* Configure floating preview usecases individually
Also:
* Extract floating preview to its own file.
* Ignore 'stay_here' option. Moving into the floating preview window
seems confusing at best.
* Re-use existing floating preview window if it's still up.
* Flush out floating preview documentation.
* Watch cursor position changes per window
Floating previews open a new window, so when that window is written to,
it moves briefly there at a different position than the original window.
This makes repeated positions detected when positions are tracked at a
s: level. Instead, we change the variable to window scoped, which only
fires a message if the cursor has changed from the last position in
*that window*.
* g:ale_floating_preview cleanup
* floating_preview: add ALEDetail tests
* Fix fecs test missing runtime call
* Add ALEHover floating preview tests
Co-authored-by: Jan-Grimo Sobez <jan-grimo.sobez@phys.chem.ethz.ch>
Prior to #3448, several linters should have been failing the
custom-checks that look for non-snake-cased lint names. They weren't,
but now the bug that hid those is fixed. So to avoid breaking users, we
just exclude those from the check. Linters excluded:
* clojure/clj_kondo.vim
* elixir/elixir_ls.vim
* go/golangci_lint.vim
* swift/swiftformat.vim
This adds a linter for Inko (https://inko-lang.org/). The linter makes
use of Inko's own compiler, and a newly introduced --check flag to only
check for errors; instead of also compiling source code.
* origin/master: (40 commits)
fix: correct suggested filetype for yamlfix
feat: add yamlfix fixer
Use _config for LSP config options
Add support for R languageserver (#3370)
Fix 3103 - add shellcheck shell directive detection. (#3216)
Added the Vundle command in installation instructions (#3400)
Adds support for Tlint - A Tighten Opinionated PHP Linter (#3291)
Add php phpcbf options (#3383)
Use has('gui_running') instead of has('gui')
Close#2727 - Add a hover-only setting for balloons
Fix#3332 - Modify everything for rename/actions
Add a missing blank line in documentation
Add luafmt fixer (#3289)
#3442 Fix code fix clangd issue
Close#1466 - Add GVIM refactor menu support
Look for node packages in .yarn/sdks as well
Update documentation for code actions and rename
cmp forwards, and reverse the code actions
Support for LSP/tsserver Code Actions (#3437)
Move the test for buffer-local variables
...
Hadolint is in the process of adding the severity of a lint rule to the
commandline output: https://github.com/hadolint/hadolint/pull/501
This change utilizes that to show the severity in vim.
NOTE: The custom-linting-rules test fails due to the following (legit)
warnings:
ale_linters/clojure/clj_kondo.vim:29 Use snake_case names for linters
ale_linters/elixir/elixir_ls.vim:15 Use snake_case names for linters
ale_linters/go/golangci_lint.vim:54 Use snake_case names for linters
ale_linters/swift/swiftformat.vim:56 Use snake_case names for linters
The message wasn't getting printed because docker was explicitly only
being asked to connect stdout (ignoring stderr). Unclear yet why the
error code wasn't getting bubbled up.
sed wasn't using -E, so '|' wasn't being handled properly. Seems likely
that's sed-implementation specific, so now it runs through docker's sed
to support portability.
* Fix 3103 - add shellcheck shell directive detection.
Searches for shellcheck shell directive to detect dialects for scripts
that do not have shebang.
* Change order of detection of shellcheck dialect
In a situation where the filetype can be wrong (example: something.sh
which is written in bash dialect) and has no hash-bang (since it is
meant to be sourced) then the override specified within the script will
be ignored.
It probably is the most right thing to do if the script author has added
a specific directive; it should trump everything else.
Co-authored-by: Horacio Sanson <horacio@allm.inc>
Co-authored-by: Dino Korah <dino.korah@redmatter.com>
ALE now just modifies every open buffer for rename and actions, and sets
up a one-time use BufEnter event to reload buffers that are changed so
you don't have to think about what to do with changed buffers.
* Added tsserver and LSP code action support.
* tsserver refactors support added.
* Handling special case when new text is added after new line symbol.
* ale#code_action#ApplyChanges simplified.
* Initial attempt on LSP Code Actions.
* workspace/executeCommand added.
* Some null checks added.
* Add last column to LSP Code Action message.
* Pass diagnostics to LSP code action.
Previously ApplyChanges code was applied from top-to-bottom that required
extra parameters to track progress and there was bug. I have changed code
to bottom-to-top approach as that does not require those extra parameters
and solved the bug.
Tested with typescript-language-server and it is working.
The "ale#handlers#sh#GetShellType()" function currently falls back
to the file type without checking for buffer-local variables first.
This causes the function to return "sh" even when a script is known
by Vim to be a script of a more specific type (e.g., "bash").
The "ale#handlers#shellcheck#GetDialectArgument()" function then
erroneously uses this type even though a more fitting type should be
used instead. Files without a "#!" line will be of type "sh" even
though they may have a ".bash" suffix.
This commit fixes the problem by checking for buffer-local shell
type variables (set by Vim) before falling back to the file type.
* origin/master:
Add tests for maven.vim file
Fix grammatical error in doc
Add maven helper file; use maven wrapper if available instead of global 'mvn' executable
fix lint, fix variable semantics and update tests
bibclean: update matchlist reges for bibclean > v2.11.4
Update rubocop_auto_correct_all tag
A recent(?) update to swipl changed the error format from
Warning: some.pl:2:
Singleton variables: [Y]
to
Warning: some.pl:2:
Warning: Singleton variables: [Y]
The old error handler doesn't report the correct line numbers and
messages on the old format.
I've chosen to add a function that covers the second case and detect it,
rather than rewrite the current function. This way, both versions should
be able to live together.
---
Example file that demonstrates the issue (some.pl above):
```
% vim: ft=prolog
ii(X, Y) :- X.
```
---
Newer versions of pylint will now check your code as you type. Older
versions will still only check the file on disk.
Co-authored-by: Oliver Wiegers <oliver.wiegers@gmail.com>
Add an `ALECompletePost` event along with everything needed to make it
useful for its primary purpose: fixing code after inserting completions.
* `ALEFix` can now be called with a bang (`!`) to suppress errors.
* A new `ALELintStop` command lets you stop linting, and start it later.
A new command, `:ALEImport`, has been added, which lets you import words
at your cursor if a completion provider can provide a completion for
that word which includes some additional text changes.
* ember-template-lint: Lint from stdin
* This feature has recently been implemented in ember-template-lint.
* Refactor ember-template-lint executable
* Fallback on a temporary file for old template-lint
Co-authored-by: w0rp <w0rp@users.noreply.github.com>
Option `per-file-ignores` was introduced in flake8 version 3.7.0.
It allows to ignore specific errors in specific files using glob syntax.
For example `per-file-ignores = src/generated/*.py:F401` will
ignore `F401` error in all python files in `src/generated`.
Thus ale has to run flake8 from project root where .flake8 config
is placed otherwise glob won't match linted file.
`lint_file` can now be computed dynamically with a callback function,
which can return a deferred result, as per `ale#command#Run`. This
allows linters to dynamically switch between checking files on disk,
or checking code on the fly.
Some tests have been fixed on Windows.
Prettier does not use `.prettierignore` unless the current directory is the root where the `.prettierignore` file resides.
* Update Prettier tests
* Look for prettierignore to determine project root
ALE now converts paths from compile_commands.json files into absolute
paths and prefers matching against absolute file and directory names for
determining which flags to use for files. As a result, parsing
compile_commands.json to determine flags should work for a lot more C
and C++ projects.
ALE was incorrectly detecting completion results from servers such as
rust-analyzer as wanting to add import lines when additionalTextEdits
was present, but empty.
Now ALE only filters out completion results if the autoimport setting is
off, and one of the additionalTextEdits starts on some line other than
the current line. If any additionalTextEdits happen to be identical to
the change from completion anyway, ALE will skip them.
Users can easily be confused when they set some options for a C or C++
compiler, and another compiler is run with different options, which
still reports errors. To remedy this, the existing `gcc` and `clang`
linters have been replaced with a `cc` linter that will run either
compiler.
This is a breaking change for ALE v3.0.0.
Certain tests could break if you ran them separately from other tests.
They have been patched.
`run-tests` now has a `--fast` option which runs tests with only the
fastest Vim version ALE tests with, and the custom checks.
* Restore old behavior of ALEFix command for Rubocop
Since RuboCop 0.60 ALEFix command stopped to fix all found offenses. This change restores the
previous behavior by allowing rubocop to fix all detected offenses.
* Fix tests
* Allow to configure auto-correct option for Rubocop
The options for parsing `make -n` and `compile_commands.json` flags
are now enabled by default, so people can start getting better flags
for their files by default.
`compile_commands.json` flags are now preferred over `make -n` results,
to make the options work better by default.
* fix cppcheck for 1.89+, and add column support
In cppcheck 1.89 the output changed to be more like GCC. This commit
forces any version of cppcheck to output in that same format. This also
allows for ALE to pick up the linter's column information
* Add parameters to tests. Vader passes.
* Fix c cppcheck for v1.89
* Added hdl_checker support
* Added hdl_checker tests
HDL Checker searches for files when no config file is found, which could lead to very long searches when the user is not really on a project setting
* Split FindNearestExecutable from FindExecutable
The path searching in ale#node#FindExecutable() will be useful for
eslint. Refactor it into a separate function so it can be used without
regard for the state of the _use_global and _executable variables.
Signed-off-by: Kevin Locke <kevin@kevinlocke.name>
* eslint: Set project root from local executable
Using the nearest directory with node_modules does not work correctly
for nested projects where the eslint dependencies are in the outer
project. For example:
https://github.com/dense-analysis/ale/issues/3143#issuecomment-652452362
Adopt the behavior of SublimeLinter, which runs from project_root
determined by the presence of the eslint executable in node_modules/.bin
(or eslint in dependencies/devDependencies of package.json, which we can
add later as necessary). See [NodeLinter#find_local_executable].
[NodeLinter#find_local_executable]: https://github.com/SublimeLinter/SublimeLinter/blob/056e6f6/lint/base_linter/node_linter.py#L109
Signed-off-by: Kevin Locke <kevin@kevinlocke.name>
* Split eslint#GetCdString from eslint#GetCommand
Move the code for finding the project root and building the cd string
into a separate function so that it can be reused in the eslint fixer.
Signed-off-by: Kevin Locke <kevin@kevinlocke.name>
* Run ESLint fixer from project root dir
To match the ESLint linter, as changed in 9ee57d43 (which I forgot to
apply to the fixer, whoops).
Fixes: #3094Closes: #3095
Signed-off-by: Kevin Locke <kevin@kevinlocke.name>
So that I can find the relevant information in the vint
linting policy summary and policies can be easily configured
https://github.com/Vimjas/vint/wiki/Vint-linting-policy-summary
Before this change an example warning message appears as:
autocmd should execute in an augroup or execute with a group (see :help :autocmd)
After this change the same example appears as:
ProhibitAutocmdWithNoGroup - autocmd should execute in an augroup or execute with a group (see :help :autocmd)
1. The often longish `description` moved away from (supposedly short)
statusline `message` into the `detail` section.
2. dockerfile_lint sends `reference_url` pointing to issue explanations.
Use that.
Windows may insert carriage return line endings, which ALE does not handle
well. These characters should not be displayed.
Adds a line to remove these characters for all messages.
ALE appends flags from {c,cpp}_{clang,gcc}_options after those found by
parsing compile_commands.json or Makefile output. If -std=* flags are
present in both the ALE flags and parsed flags, the last one present
(i.e., ALE's -std=* flag) will determine the mode the compiler works in.
This can result in errors showing up in vim but not in the actual build
or vice-versa.
For example, say you have foo.cpp:
#include <type_traits>
int main() {
return std::is_same_v<float, int>;
}
If cpp_clang_options contains -std=c++17 and -std=c++14 is parsed from
compile_commands.json, then ALE would end up running something like:
clang++ -S -x c++ -fsyntax-only -std=c++14 -std=c++17 - < foo.cpp
This would result in no errors showing up in Vim, but the actual build
would fail with:
<stdin>:3:14: error: no template named 'is_same_v' in namespace 'std'; did you mean 'is_same'?
return std::is_same_v<float, int>;
~~~~~^~~~~~~~~
is_same
/Library/Developer/CommandLineTools/usr/bin/../include/c++/v1/type_traits:872:61: note: 'is_same' declared here
template <class _Tp, class _Up> struct _LIBCPP_TEMPLATE_VIS is_same : public false_type {};
^
<stdin>:3:35: error: expected '(' for function-style cast or type construction
return std::is_same_v<float, int>;
~~~~~~~~~~~~~~~~~~~~~~~~~~^
2 errors generated.
as the actual build would not have the -std=c++17 flag added by ALE.
If cpp_clang_options contains -std=c++14 and -std=c++17 is parsed from
compile_commands.json, then the opposite problem would occur. ALE would
end up running something like:
clang++ -S -x c++ -fsyntax-only -std=c++17 -std=c++14 - < foo.cpp
and would show an error on line 3 of foo.cpp:
[clang] No template named 'is_same_v' in namespace 'std'; did you mean 'is_same'? (fix available)
The actual build, on the other hand, would succeed without any
complaints.
Removing -std=* from ALE's flags if it is already present in the parsed
flags ensures that the wrong -std=* flag is not used.
An alternative would have been to switch the order in which parsed flags
and ALE flags were concatenated when producing the command to execute,
but that could prevent a user from intentionally using ALE's flags to
override some other flags, e.g. -W* flags to enable/disable warnings in
a project whose flags are not under the developer's control.
-std=* flags are also present in cuda/nvcc.vim, objc/clang.vim,
objcpp/clang.vim, and vhdl/ghdl.vim, but none of those linters appear to
parse compile_commands.json or `make` output.
The standard linter --fix fails if the file being input is not relative
to the project root (https://github.com/standard/standard/issues/1384).
This MR attempts to fix this by changing the command so the input file
is relative to the project root and the output is to a temporary file.
Preliminary tests with toy javascript projects seem to indicate this
works fine.
Rather than requiring users to alias ps1 to powershell themselves,
include it in s:default_ale_linter_aliases. Since [vim-ps1] is a
popular (the only?) PowerShell ftplugin and there do not appear to be
any other uses of ft=ps1 on vim.org, this seems like a safe and
reasonable default.
[vim-ps1]: http://www.vim.org/scripts/script.php?script_id=1327
Signed-off-by: Kevin Locke <kevin@kevinlocke.name>
Before this change, prettier_standard would run and ignore any
.prettierrc, now it will respect the configuration of the file being
linted.
This change relies on prettier-standard 16.1.0 for the --stdin-filepath
flag, but is backward compatible: older versions of prettier-standard
will ignore the unknown flag and continue to run with no configuration
file.
If checkstyle is configured with custom options that contain "-c" then
the checkstyle config file option is ignored. This PR modifies the
regular expression when creating the checkstyle command to avoid this.
Some files lack a hashbang line but still have an unambiguous filetype.
For example, the file `.zshrc` has the filetype `zsh`.
Augment ale#handlers#sh#GetShellType to fall back to the filetype if
no hashbang line can be found.
ALE (Asynchronous Lint Engine) is a plugin providing linting (syntax checking
and semantic errors) in NeoVim 0.2.0+ and Vim 8 while you edit your text files,
and semantic errors) in Neovim 0.7.0+ and Vim 8.0+ while you edit your text files,
and acts as a Vim [Language Server Protocol](https://langserver.org/) client.
<img src="https://user-images.githubusercontent.com/3518142/59195938-3a81b100-8b85-11e9-8e8d-6a601b1db908.gif" alt="A linting example with the darkspectrum color scheme in GVim." title="A linting example with the darkspectrum color scheme in GVim.">
<video autoplay="true" muted="true" loop="true" controls="false" src="https://user-images.githubusercontent.com/3518142/210141215-8f2ff760-6a87-4704-a11e-c109b8e9ec41.mp4" title="An example showing what ALE can do."></video>
ALE makes use of NeoVim and Vim 8 job control functions and timers to
ALE makes use of Neovim and Vim 8 job control functions and timers to
run linters on the contents of text buffers and return errors as
text is changed in Vim. This allows for displaying warnings and
errors in files being edited in Vim before files have been saved
@@ -42,58 +43,34 @@ email at [dev@w0rp.com](mailto:dev@w0rp.com?subject=Helping%20with%20ALE).
If you enjoy this plugin, feel free to contribute or check out the author's
other content at [w0rp.com](https://w0rp.com).
## Table of Contents
## Why ALE?
1. [Supported Languages and Tools](#supported-languages)
2. [Usage](#usage)
1. [Linting](#usage-linting)
2. [Fixing](#usage-fixing)
3. [Completion](#usage-completion)
4. [Go To Definition](#usage-go-to-definition)
5. [Find References](#usage-find-references)
6. [Hovering](#usage-hover)
7. [Symbol Search](#usage-symbol-search)
3. [Installation](#installation)
1. [Installation with Vim package management](#standard-installation)
2. [Installation with Pathogen](#installation-with-pathogen)
3. [Installation with Vundle](#installation-with-vundle)
4. [Installation with Vim-Plug](#installation-with-vim-plug)
4. [Contributing](#contributing)
5. [FAQ](#faq)
1. [How do I disable particular linters?](#faq-disable-linters)
2. [How can I keep the sign gutter open?](#faq-keep-signs)
3. [How can I change the signs ALE uses?](#faq-change-signs)
4. [How can I change or disable the highlights ALE uses?](#faq-change-highlights)
5. [How can I show errors or warnings in my statusline?](#faq-statusline)
6. [How can I show errors or warnings in my lightline?](#faq-lightline)
7. [How can I change the format for echo messages?](#faq-echo-format)
8. [How can I execute some code when ALE starts or stops linting?](#faq-autocmd)
9. [How can I navigate between errors quickly?](#faq-navigation)
10. [How can I run linters only when I save files?](#faq-lint-on-save)
11. [How can I use the quickfix list instead of the loclist?](#faq-quickfix)
12. [How can I check JSX files with both stylelint and eslint?](#faq-jsx-stylelint-eslint)
13. [How can I check Vue files with ESLint?](#faq-vue-eslint)
14. [Will this plugin eat all of my laptop battery power?](#faq-my-battery-is-sad)
15. [How can I configure my C or C++ project?](#faq-c-configuration)
16. [How can I configure ALE differently for different buffers?](#faq-buffer-configuration)
17. [How can I configure the height of the list in which ALE displays errors?](#faq-list-window-height)
18. [How can I see what ALE has configured for the current file?](#faq-get-info)
ALE has been around for many years, and there are many ways to run asynchronous
linting and fixing of code in Vim. ALE offers the following.
<a name="supported-languages"></a>
* No dependencies for ALE itself
* Lightweight plugin architecture (No JavaScript or Python required)
* Low memory footprint
* Runs virtually everywhere, including remote shells, and in `git commit`
* Out of the box support for running particular linters and language servers
* Near-zero configuration with custom code for better defaults
* Highly customizable and well-documented (`:help ale-options`)
* Breaking changes for the plugin are extremely rare
* Support for older Vim and Neovim versions
* Windows support
* Well-integrated with other plugins
## 1. Supported Languages and Tools
## Supported Languages and Tools
ALE supports a wide variety of languages and tools. See the
[full list](supported-tools.md) in the
[Supported Languages and Tools](supported-tools.md) page.
<a name="usage"></a>
## 2. Usage
## Usage
<a name="usage-linting"></a>
### 2.i Linting
### Linting
Once this plugin is installed, while editing your files in supported
languages and tools which have been correctly installed,
@@ -102,14 +79,14 @@ programs for checking the syntax and semantics of your programs. By default,
linters will be re-run in the background to check your syntax when you open
new buffers or as you make edits to your files.
The behaviour of linting can be configured with a variety of options,
The behavior of linting can be configured with a variety of options,
documented in [the Vim help file](doc/ale.txt). For more information on the
options ALE offers, consult `:help ale-options` for global options and `:help
ale-integration-options` for options specified to particular linters.
<a name="usage-fixing"></a>
### 2.ii Fixing
### Fixing
ALE can fix files with the `ALEFix` command. Functions need to be configured
either in each buffer with a `b:ale_fixers`, or globally with `g:ale_fixers`.
@@ -157,7 +134,7 @@ See `:help ale-fix` for complete information on how to fix files with ALE.
<a name="usage-completion"></a>
### 2.iii Completion
### Completion
ALE offers some support for completion via hijacking of omnicompletion while you
type. All of ALE's completion information must come from Language Server
@@ -193,19 +170,19 @@ completion manually with `<C-x><C-o>`.
setomnifunc=ale#completion#OmniFunc
```
When working with TypeScript files, ALE supports automatic imports from
external modules. This behavior is disabled by default and can be enabled by
setting:
ALE supports automatic imports from external modules. This behavior is enabled
by default and can be disabled by setting:
```vim
letg:ale_completion_tsserver_autoimport=1
letg:ale_completion_autoimport=0
```
See `:help ale-completion` for more information.
Note that disabling auto import can result in missing completion items from some
LSP servers (e.g. eclipselsp). See `:help ale-completion` for more information.
<a name="usage-go-to-definition"></a>
### 2.iv Go To Definition
### Go To Definition
ALE supports jumping to the definition of words under your cursor with the
`:ALEGoToDefinition` command using any enabled Language Server Protocol linters
@@ -215,7 +192,7 @@ See `:help ale-go-to-definition` for more information.
<a name="usage-find-references"></a>
### 2.v Find References
### Find References
ALE supports finding references for words under your cursor with the
`:ALEFindReferences` command using any enabled Language Server Protocol linters
@@ -225,12 +202,15 @@ See `:help ale-find-references` for more information.
<a name="usage-hover"></a>
### 2.vi Hovering
### Hovering
ALE supports "hover" information for printing brief information about symbols at
the cursor taken from Language Server Protocol linters and `tsserver` with the
`ALEHover` command.
Truncated information will be displayed when the cursor rests on a symbol by
default, as long as there are no problems on the same line.
The information can be displayed in a `balloon` tooltip in Vim or GVim by
hovering your mouse over symbols. Mouse hovering is enabled by default in GVim,
and needs to be configured for Vim 8.1+ in terminals.
@@ -239,7 +219,7 @@ See `:help ale-hover` for more information.
<a name="usage-symbol-search"></a>
### 2.vii Symbol Search
### Symbol Search
ALE supports searching for workspace symbols via Language Server Protocol
linters with the `ALESymbolSearch` command.
@@ -249,38 +229,46 @@ similar to a given query string.
See `:help ale-symbol-search` for more information.
<a name="installation"></a>
<a name="usage-refactoring"></a>
## 3. Installation
### Refactoring: Rename, Actions
To install this plugin, you should use one of the following methods.
For Windows users, replace usage of the Unix `~/.vim` directory with
`%USERPROFILE%\vimfiles`, or another directory if you have configured
Vim differently. On Windows, your `~/.vimrc` file will be similarly
stored in `%USERPROFILE%\_vimrc`.
ALE supports renaming symbols in code such as variables or class
names with the `ALERename` command.
<a name="standard-installation"></a>
`ALEFileRename` will rename file and fix import paths (tsserver
only).
### 3.i. Installation with Vim package management
`ALECodeAction` will execute actions on the cursor or applied to a visual
range selection, such as automatically fixing errors.
In Vim 8 and NeoVim, you can install plugins easily without needing to use
any other tools. Simply clone the plugin into your `pack` directory.
See `:help ale-refactor` for more information.
#### Vim 8 on Unix
## Installation
Add ALE to your runtime path in the usual ways.
If you have trouble reading `:help ale`, try the following.
[vim-airline](https://github.com/vim-airline/vim-airline) integrates with ALE
for displaying error information in the status bar. If you want to see the
@@ -484,9 +526,10 @@ The airline extension can be enabled by adding the following to your vimrc:
letg:airline#extensions#ale#enabled=1
```
If you don't want to use vim-airline, you can implement your own statusline
function without adding any other plugins. ALE provides some functions to
assist in this endeavour, including:
#### Custom statusline
You can implement your own statusline function without adding any other plugins.
ALE provides some functions to assist in this endeavour, including:
*`ale#statusline#Count`: Which returns the number of problems found by ALE
for a specified buffer.
@@ -519,47 +562,136 @@ set statusline=%{LinterStatus()}
See `:help ale#statusline#Count()` or `:help ale#statusline#FirstProblem()`
for more information.
<a name="faq-lightline"></a>
<a name="faq-window-borders"></a>
### 5.vi. How can I show errors or warnings in my lightline?
### How can I change the borders for floating preview windows?
[lightline](https://github.com/itchyny/lightline.vim) does not have built-in
support for ALE, nevertheless there is a plugin that adds this functionality: [maximbaz/lightline-ale](https://github.com/maximbaz/lightline-ale).
Borders for floating preview windows are enabled by default. You can use the
`g:ale_floating_window_border` setting to configure them.
For more information, check out the sources of that plugin, `:help ale#statusline#Count()` and [lightline documentation](https://github.com/itchyny/lightline.vim#advanced-configuration).
<a name="faq-echo-format"></a>
### 5.vii. How can I change the format for echo messages?
There are 3 global options that allow customizing the echoed message.
-`g:ale_echo_msg_format` where:
*`%s` is the error message itself
*`%...code...%` is an optional error code, and most characters can be
written between the `%` characters.
*`%linter%` is the linter name
*`%severity%` is the severity type
-`g:ale_echo_msg_error_str` is the string used for error severity.
-`g:ale_echo_msg_warning_str` is the string used for warning severity.
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
