Remove error highlights when buffers are cleaned up

PHP: Fix double errors and support fatal errors

.gitattributes

@@ -1,7 +1,9 @@
 .* export-ignore
 /CONTRIBUTING.md export-ignore
 /Dockerfile export-ignore
+/ISSUE_TEMPLATE.md export-ignore
 /Makefile export-ignore
 /README.md export-ignore
+/custom-checks export-ignore
 /img export-ignore
 /test export-ignore

.travis.yml

@@ -2,6 +2,9 @@
 sudo: required
 services:
     - docker
+branches:
+    only:
+        - master
 language: python
 script: |
     make test

CONTRIBUTING.md

@@ -1,8 +1,15 @@
 # Contributing to ALE
 
 1. [Guidelines](#guidelines)
-2. [Creating Pull Requests](#pull-requests)
-3. [Creating Pull Requests](#compiling)
+2. [Creating Issues](#issues)
+3. [Creating Pull Requests](#pull-requests)
+ 1. [Adding a New Linter](#adding-a-new-linter)
+ 2. [Adding New Options](#adding-new-options)
+4. [Writing Documentation](#writing-documentation)
+ 1. [Documenting New Linters](#documenting-new-linters)
+ 2. [Editing the Online Documentation](#editing-online-documentation)
+ 3. [Documenting Linter Options](#documenting-new-options)
+5. [In Case of Busses](#in-case-of-busses)
 
 <a name="guidelines"></a>
 
@@ -10,16 +17,50 @@
 
 Have fun, and work on whatever floats your boat. Take It Easy :tm:.
 
+Don't forget to **write documentation** for whatever it is you are doing.
+See the ["Writing Documentation"](#writing-documentation) section.
+
+Remember to write Vader tests for most of the code you write. You can look at
+existing Vader tests in the `test` directory for examples.
+
+When writing code, follow the [Google Vimscript Style
+Guide](https://google.github.io/styleguide/vimscriptguide.xml), and run `vint
+-s` on your files to check for most of what the guide mentions and more. If you
+install this plugin (ALE) and install [Vint](https://github.com/Kuniwak/vint), it
+will check your code while you type.
+
+<a name="issues"></a>
+
+# 2. Creating Issues
+
+Before creating any issues, please look through the current list of issues and
+pull requests, and ensure that the issue hasn't already been reported. If an
+issue has already been reported, but you have some new insight, please add
+a comment to the existing issue.
+
+Please read the FAQ in the README before creating any issues. A feature
+you desire may already exist and be documented, or the FAQ might explain
+how to solve a problem you have already.
+
+Please try and describe any issues reported with as much detail as you can
+provide about your Vim version, the linter you were trying to run, your
+operating system, or any other information you think might be helpful.
+
+Please describe your issue in clear, grammatically correct, and easy to
+understand English. You are more likely to see an issue resolved if others
+can understand you.
+
 <a name="pull-requests"></a>
 
-# 2. Creating Pull Requests
+# 3. Creating Pull Requests
 
-For code you write, make sure to credit yourself at the top of files you add, and probably those you modify. You can write
-some comments at the top of your VIM files.
+For code you write, make sure to credit yourself at the top of files you add,
+and probably those you modify. You can write some comments at the top of your
+VIM files.
 
 ```vim
 " Author: John Smith <john.smith@gmail.com>
-" Description: This file adds support for awesomelinter to the best language ever.
+" Description: This file adds support for awesomelinter for the best language ever.
 ```
 
 If you want to credit multiple authors, you can comma separate them.
@@ -28,34 +69,105 @@ If you want to credit multiple authors, you can comma separate them.
 " Author: John Smith <john.smith@gmail.com>, Jane Doe <https://jane-doe.info>
 ```
 
-# 2.1. Adding a New Linter
+<a name="adding-a-new-linter"></a>
 
-If you add a new linter, look for existing handlers first in the [handlers.vim](plugin/ale/handlers.vim) file. One of the handlers
-there may already be able to handle your lines of output. If you find that your new linter replicates an existing error handler,
-consider pulling it up into the [handlers.vim](plugin/ale/handlers.vim) file, and use the generic handler in both places.
+# 3.i. Adding a New Linter
 
-When you add a linter, make sure the language for the linter and the linter itself are present in the table in the
-[README.md](README.md) file and in the Vim [help file](doc/ale.txt). The programs and linters are sorted alphabetically in the
-table and list.
+If you add a new linter, look for existing handlers first in the
+[handlers.vim](autoload/ale/handlers.vim) file. One of the handlers there may
+already be able to handle your lines of output. If you find that your new
+linter replicates an existing error handler, consider pulling it up into the
+[handlers.vim](autoload/ale/handlers.vim) file, and use the generic handler in
+both places.
 
-# 2.2. Adding New Options
+When you add a linter, make sure the language for the linter and the linter
+itself are present in the table in the [README.md](README.md) file and in the
+Vim [help file](doc/ale.txt). The programs and linters should be sorted
+alphabetically in the table and list.
 
-If you add new options to the plugin, make sure to document those new options in the [README.md](README.md) file, and also
-in the [help file](doc/ale.txt). Follow the format of other options in each. Global options should appear in the README
-file, and in the relevant section in the help file, and options specific to a particular linter should go in the section
-for that linter.
+<a name="adding-new-options"></a>
 
-<a name="compiling"></a>
+# 3.ii. Adding New Options
 
-# 3. Compiling the Windows stdin wrapper
+If you add new options to the plugin, make sure to document those new options
+in the [README.md](README.md) file, and also in the [help file](doc/ale.txt).
+Follow the format of other options in each. Global options should appear in the
+README file, and in the relevant section in the help file. Options specific
+to a particular linter should appear in the section for that linter.
 
-To compile the stdin wrapper program for Windows, when updating the D program, you will need to compile the program with
-[LDC](https://github.com/ldc-developers/ldc) in release mode. Download and install the Community edition of Visual Studio
-from [the Visual Studio website](https://www.visualstudio.com/downloads/) first before installing LDC. LDC typically comes in
-a ZIP you can just extract somewhere.
+Linter options for customizing general argument lists should be named
+`g:ale_<filetype>_<linter>_options`, so that all linters can have similar
+global variable names.
 
-Make sure to compile with the 32-bit architecture flag, otherwise the EXE will not run on 32-bit machines.
+Any options for linters should be set to some default value so it is always
+easy to see what the default is with `:echo g:ale...`.
 
-```
-ldc2 -m32 -Oz -release stdin_wrapper.d -of=stdin-wrapper.exe
-```
+<a name="writing-documentation"></a>
+
+# 4. Writing Documentation
+
+If you are adding new linters, changing the API, adding new options, etc., you
+_must_ write some documentation describing it in the `doc/ale.txt` file.  New
+linters _must_ be added to the `README.md` file too, so other users can get a
+quick overview of the supported tools.
+
+<a name="documenting-new-linters"></a>
+
+# 4.i Documenting New Linters
+
+If you add a new linter to the project, edit the table in the `README.md` file,
+and edit the list of linters at the top of the `doc/ale.txt` file. The linters
+should be sorted vertically in lexicographic (alphabetical) order by the
+programming language name or filetype, and the tools for each language should
+be sorted in lexicographic order horizontally. Sorting in this manner is a fair
+manner of presenting all of the information in an easy to scan way, without
+giving some unfair preference to any particular tool or language.
+
+<a name="editing-online-documentation"></a>
+
+# 4.ii Editing the Online Documentation
+
+The "online documentation" file used for this project lives in `doc/ale.txt`.
+This is the file used for generating `:help` text inside Vim itself. There are
+some guidlines to follow for this file.
+
+1. Keep all text within a column size of 79 characters, inclusive.
+2. Open a section with 79 `=` or `-` characters, for headings and subheadings.
+3. Sections should have a _single_ blank line before or after.
+4. Between descriptions of variables/functions/commands, use _two_ blank lines.
+5. Up-indent the description of a variable/function/command by two spaces.
+6. Place tags at the ends of lines, with the final characters on column 79.
+   All of the tags should line up perfectly on the same column as you scan
+   down through the document.
+7. Keep the table of contents balanced so the longest tag link ends on column
+   79, and so all links line up perfectly on their first character, on the
+   left.
+
+<a name="documenting-linter-options"></a>
+
+# 4.iii Documenting Linter Options
+
+For documenting new linter options, please add a new sub-section under the
+"Linter Specific Options" section describing all of the global options added
+for each linter, and what the default values of the options are. All global
+options for linters should be set to some default value. This will allow users
+to look up the default value easily by typing `:echo g:ale_...`.
+
+<a name="in-case-of-busses"></a>
+
+# 5. In Case of Busses
+
+Should the principal author of the ALE project and all collaborators with the
+required access needed to properly administrate the project on GitHub or any
+other website either perish or disappear, whether by tragic traffic accident
+or government adduction, etc., action should be taken to ensure that the
+project continues. If no one is left to administer the project where it is
+hosted, please fork the project and nominate someone capable to administer it.
+Preferably, in such an event, a single fork of the project will replace the
+original, and life will go on, except the life of whoever vanished, because
+then they will probably be dead.
+
+Should w0rp suddenly disappear, then he was probably killed in a traffic
+accident, or the government finally decided to kill him and make it look like
+suicide. In the latter event, please subvert said government and restore
+order to the universe, and ensure peace for mankind.

ISSUE_TEMPLATE.md

@@ -0,0 +1,10 @@
+For bugs, paste output from your clipboard after running :ALEInfoToClipboard
+here. If that doesn't work for some reason, try running :ALEInfo and copying
+the output from that here instead. If everything is broken, run around in
+circles and scream.
+
+If you are experiencing a bug where ALE is not correctly parsing the output of
+commands, set g:ale_history_log_output to 1, and run ALE again, and then
+:ALEInfo should include the full output of each command which ran.
+
+Whatever the case, describe the your issue here.

Makefile

@@ -1,11 +1,21 @@
+SHELL := /usr/bin/env bash
 IMAGE ?= w0rp/ale
 CURRENT_IMAGE_ID = 107e4efc4267
 DOCKER_FLAGS = --rm -v $(PWD):/testplugin -v $(PWD)/test:/home "$(IMAGE)"
+tests = test/*.vader test/*/*.vader test/*/*/*.vader test/*/*/*/*.vader
 
 test-setup:
 	docker images -q w0rp/ale | grep ^$(CURRENT_IMAGE_ID) > /dev/null || \
 		docker pull $(IMAGE)
 
+vader: test-setup
+	@:; \
+	vims=$$(docker run --rm $(IMAGE) ls /vim-build/bin | grep -E '^n?vim'); \
+	if [ -z "$$vims" ]; then echo "No Vims found!"; exit 1; fi; \
+	for vim in $$vims; do \
+		docker run -a stderr $(DOCKER_FLAGS) $$vim '+Vader! $(tests)'; \
+	done
+
 test: test-setup
 	@:; \
 	vims=$$(docker run --rm $(IMAGE) ls /vim-build/bin | grep -E '^n?vim'); \
@@ -17,7 +27,7 @@ test: test-setup
 		echo "Running tests for $$vim"; \
 		echo '========================================'; \
 		echo; \
-		docker run -a stderr $(DOCKER_FLAGS) $$vim '+Vader! test/*' || EXIT=$$?; \
+		docker run -a stderr $(DOCKER_FLAGS) $$vim '+Vader! $(tests)' || EXIT=$$?; \
 	done; \
 	echo; \
 	echo '========================================'; \
@@ -25,8 +35,18 @@ test: test-setup
 	echo '========================================'; \
 	echo 'Vint warnings/errors follow:'; \
 	echo; \
+	set -o pipefail; \
 	docker run -a stdout $(DOCKER_FLAGS) vint -s /testplugin | sed s:^/testplugin/:: || EXIT=$$?; \
+	set +o pipefail; \
 	echo; \
+	echo '========================================'; \
+	echo 'Running custom checks'; \
+	echo '========================================'; \
+	echo 'Custom warnings/errors follow:'; \
+	echo; \
+	set -o pipefail; \
+	docker run -a stdout $(DOCKER_FLAGS) /testplugin/custom-checks /testplugin | sed s:^/testplugin/:: || EXIT=$$?; \
+	set +o pipefail; \
 	echo; \
 	exit $$EXIT;
 

README.md

@@ -15,7 +15,31 @@ back to a filesystem.
 
 In other words, this plugin allows you to lint while you type.
 
-## Supported Languages and Tools
+## Table of Contents
+
+1. [Supported Languages and Tools](#supported-languages)
+2. [Usage](#usage)
+3. [Installation](#installation)
+ 1. [Installation with Pathogen](#installation-with-pathogen)
+ 2. [Installation with Vundle](#installation-with-vundle)
+ 3. [Manual Installation](#manual-installation)
+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-disable-linters)
+ 3. [How can I change the signs ALE uses?](#faq-change-signs)
+ 4. [How can I show errors or warnings in my statusline?](#faq-statusline)
+ 5. [How can I change the format for echo messages?](#faq-echo-format)
+ 6. [How can I execute some code when ALE stops linting?](#faq-autocmd)
+ 7. [How can I navigate between errors quickly?](#faq-navigation)
+ 8. [How can I run linters only when I save files?](#faq-lint-on-save)
+ 9. [How can I use the quickfix list instead of the loclist?](#faq-quickfix)
+ 10. [How can I check JSX files with both stylelint and eslint?](#faq-jsx-stylelint-eslint)
+ 11. [Will this plugin eat all of my laptop battery power?](#faq-my-battery-is-sad)
+
+<a name="supported-languages"></a>
+
+## 1. Supported Languages and Tools
 
 This plugin supports the following languages and tools. All available
 tools will be run in combination, so they can be complementary.
@@ -28,44 +52,69 @@ name. That seems to be the fairest way to arrange this table.
 
 | Language | Tools |
 | -------- | ----- |
+| Ansible | [ansible-lint](https://github.com/willthames/ansible-lint) |
+| AsciiDoc | [proselint](http://proselint.com/)|
 | Bash | [-n flag](https://www.gnu.org/software/bash/manual/bash.html#index-set), [shellcheck](https://www.shellcheck.net/) |
 | Bourne Shell | [-n flag](http://linux.die.net/man/1/sh), [shellcheck](https://www.shellcheck.net/) |
-| C | [gcc](https://gcc.gnu.org/) |
-| C++ (filetype cpp)| [gcc](https://gcc.gnu.org/) |
+| C | [cppcheck](http://cppcheck.sourceforge.net), [gcc](https://gcc.gnu.org/), [clang](http://clang.llvm.org/)|
+| C++ (filetype cpp) | [clang](http://clang.llvm.org/), [clangtidy](http://clang.llvm.org/extra/clang-tidy/), [cppcheck] (http://cppcheck.sourceforge.net), [gcc](https://gcc.gnu.org/)|
+| C# | [mcs](http://www.mono-project.com/docs/about-mono/languages/csharp/) |
+| Chef | [foodcritic](http://www.foodcritic.io/) |
+| CMake | [cmakelint](https://github.com/richq/cmake-lint) |
 | CoffeeScript | [coffee](http://coffeescript.org/), [coffeelint](https://www.npmjs.com/package/coffeelint) |
-| CSS | [csslint](http://csslint.net/) |
+| CSS | [csslint](http://csslint.net/), [stylelint](https://github.com/stylelint/stylelint) |
 | Cython (pyrex filetype) | [cython](http://cython.org/) |
-| D | [dmd](https://dlang.org/dmd-linux.html)^ |
+| D | [dmd](https://dlang.org/dmd-linux.html) |
+| Dockerfile | [hadolint](https://github.com/lukasmartinelli/hadolint) |
 | Elixir | [credo](https://github.com/rrrene/credo) |
+| Elm | [elm-make](https://github.com/elm-lang/elm-make) |
+| Erlang | [erlc](http://erlang.org/doc/man/erlc.html) |
 | Fortran | [gcc](https://gcc.gnu.org/) |
-| Go | [gofmt -e](https://golang.org/cmd/gofmt/), [go vet](https://golang.org/cmd/vet/), [golint](https://godoc.org/github.com/golang/lint) |
-| Haskell | [ghc](https://www.haskell.org/ghc/), [hlint](https://hackage.haskell.org/package/hlint) |
-| HTML | [HTMLHint](http://htmlhint.com/), [tidy](http://www.html-tidy.org/) |
-| JavaScript | [eslint](http://eslint.org/), [jscs](http://jscs.info/), [jshint](http://jshint.com/) |
+| Go | [gofmt -e](https://golang.org/cmd/gofmt/), [go vet](https://golang.org/cmd/vet/), [golint](https://godoc.org/github.com/golang/lint), [go build](https://golang.org/cmd/go/) |
+| Haml | [haml-lint](https://github.com/brigade/haml-lint)
+| Haskell | [ghc](https://www.haskell.org/ghc/), [hlint](https://hackage.haskell.org/package/hlint), [hdevtools](https://hackage.haskell.org/package/hdevtools) |
+| HTML | [HTMLHint](http://htmlhint.com/), [proselint](http://proselint.com/), [tidy](http://www.html-tidy.org/) |
+| Java | [javac](http://www.oracle.com/technetwork/java/javase/downloads/index.html) |
+| JavaScript | [eslint](http://eslint.org/), [jscs](http://jscs.info/), [jshint](http://jshint.com/), [flow](https://flowtype.org/), [standard](http://standardjs.com/)
 | JSON | [jsonlint](http://zaa.ch/jsonlint/) |
+| LaTeX | [chktex](http://www.nongnu.org/chktex/), [lacheck](https://www.ctan.org/pkg/lacheck) |
 | Lua | [luacheck](https://github.com/mpeterv/luacheck) |
+| Markdown | [mdl](https://github.com/mivok/markdownlint), [proselint](http://proselint.com/)|
+| MATLAB | [mlint](https://www.mathworks.com/help/matlab/ref/mlint.html) |
+| Nim | [nim](https://nim-lang.org/docs/nimc.html) |
+| nix | [nix-instantiate](http://nixos.org/nix/manual/#sec-nix-instantiate) |
+| nroff | [proselint](http://proselint.com/)|
+| OCaml | [merlin](https://github.com/the-lambda-church/merlin) see `:help ale-integration-ocaml-merlin` for configuration instructions
 | Perl | [perl -c](https://perl.org/), [perl-critic](https://metacpan.org/pod/Perl::Critic) |
-| PHP | [php -l](https://secure.php.net/), [phpcs](https://github.com/squizlabs/PHP_CodeSniffer) |
+| PHP | [hack](http://hacklang.org/), [php -l](https://secure.php.net/), [phpcs](https://github.com/squizlabs/PHP_CodeSniffer), [phpmd](https://phpmd.org) |
+| Pod | [proselint](http://proselint.com/)|
 | Pug | [pug-lint](https://github.com/pugjs/pug-lint) |
-| Python | [flake8](http://flake8.pycqa.org/en/latest/) |
+| Puppet | [puppet](https://puppet.com), [puppet-lint](https://puppet-lint.com) |
+| Python | [flake8](http://flake8.pycqa.org/en/latest/), [mypy](http://mypy-lang.org/), [pylint](https://www.pylint.org/) |
+| reStructuredText | [proselint](http://proselint.com/)|
 | Ruby | [rubocop](https://github.com/bbatsov/rubocop) |
-| SASS | [sass-lint](https://www.npmjs.com/package/sass-lint) |
-| SCSS | [sass-lint](https://www.npmjs.com/package/sass-lint), [scss-lint](https://github.com/brigade/scss-lint) |
+| Rust | [rustc](https://www.rust-lang.org/), cargo (see `:help ale-integration-rust` for configuration instructions) |
+| SASS | [sass-lint](https://www.npmjs.com/package/sass-lint), [stylelint](https://github.com/stylelint/stylelint) |
+| SCSS | [sass-lint](https://www.npmjs.com/package/sass-lint), [scss-lint](https://github.com/brigade/scss-lint), [stylelint](https://github.com/stylelint/stylelint) |
 | Scala | [scalac](http://scala-lang.org) |
-| TypeScript | [tslint](https://github.com/palantir/tslint) |
+| Slim | [slim-lint](https://github.com/sds/slim-lint)
+| SML | [smlnj](http://www.smlnj.org/) |
+| Swift | [swiftlint](https://swift.org/) |
+| Tex | [proselint](http://proselint.com/) |
+| Texinfo | [proselint](http://proselint.com/)|
+| Text^ | [proselint](http://proselint.com/) |
+| TypeScript | [tslint](https://github.com/palantir/tslint), typecheck |
 | Verilog | [iverilog](https://github.com/steveicarus/iverilog), [verilator](http://www.veripool.org/projects/verilator/wiki/Intro) |
 | Vim | [vint](https://github.com/Kuniwak/vint) |
+| Vim help^ | [proselint](http://proselint.com/)|
+| XHTML | [proselint](http://proselint.com/)|
 | YAML | [yamllint](https://yamllint.readthedocs.io/) |
 
-*^ Supported only on Unix machines via a wrapper script.*
+* *^ No linters for text or Vim help filetypes are enabled by default.*
 
-If you would like to see support for more languages and tools, please
-[create an issue](https://github.com/w0rp/ale/issues)
-or [create a pull request](https://github.com/w0rp/ale/pulls).
-If your tool can read from stdin or you have code to suggest which is good,
-support can be happily added for more tools.
+<a name="usage"></a>
 
-## Usage
+## 2. Usage
 
 Once this plugin is installed, while editing your files in supported
 languages and tools which have been correctly installed,
@@ -74,32 +123,104 @@ 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.
 
-### Options
+The behaviour 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-linter-options` for options specified to particular linters.
 
-A full list of options supported for configuring this plugin in your
-vimrc file for all given linters is as follows:
+<a name="installation"></a>
 
-| Option | Description | Default |
-| ------ | ----------- | ------- |
-| `g:ale_echo_cursor` | echo errors when the cursor is over them | `1` |
-| `g:ale_echo_msg_format` | string format to use for the echoed message | `'%s'` |
-| `g:ale_echo_msg_error_str` | string used for error severity in echoed message | `'Error'` |
-| `g:ale_echo_msg_warning_str` | string used for warning severity in echoed message | `'Warning'` |
-| `g:ale_lint_delay` | milliseconds to wait before linting | `200` |
-| `g:ale_linters` | a dictionary of linters to whitelist | _not set_ |
-| `g:ale_lint_on_enter` | lint when opening a file  | `1` |
-| `g:ale_lint_on_save` | lint when saving a file  | `0` |
-| `g:ale_lint_on_text_changed` | lint while typing  | `1` |
-| `g:ale_set_loclist` | set the loclist with errors | `1` |
-| `g:ale_set_signs` | set gutter signs with error markers | `has('signs')` |
-| `g:ale_sign_column_always` | always show the sign gutter | `0` |
-| `g:ale_sign_error` | the text to use for errors in the gutter | `'>>'` |
-| `g:ale_sign_offset` | an offset for sign ids | `1000000` |
-| `g:ale_sign_warning` | the text to use for warnings in the gutter | `'--'` |
-| `g:ale_statusline_format` | string format to use in statusline flag | `['%d error(s)', '%d warning(s)', 'OK']` |
-| `g:ale_warn_about_trailing_whitespace` | enable trailing whitespace warnings for some linters | `1` |
+## 3. Installation
 
-### Selecting Particular Linters
+To install this plugin, you should use one of the following methods.
+For Windows users, replace usage of the Unix `~/.vim` directory with
+`%USERPROFILE%\_vim`, or another directory if you have configured
+Vim differently. On Windows, your `~/.vimrc` file will be similarly
+stored in `%USERPROFILE%\_vimrc`.
+
+<a name="installation-with-pathogen"></a>
+
+### 3.i. Installation with Pathogen
+
+To install this module with [Pathogen](https://github.com/tpope/vim-pathogen),
+you should clone this repository to your bundle directory, and ensure
+you have the line `execute pathogen#infect()` in your `~/.vimrc` file.
+You can run the following commands in your terminal to do so:
+
+```bash
+cd ~/.vim/bundle
+git clone https://github.com/w0rp/ale.git
+```
+
+<a name="installation-with-vundle"></a>
+
+### 3.ii. Installation with Vundle
+
+You can install this plugin using [Vundle](https://github.com/VundleVim/Vundle.vim)
+by using the path on GitHub for this repository.
+
+```vim
+Plugin 'w0rp/ale'
+```
+
+See the Vundle documentation for more information.
+
+<a name="manual-installation"></a>
+
+### 3.iii. Manual Installation
+
+For installation without a package manager, you can clone this git repository
+into a bundle directory as with pathogen, and add the repository to your
+runtime path yourself. First clone the repository.
+
+```bash
+cd ~/.vim/bundle
+git clone https://github.com/w0rp/ale.git
+```
+
+Then, modify your `~/.vimrc` file to add this plugin to your runtime path.
+
+```vim
+set nocompatible
+filetype off
+
+let &runtimepath.=',~/.vim/bundle/ale'
+
+filetype plugin on
+```
+
+You can add the following line to generate documentation tags automatically,
+if you don't have something similar already, so you can use the `:help` command
+to consult ALE's online documentation:
+
+```vim
+silent! helptags ALL
+```
+
+Because the author of this plugin is a weird nerd, this is his preferred
+installation method.
+
+<a name="contributing"></a>
+
+## 4. Contributing
+
+If you would like to see support for more languages and tools, please
+[create an issue](https://github.com/w0rp/ale/issues)
+or [create a pull request](https://github.com/w0rp/ale/pulls).
+If your tool can read from stdin or you have code to suggest which is good,
+support can be happily added for it.
+
+If you are interested in the general direction of the project, check out the
+[wiki home page](https://github.com/w0rp/ale/wiki). The wiki includes a
+Roadmap for the future, and more.
+
+<a name="faq"></a>
+
+## 5. FAQ
+
+<a name="faq-disable-linters"></a>
+
+### 5.i. How do I disable particular linters?
 
 By default, all available tools for all supported languages will be run.
 If you want to only select a subset of the tools, simply create a
@@ -121,15 +242,20 @@ This plugin will look for linters in the [`ale_linters`](ale_linters) directory.
 Each directory within corresponds to a particular filetype in Vim, and each file
 in each directory corresponds to the name of a particular linter.
 
-### Always showing gutter
+<a name="faq-keep-signs"></a>
 
-You can keep the sign gutter open at all times by setting the `g:ale_sign_column_always` to 1
+### 5.ii. How can I keep the sign gutter open?
+
+You can keep the sign gutter open at all times by setting the
+`g:ale_sign_column_always` to 1
 
 ```vim
 let g:ale_sign_column_always = 1
 ```
 
-### Customize signs
+<a name="faq-change-signs"></a>
+
+### 5.iii. How can I change the signs ALE uses?
 
 Use these options to specify what text should be used for signs:
 
@@ -138,7 +264,18 @@ let g:ale_sign_error = '>>'
 let g:ale_sign_warning = '--'
 ```
 
-### Statusline
+ALE sets some background colors automatically for warnings and errors
+in the sign gutter, with the names `ALEErrorSign` and `ALEWarningSign`.
+These colors can be customised, or even removed completely:
+
+```vim
+highlight clear ALEErrorSign
+highlight clear ALEWarningSign
+```
+
+<a name="faq-statusline"></a>
+
+### 5.iv. How can I show errors or warnings in my statusline?
 
 You can use `ALEGetStatusLine()` to integrate ALE into vim statusline.
 To enable it, you should have in your `statusline` settings
@@ -163,8 +300,9 @@ let g:ale_statusline_format = ['⨉ %d', '⚠ %d', '⬥ ok']
 ![Statusline with issues](img/issues.png)
 ![Statusline with no issues](img/no_issues.png)
 
+<a name="faq-echo-format"></a>
 
-### Customize echoed message
+### 5.v. How can I change the format for echo messages?
 
 There are 3 global options that allow customizing the echoed message.
 
@@ -187,58 +325,137 @@ Will give you:
 
 ![Echoed message](img/echo.png)
 
-## Installation
+<a name="faq-autocmd"></a>
 
-To install this plugin, you should use one of the following methods.
-For Windows users, replace usage of the Unix `~/.vim` directory with
-`%USERPROFILE%\_vim`, or another directory if you have configured
-Vim differently. On Windows, your `~/.vimrc` file will be similarly
-stored in `%USERPROFILE%\_vimrc`.
+### 5.vi. How can I execute some code when ALE stops linting?
 
-### Installation with Pathogen
-
-To install this module with [Pathogen](https://github.com/tpope/vim-pathogen),
-you should clone this repository to your bundle directory, and ensure
-you have the line `execute pathogen#infect()` in your `~/.vimrc` file.
-You can run the following commands in your terminal to do so:
-
-```bash
-cd ~/.vim/bundle
-git clone https://github.com/w0rp/ale.git
-```
-
-### Installation with Vundle
-
-You can install this plugin using [Vundle](https://github.com/VundleVim/Vundle.vim)
-by using the path on GitHub for this repository.
+ALE runs its own [autocmd](http://vimdoc.sourceforge.net/htmldoc/autocmd.html)
+event whenever has a linter has been successfully executed and processed. This
+autocmd event can be used to call arbitrary functions after ALE stops linting.
 
 ```vim
-Plugin 'w0rp/ale'
+augroup YourGroup
+    autocmd!
+    autocmd User ALELint call YourFunction()
+augroup END
 ```
 
-See the Vundle documentation for more information.
+<a name="faq-navigation"></a>
 
-### Manual Installation
+### 5.vii. How can I navigate between errors quickly?
 
-For installation without a package manager, you can clone this git repository
-into a bundle directory as with pathogen, and add the repository to your
-runtime path yourself. First clone the repository.
-
-```bash
-cd ~/.vim/bundle
-git clone https://github.com/w0rp/ale.git
-```
-
-Then, modify your `~/.vimrc` file to add this plugin to your runtime path.
+ALE offers some commands with `<Plug>` keybinds for moving between warnings and
+errors quickly. You can map the keys Ctrl+j and Ctrl+k to moving between errors
+for example:
 
 ```vim
-set nocompatible
-filetype off
-
-let &runtimepath.=',~/.vim/bundle/ale'
-
-filetype plugin on
+nmap <silent> <C-k> <Plug>(ale_previous_wrap)
+nmap <silent> <C-j> <Plug>(ale_next_wrap)
 ```
 
-Because the author of this plugin is a weird nerd, this is his preferred
-installation method.
+For more information, consult the online documentation with
+`:help ale-navigation-commands`.
+
+<a name="faq-lint-on-save"></a>
+
+### 5.viii. How can I run linters only when I save files?
+
+ALE offers an option `g:ale_lint_on_save` for enabling running the linters
+when files are saved. If you wish to run linters when files are saved, not
+as you are editing files, then you can turn the option for linting
+when text is changed off too.
+
+```vim
+" Write this in your vimrc file
+let g:ale_lint_on_save = 1
+let g:ale_lint_on_text_changed = 0
+" You can disable this option too
+" if you don't want linters to run on opening a file
+let g:ale_lint_on_enter = 0
+```
+
+<a name="faq-quickfix"></a>
+
+### 5.ix. How can I use the quickfix list instead of the loclist?
+
+The quickfix list can be enabled by turning the `g:ale_set_quickfix`
+option on. If you wish to also disable the loclist, you can disable
+the `g:ale_set_loclist` option.
+
+```vim
+" Write this in your vimrc file
+let g:ale_set_loclist = 0
+let g:ale_set_quickfix = 1
+```
+
+If you wish to show Vim windows for the loclist or quickfix items
+when a file contains warnings or errors, `g:ale_open_list` can be
+set to `1`. `g:ale_keep_list_window_open` can be set to `1`
+if you wish to keep the window open even after errors disappear.
+
+```vim
+let g:ale_open_list = 1
+" Set this if you want to.
+" This can be useful if you are combining ALE with
+" some other plugin which sets quickfix errors, etc.
+let g:ale_keep_list_window_open = 1
+```
+
+<a name="faq-jsx-stylelint-eslint"></a>
+
+### 5.x. How can I check JSX files with both stylelint and eslint?
+
+If you configure ALE options correctly in your vimrc file, and install
+the right tools, you can check JSX files with stylelint and eslint.
+
+First, install eslint and install stylelint with
+[https://github.com/styled-components/stylelint-processor-styled-components](stylelint-processor-styled-components).
+
+Supposing you have installed both tools correctly, configure your .jsx files so
+`jsx` is included in the filetype. You can use an `autocmd` for this.
+
+```vim
+augroup FiletypeGroup
+    autocmd!
+    au BufNewFile,BufRead *.jsx set filetype=javascript.jsx
+augroup END
+```
+
+Supposing the filetype has been set correctly, you can set the following
+options in your vimrc file:
+
+```vim
+let g:ale_linters = {'jsx': ['stylelint', 'eslint']}
+let g:ale_linter_aliases = {'jsx': 'css'}
+```
+
+ALE will alias the `jsx` filetype so it uses the `css` filetype linters, and
+use the original Array of selected linters for `jsx` from the `g:ale_linters`
+object. All available linters will be used for the filetype `javascript`, and
+no linter will be run twice for the same file.
+
+<a name="faq-my-battery-is-sad"></a>
+
+### 5.xi. Will this plugin eat all of my laptop battery power?
+
+ALE takes advantage of the power of various tools to check your code. This of
+course means that CPU time will be used to continuously check your code. If you
+are concerned about the CPU time ALE will spend, which will of course imply
+some cost to battery life, you can adjust your settings to make your CPU do
+less work.
+
+First, consider increasing the delay before which ALE will run any linters
+while you type. ALE uses a timeout which is cancelled and reset every time you
+type, and this delay can be increased so linters are run less often. See
+`:help g:ale_lint_delay` for more information.
+
+If you don't wish to run linters while you type, you can disable that
+behaviour. Set `g:ale_lint_on_text_changed` to `0`, and consider setting
+`g:ale_lint_on_save` to `1` to enable linting when you save files. You won't
+get as frequent error checking, but ALE shouldn't block your ability to edit a
+document after you save a file, so the asynchronous nature of the plugin will
+still be an advantage.
+
+If you are still concerned, you can turn the automatic linting off altogether,
+including the option `g:ale_lint_on_enter`, and you can run ALE manually with
+`:call ale#Lint()`.

after/plugin/ale.vim

@@ -0,0 +1,37 @@
+" Author: w0rp <devw0rp@gmail.com>
+" Description: Follow-up checks for the plugin: warn about conflicting plugins.
+
+" A flag for ensuring that this is not run more than one time.
+if exists('g:loaded_ale_after')
+    finish
+endif
+
+" Set the flag so this file is not run more than one time.
+let g:loaded_ale_after = 1
+
+" Check if the flag is available and set to 0 to disable checking for and
+" emitting conflicting plugin warnings.
+if exists('g:ale_emit_conflict_warnings') && !g:ale_emit_conflict_warnings
+    finish
+endif
+
+" Conflicting Plugins Checks
+
+function! s:GetConflictingPluginWarning(plugin_name) abort
+    return 'ALE conflicts with ' . a:plugin_name
+    \   . '. Uninstall it, or disable this warning with '
+    \   . '`let g:ale_emit_conflict_warnings = 0` in your vimrc file, '
+    \   . '*before* plugins are loaded.'
+endfunction
+
+if exists('g:loaded_syntastic_plugin')
+    throw s:GetConflictingPluginWarning('Syntastic')
+endif
+
+if exists('g:loaded_neomake')
+    throw s:GetConflictingPluginWarning('Neomake')
+endif
+
+if exists('g:loaded_validator_plugin')
+    throw s:GetConflictingPluginWarning('Validator')
+endif

ale_linters/ansible/ansible-lint.vim

@@ -0,0 +1,9 @@
+" Author: Bjorn Neergaard <bjorn@neersighted.com>
+" Description: ansible-lint for ansible-yaml files
+
+call ale#linter#Define('ansible', {
+\   'name': 'ansible',
+\   'executable': 'ansible',
+\   'command': 'ansible-lint -p %t',
+\   'callback': 'ale#handlers#HandlePEP8Format',
+\})

ale_linters/asciidoc/proselint.vim

@@ -0,0 +1,9 @@
+" Author: Daniel M. Capella https://github.com/polyzen
+" Description: proselint for AsciiDoc files
+
+call ale#linter#Define('asciidoc', {
+\   'name': 'proselint',
+\   'executable': 'proselint',
+\   'command': 'proselint %t',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/c/clang.vim

@@ -0,0 +1,26 @@
+" Author: Masahiro H https://github.com/mshr-h
+" Description: clang linter for c files
+
+" Set this option to change the Clang options for warnings for C.
+if !exists('g:ale_c_clang_options')
+    " let g:ale_c_clang_options = '-Wall'
+    " let g:ale_c_clang_options = '-std=c99 -Wall'
+    " c11 compatible
+    let g:ale_c_clang_options = '-std=c11 -Wall'
+endif
+
+function! ale_linters#c#clang#GetCommand(buffer) abort
+    " -iquote with the directory the file is in makes #include work for
+    "  headers in the same directory.
+    return 'clang -S -x c -fsyntax-only '
+    \   . '-iquote ' . fnameescape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ' ' . g:ale_c_clang_options . ' -'
+endfunction
+
+call ale#linter#Define('c', {
+\   'name': 'clang',
+\   'output_stream': 'stderr',
+\   'executable': 'clang',
+\   'command_callback': 'ale_linters#c#clang#GetCommand',
+\   'callback': 'ale#handlers#HandleGCCFormat',
+\})

ale_linters/c/cppcheck.vim

@@ -0,0 +1,15 @@
+" Author: Bart Libert <bart.libert@gmail.com>
+" Description: cppcheck linter for c files
+
+" Set this option to change the cppcheck options
+let g:ale_c_cppcheck_options = get(g:, 'ale_c_cppcheck_options', '--enable=style')
+
+call ale#linter#Define('c', {
+\   'name': 'cppcheck',
+\   'output_stream': 'both',
+\   'executable': 'cppcheck',
+\   'command': 'cppcheck -q --language=c '
+\       . g:ale_c_cppcheck_options
+\       . ' %t',
+\   'callback': 'ale#handlers#HandleCppCheckFormat',
+\})

ale_linters/c/gcc.vim

@@ -1,23 +1,26 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: gcc linter for c files
 
-if exists('g:loaded_ale_linters_c_gcc')
-    finish
-endif
-
-let g:loaded_ale_linters_c_gcc = 1
-
 " Set this option to change the GCC options for warnings for C.
 if !exists('g:ale_c_gcc_options')
-    let g:ale_c_gcc_options = '-Wall'
+    " let g:ale_c_gcc_options = '-Wall'
+    " let g:ale_c_gcc_options = '-std=c99 -Wall'
+    " c11 compatible
+    let g:ale_c_gcc_options = '-std=c11 -Wall'
 endif
 
+function! ale_linters#c#gcc#GetCommand(buffer) abort
+    " -iquote with the directory the file is in makes #include work for
+    "  headers in the same directory.
+    return 'gcc -S -x c -fsyntax-only '
+    \   . '-iquote ' . fnameescape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ' ' . g:ale_c_gcc_options . ' -'
+endfunction
+
 call ale#linter#Define('c', {
 \   'name': 'gcc',
 \   'output_stream': 'stderr',
 \   'executable': 'gcc',
-\   'command': 'gcc -S -x c -fsyntax-only '
-\       . g:ale_c_gcc_options
-\       . ' -',
+\   'command_callback': 'ale_linters#c#gcc#GetCommand',
 \   'callback': 'ale#handlers#HandleGCCFormat',
 \})

ale_linters/chef/foodcritic.vim

@@ -0,0 +1,38 @@
+" Author: Edward Larkey <edwlarkey@mac.com>
+" Description: This file adds the foodcritic linter for Chef files.
+
+function! ale_linters#chef#foodcritic#Handle(buffer, lines) abort
+    " Matches patterns line the following:
+    "
+    " FC002: Avoid string interpolation where not required: httpd.rb:13
+    let l:pattern = '^\(.\+:\s.\+\):\s\(.\+\):\(\d\+\)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        let l:text = l:match[1]
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[3] + 0,
+        \   'col': 0,
+        \   'text': l:text,
+        \   'type': 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('chef', {
+\   'name': 'foodcritic',
+\   'executable': 'foodcritic',
+\   'command': 'foodcritic %t',
+\   'callback': 'ale_linters#chef#foodcritic#Handle',
+\})
+

ale_linters/cmake/cmakelint.vim

@@ -0,0 +1,24 @@
+" Author: Kenneth Benzie <k.benzie83@gmail.com>
+" Description: cmakelint for cmake files
+
+let g:ale_cmake_cmakelint_executable =
+\   get(g:, 'ale_cmake_cmakelint_executable', 'cmakelint')
+
+let g:ale_cmake_cmakelint_options =
+\   get(g:, 'ale_cmake_cmakelint_options', '')
+
+function! ale_linters#cmake#cmakelint#Executable(buffer) abort
+    return g:ale_cmake_cmakelint_executable
+endfunction
+
+function! ale_linters#cmake#cmakelint#Command(buffer) abort
+    return ale_linters#cmake#cmakelint#Executable(a:buffer)
+    \   . ' ' . g:ale_cmake_cmakelint_options . ' %t'
+endfunction
+
+call ale#linter#Define('cmake', {
+\   'name': 'cmakelint',
+\   'executable_callback': 'ale_linters#cmake#cmakelint#Executable',
+\   'command_callback': 'ale_linters#cmake#cmakelint#Command',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/coffee/coffee.vim

@@ -1,17 +1,23 @@
 " Author: KabbAmine - https://github.com/KabbAmine
 " Description: Coffee for checking coffee files
 
-if exists('g:loaded_ale_linters_coffee_coffee')
-    finish
-endif
+function! ale_linters#coffee#coffee#GetExecutable(buffer) abort
+    return ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/coffee',
+    \   'coffee'
+    \)
+endfunction
 
-let g:loaded_ale_linters_coffee_coffee = 1
+function! ale_linters#coffee#coffee#GetCommand(buffer) abort
+    return ale_linters#coffee#coffee#GetExecutable(a:buffer)
+    \   . ' -cp -s'
+endfunction
 
 call ale#linter#Define('coffee', {
 \   'name': 'coffee',
-\   'executable': 'coffee',
-\   'command': 'coffee -cp -s',
+\   'executable_callback': 'ale_linters#coffee#coffee#GetExecutable',
+\   'command_callback': 'ale_linters#coffee#coffee#GetCommand',
 \   'output_stream': 'stderr',
 \   'callback': 'ale#handlers#HandleGCCFormat',
 \})
-

ale_linters/coffee/coffeelint.vim

@@ -1,20 +1,27 @@
 " Author: Prashanth Chandra https://github.com/prashcr
 " Description: coffeelint linter for coffeescript files
 
-if exists('g:loaded_ale_linters_coffee_coffeelint')
-    finish
-endif
+function! ale_linters#coffee#coffeelint#GetExecutable(buffer) abort
+    return ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/coffeelint',
+    \   'coffeelint'
+    \)
+endfunction
 
-let g:loaded_ale_linters_coffee_coffeelint = 1
+function! ale_linters#coffee#coffeelint#GetCommand(buffer) abort
+    return ale_linters#coffee#coffeelint#GetExecutable(a:buffer)
+    \   . ' --stdin --reporter csv'
+endfunction
 
-function! ale_linters#coffee#coffeelint#Handle(buffer, lines)
+function! ale_linters#coffee#coffeelint#Handle(buffer, lines) abort
     " Matches patterns like the following:
     "
     " path,lineNumber,lineNumberEnd,level,message
     " stdin,14,,error,Throwing strings is forbidden
     "
     " Note that we currently ignore lineNumberEnd for multiline errors
-    let l:pattern = 'stdin,\(\d\+\),\(\d*\),\(.\+\),\(.\+\)'
+    let l:pattern = 'stdin,\(\d\+\),\(\d*\),\(.\{-1,}\),\(.\+\)'
     let l:output = []
 
     for l:line in a:lines
@@ -25,19 +32,14 @@ function! ale_linters#coffee#coffeelint#Handle(buffer, lines)
         endif
 
         let l:line = l:match[1] + 0
-        let l:column = 1
         let l:type = l:match[3] ==# 'error' ? 'E' : 'W'
         let l:text = l:match[4]
 
-        " vcol is needed to indicate that the column is a character
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:line,
-        \   'vcol': 0,
-        \   'col': l:column,
         \   'text': l:text,
         \   'type': l:type,
-        \   'nr': -1,
         \})
     endfor
 
@@ -46,7 +48,7 @@ endfunction
 
 call ale#linter#Define('coffee', {
 \   'name': 'coffeelint',
-\   'executable': 'coffeelint',
-\   'command': 'coffeelint --stdin --reporter csv',
+\   'executable_callback': 'ale_linters#coffee#coffeelint#GetExecutable',
+\   'command_callback': 'ale_linters#coffee#coffeelint#GetCommand',
 \   'callback': 'ale_linters#coffee#coffeelint#Handle',
 \})

ale_linters/cpp/clang.vim

@@ -0,0 +1,23 @@
+" Author: Tomota Nakamura <https://github.com/tomotanakamura>
+" Description: clang linter for cpp files
+
+" Set this option to change the Clang options for warnings for CPP.
+if !exists('g:ale_cpp_clang_options')
+    let g:ale_cpp_clang_options = '-std=c++14 -Wall'
+endif
+
+function! ale_linters#cpp#clang#GetCommand(buffer) abort
+    " -iquote with the directory the file is in makes #include work for
+    "  headers in the same directory.
+    return 'clang++ -S -x c++ -fsyntax-only '
+    \   . '-iquote ' . fnameescape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ' ' . g:ale_cpp_clang_options . ' -'
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'clang',
+\   'output_stream': 'stderr',
+\   'executable': 'clang++',
+\   'command_callback': 'ale_linters#cpp#clang#GetCommand',
+\   'callback': 'ale#handlers#HandleGCCFormat',
+\})

ale_linters/cpp/clangtidy.vim

@@ -0,0 +1,18 @@
+" Author: vdeurzen <tim@kompiler.org>, w0rp <devw0rp@gmail.com>
+" Description: clang-tidy linter for cpp files
+
+" Set this option to change the clang-tidy options for warnings for C.
+let g:ale_cpp_clangtidy_options =
+\   get(g:, 'ale_cpp_clangtidy_options', '-std=c++14 -Wall')
+
+function! ale_linters#cpp#clangtidy#GetCommand(buffer) abort
+    return 'clang-tidy %t -- ' . g:ale_cpp_clangtidy_options
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'clangtidy',
+\   'output_stream': 'stdout',
+\   'executable': 'clang-tidy',
+\   'command_callback': 'ale_linters#cpp#clangtidy#GetCommand',
+\   'callback': 'ale#handlers#HandleGCCFormat',
+\})

ale_linters/cpp/cppcheck.vim

@@ -0,0 +1,15 @@
+" Author: Bart Libert <bart.libert@gmail.com>
+" Description: cppcheck linter for cpp files
+
+" Set this option to change the cppcheck options
+let g:ale_cpp_cppcheck_options = get(g:, 'ale_cpp_cppcheck_options', '--enable=style')
+
+call ale#linter#Define('cpp', {
+\   'name': 'cppcheck',
+\   'output_stream': 'both',
+\   'executable': 'cppcheck',
+\   'command': 'cppcheck -q --language=c++ '
+\       . g:ale_cpp_cppcheck_options
+\       . ' %t',
+\   'callback': 'ale#handlers#HandleCppCheckFormat',
+\})

ale_linters/cpp/gcc.vim

@@ -1,23 +1,32 @@
 " Author: geam <mdelage@student.42.fr>
 " Description: gcc linter for cpp files
 
-if exists('g:loaded_ale_linters_cpp_gcc')
-    finish
-endif
-
-let g:loaded_ale_linters_cpp_gcc = 1
-
 " Set this option to change the GCC options for warnings for C.
 if !exists('g:ale_cpp_gcc_options')
-    let g:ale_cpp_gcc_options = '-Wall'
+  " added c++14 standard support
+  " POSIX thread and standard c++ thread and atomic library Linker
+  " let g:ale_cpp_gcc_options = '-std=c++1z' for c++17
+  " for previous version and default, you can just use
+  " let g:ale_cpp_gcc_options = '-Wall'
+  " for more see man pages of gcc
+  " $ man g++
+  " make sure g++ in your $PATH
+  " Add flags according to your requirements
+    let g:ale_cpp_gcc_options = '-std=c++14 -Wall'
 endif
 
+function! ale_linters#cpp#gcc#GetCommand(buffer) abort
+    " -iquote with the directory the file is in makes #include work for
+    "  headers in the same directory.
+    return 'gcc -S -x c++ -fsyntax-only '
+    \   . '-iquote ' . fnameescape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ' ' . g:ale_cpp_gcc_options . ' -'
+endfunction
+
 call ale#linter#Define('cpp', {
-\   'name': 'gcc',
+\   'name': 'g++',
 \   'output_stream': 'stderr',
-\   'executable': 'gcc',
-\   'command': 'gcc -S -x c++ -fsyntax-only '
-\       . g:ale_cpp_gcc_options
-\       . ' -',
+\   'executable': 'g++',
+\   'command_callback': 'ale_linters#cpp#gcc#GetCommand',
 \   'callback': 'ale#handlers#HandleGCCFormat',
 \})

ale_linters/cs/mcs.vim

@@ -0,0 +1,39 @@
+let g:ale_cs_mcs_options = get(g:, 'ale_cs_mcs_options', '')
+
+function! ale_linters#cs#mcs#GetCommand(buffer) abort
+    return 'mcs -unsafe --parse ' . g:ale_cs_mcs_options . ' %t'
+endfunction
+
+function! ale_linters#cs#mcs#Handle(buffer, lines) abort
+    " Look for lines like the following.
+    "
+    " Tests.cs(12,29): error CSXXXX: ; expected
+    let l:pattern = '^.\+.cs(\(\d\+\),\(\d\+\)): \(.\+\): \(.\+\)'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:match[2] + 0,
+        \   'text': l:match[3] . ': ' . l:match[4],
+        \   'type': l:match[3] =~# '^error' ? 'E' : 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('cs',{
+\   'name': 'mcs',
+\   'output_stream': 'stderr',
+\   'executable': 'mcs',
+\   'command_callback': 'ale_linters#cs#mcs#GetCommand',
+\   'callback': 'ale_linters#cs#mcs#Handle',
+\})

ale_linters/css/csslint.vim

@@ -1,15 +1,9 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: This file adds support for checking CSS code with csslint.
 
-if exists('g:loaded_ale_linters_css_csslint')
-    finish
-endif
-
-let g:loaded_ale_linters_css_csslint = 1
-
 call ale#linter#Define('css', {
 \   'name': 'csslint',
 \   'executable': 'csslint',
-\   'command': g:ale#util#stdin_wrapper . ' .css csslint --format=compact',
+\   'command': 'csslint --format=compact %t',
 \   'callback': 'ale#handlers#HandleCSSLintFormat',
 \})

ale_linters/css/stylelint.vim

@@ -0,0 +1,35 @@
+" Author: diartyz <diartyz@gmail.com>
+
+let g:ale_css_stylelint_executable =
+\   get(g:, 'ale_css_stylelint_executable', 'stylelint')
+
+let g:ale_css_stylelint_options =
+\   get(g:, 'ale_css_stylelint_options', '')
+
+let g:ale_css_stylelint_use_global =
+\   get(g:, 'ale_css_stylelint_use_global', 0)
+
+function! ale_linters#css#stylelint#GetExecutable(buffer) abort
+    if g:ale_css_stylelint_use_global
+        return g:ale_css_stylelint_executable
+    endif
+
+    return ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/stylelint',
+    \   g:ale_css_stylelint_executable
+    \)
+endfunction
+
+function! ale_linters#css#stylelint#GetCommand(buffer) abort
+    return ale_linters#css#stylelint#GetExecutable(a:buffer)
+    \   . ' ' . g:ale_css_stylelint_options
+    \   . ' --stdin-filename %s'
+endfunction
+
+call ale#linter#Define('css', {
+\   'name': 'stylelint',
+\   'executable_callback': 'ale_linters#css#stylelint#GetExecutable',
+\   'command_callback': 'ale_linters#css#stylelint#GetCommand',
+\   'callback': 'ale#handlers#HandleStyleLintFormat',
+\})

ale_linters/d/dmd.vim

@@ -1,37 +1,59 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: "dmd for D files"
 
-if exists('g:loaded_ale_linters_d_dmd')
-    finish
-endif
+function! s:FindDUBConfig(buffer) abort
+    " Find a DUB configuration file in ancestor paths.
+    " The most DUB-specific names will be tried first.
+    for l:possible_filename in ['dub.sdl', 'dub.json', 'package.json']
+        let l:dub_file = ale#util#FindNearestFile(a:buffer, l:possible_filename)
 
-let g:loaded_ale_linters_d_dmd = 1
-
-" A function for finding the dmd-wrapper script in the Vim runtime paths
-function! s:FindWrapperScript()
-    for l:parent in split(&runtimepath, ',')
-        " Expand the path to deal with ~ issues.
-        let l:path = expand(l:parent . '/' . 'dmd-wrapper')
-
-        if filereadable(l:path)
-            return l:path
+        if !empty(l:dub_file)
+            return l:dub_file
         endif
     endfor
+
+    return ''
 endfunction
 
-function! ale_linters#d#dmd#GetCommand(buffer)
-    let l:wrapper_script = s:FindWrapperScript()
+function! ale_linters#d#dmd#DUBCommand(buffer) abort
+    " If we can't run dub, then skip this command.
+    if !executable('dub')
+        " Returning an empty string skips to the DMD command.
+        return ''
+    endif
 
-    let l:command = l:wrapper_script . ' -o- -vcolumns -c'
+    let l:dub_file = s:FindDUBConfig(a:buffer)
 
-    return l:command
+    if empty(l:dub_file)
+        return ''
+    endif
+
+    " To support older dub versions, we just change the directory to
+    " the directory where we found the dub config, and then run `dub describe`
+    " from that directory.
+    return 'cd ' . fnameescape(fnamemodify(l:dub_file, ':h'))
+    \   . ' && dub describe --import-paths'
 endfunction
 
-function! ale_linters#d#dmd#Handle(buffer, lines)
+function! ale_linters#d#dmd#DMDCommand(buffer, dub_output) abort
+    let l:import_list = []
+
+    " Build a list of import paths generated from DUB, if available.
+    for l:line in a:dub_output
+        if !empty(l:line)
+            " The arguments must be '-Ifilename', not '-I filename'
+            call add(l:import_list, '-I' . fnameescape(l:line))
+        endif
+    endfor
+
+    return 'dmd '. join(l:import_list) . ' -o- -vcolumns -c %t'
+endfunction
+
+function! ale_linters#d#dmd#Handle(buffer, lines) abort
     " Matches patterns lines like the following:
-    "
+    " /tmp/tmp.qclsa7qLP7/file.d(1): Error: function declaration without return type. (Note that constructors are always named 'this')
     " /tmp/tmp.G1L5xIizvB.d(8,8): Error: module weak_reference is in file 'dstruct/weak_reference.d' which cannot be read
-    let l:pattern = '^[^(]\+(\([0-9]\+\),\([0-9]\+\)): \([^:]\+\): \(.\+\)'
+    let l:pattern = '^[^(]\+(\([0-9]\+\)\,\?\([0-9]*\)): \([^:]\+\): \(.\+\)'
     let l:output = []
 
     for l:line in a:lines
@@ -46,15 +68,12 @@ function! ale_linters#d#dmd#Handle(buffer, lines)
         let l:type = l:match[3]
         let l:text = l:match[4]
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': bufnr('%'),
         \   'lnum': l:line,
-        \   'vcol': 0,
         \   'col': l:column,
         \   'text': l:text,
         \   'type': l:type ==# 'Warning' ? 'W' : 'E',
-        \   'nr': -1,
         \})
     endfor
 
@@ -63,8 +82,10 @@ endfunction
 
 call ale#linter#Define('d', {
 \   'name': 'dmd',
-\   'output_stream': 'stderr',
 \   'executable': 'dmd',
-\   'command_callback': 'ale_linters#d#dmd#GetCommand',
+\   'command_chain': [
+\       {'callback': 'ale_linters#d#dmd#DUBCommand', 'output_stream': 'stdout'},
+\       {'callback': 'ale_linters#d#dmd#DMDCommand', 'output_stream': 'stderr'},
+\   ],
 \   'callback': 'ale_linters#d#dmd#Handle',
 \})

ale_linters/dockerfile/hadolint.vim

@@ -0,0 +1,43 @@
+" Author: hauleth - https://github.com/hauleth
+
+function! ale_linters#dockerfile#hadolint#Handle(buffer, lines) abort
+  " Matches patterns line the following:
+  "
+  " stdin:19: F: Pipe chain should start with a raw value.
+  let l:pattern = '\v^/dev/stdin:?(\d+)? (\S+) (.+)$'
+  let l:output = []
+
+  for l:line in a:lines
+    let l:match = matchlist(l:line, l:pattern)
+
+    if len(l:match) == 0
+        continue
+    endif
+
+    let l:lnum = 0
+
+    if l:match[1] !=# ''
+        let l:lnum = l:match[1] + 0
+    endif
+
+    let l:type = 'W'
+    let l:text = l:match[3]
+
+    call add(l:output, {
+    \   'bufnr': a:buffer,
+    \   'lnum': l:lnum,
+    \   'col': 0,
+    \   'type': l:type,
+    \   'text': l:text,
+    \   'nr': l:match[2],
+    \})
+  endfor
+
+  return l:output
+endfunction
+
+call ale#linter#Define('dockerfile', {
+      \ 'name': 'hadolint',
+      \ 'executable': 'hadolint',
+      \ 'command': 'hadolint -',
+      \ 'callback': 'ale_linters#dockerfile#hadolint#Handle' })

ale_linters/elixir/credo.vim

@@ -1,16 +1,10 @@
-" Author: hauleth - https://github.com/haulethe
+" Author: hauleth - https://github.com/hauleth
 
-if exists('g:loaded_ale_linters_elixir_credo')
-  finish
-endif
-
-let g:loaded_ale_linters_elixir_credo = 1
-
-function! ale_linters#elixir#credo#Handle(buffer, lines)
+function! ale_linters#elixir#credo#Handle(buffer, lines) abort
   " Matches patterns line the following:
   "
-  " stdin:19: F: Pipe chain should start with a raw value.
-  let l:pattern = '\v^stdin:(\d+):?(\d+)?: (.): (.+)$'
+  " lib/filename.ex:19:7: F: Pipe chain should start with a raw value.
+  let l:pattern = '\v:(\d+):?(\d+)?: (.): (.+)$'
   let l:output = []
 
   for l:line in a:lines
@@ -29,15 +23,12 @@ function! ale_linters#elixir#credo#Handle(buffer, lines)
       let l:type = 'W'
     endif
 
-    " vcol is Needed to indicate that the column is a character.
     call add(l:output, {
     \   'bufnr': a:buffer,
     \   'lnum': l:match[1] + 0,
-    \   'vcol': 0,
     \   'col': l:match[2] + 0,
     \   'type': l:type,
     \   'text': l:text,
-    \   'nr': -1,
     \})
   endfor
 
@@ -47,5 +38,5 @@ endfunction
 call ale#linter#Define('elixir', {
       \ 'name': 'credo',
       \ 'executable': 'mix',
-      \ 'command': 'mix credo suggest --format=flycheck --read-from-stdin',
+      \ 'command': 'mix credo suggest --format=flycheck --read-from-stdin %s',
       \ 'callback': 'ale_linters#elixir#credo#Handle' })

ale_linters/elm/make.vim

@@ -0,0 +1,65 @@
+" Author: buffalocoder - https://github.com/buffalocoder
+" Description: Elm linting in Ale. Closely follows the Syntastic checker in https://github.com/ElmCast/elm-vim.
+
+function! ale_linters#elm#make#Handle(buffer, lines) abort
+    let l:output = []
+    let l:is_windows = has('win32')
+    let l:temp_dir = l:is_windows ? $TMP : $TMPDIR
+    for l:line in a:lines
+        if l:line[0] ==# '['
+            let l:errors = json_decode(l:line)
+
+            for l:error in l:errors
+                " Check if file is from the temp directory.
+                " Filters out any errors not related to the buffer.
+                if l:is_windows
+                    let l:file_is_buffer = l:error.file[0:len(l:temp_dir) - 1] ==? l:temp_dir
+                else
+                    let l:file_is_buffer = l:error.file[0:len(l:temp_dir) - 1] ==# l:temp_dir
+                endif
+
+                if l:file_is_buffer
+                    call add(l:output, {
+                    \    'bufnr': a:buffer,
+                    \    'lnum': l:error.region.start.line,
+                    \    'col': l:error.region.start.column,
+                    \    'type': (l:error.type ==? 'error') ? 'E' : 'W',
+                    \    'text': l:error.overview,
+                    \    'detail': l:error.overview . "\n\n" . l:error.details
+                    \})
+                endif
+            endfor
+        endif
+    endfor
+
+    return l:output
+endfunction
+
+" Return the command to execute the linter in the projects directory.
+" If it doesn't, then this will fail when imports are needed.
+function! ale_linters#elm#make#GetCommand(buffer) abort
+    let l:elm_package = ale#util#FindNearestFile(a:buffer, 'elm-package.json')
+    if empty(l:elm_package)
+        let l:dir_set_cmd = ''
+    else
+        let l:root_dir = fnamemodify(l:elm_package, ':p:h')
+        let l:dir_set_cmd = 'cd ' . fnameescape(l:root_dir) . ' && '
+    endif
+
+    " The elm-make compiler, at the time of this writing, uses '/dev/null' as
+    " a sort of flag to tell the compiler not to generate an output file,
+    " which is why this is hard coded here.
+    " Source: https://github.com/elm-lang/elm-make/blob/master/src/Flags.hs
+    let l:elm_cmd = 'elm-make --report=json --output='.shellescape('/dev/null')
+
+    return l:dir_set_cmd . ' ' . l:elm_cmd . ' %t'
+endfunction
+
+call ale#linter#Define('elm', {
+\    'name': 'make',
+\    'executable': 'elm-make',
+\    'output_stream': 'both',
+\    'command_callback': 'ale_linters#elm#make#GetCommand',
+\    'callback': 'ale_linters#elm#make#Handle'
+\})
+

ale_linters/erlang/erlc.vim

@@ -0,0 +1,93 @@
+" Author: Magnus Ottenklinger - https://github.com/evnu
+
+let g:ale_erlang_erlc_options = get(g:, 'ale_erlang_erlc_options', '')
+
+function! ale_linters#erlang#erlc#GetCommand(buffer) abort
+    let l:output_file = tempname()
+    call ale#engine#ManageFile(a:buffer, l:output_file)
+    return 'erlc -o ' . fnameescape(l:output_file) . ' ' . g:ale_erlang_erlc_options . ' %t'
+endfunction
+
+function! ale_linters#erlang#erlc#Handle(buffer, lines) abort
+    " Matches patterns like the following:
+    "
+    " error.erl:4: variable 'B' is unbound
+    " error.erl:3: Warning: function main/0 is unused
+    " error.erl:4: Warning: variable 'A' is unused
+    let l:pattern = '\v^([^:]+):(\d+): (Warning: )?(.+)$'
+
+    " parse_transforms are a special case. The error message does not indicate a location:
+    " error.erl: undefined parse transform 'some_parse_transform'
+    let l:pattern_parse_transform = '\v(undefined parse transform .*)$'
+    let l:output = []
+
+    let l:pattern_no_module_definition = '\v(no module definition)$'
+    let l:pattern_unused = '\v(.* is unused)$'
+
+    let l:is_hrl = fnamemodify(bufname(a:buffer), ':e') ==# 'hrl'
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        " Determine if the output indicates an error. We distinguish between two cases:
+        "
+        " 1) normal errors match l:pattern
+        " 2) parse_transform errors match l:pattern_parse_transform
+        "
+        " If none of the patterns above match, the line can be ignored
+        if len(l:match) == 0 " not a 'normal' warning or error
+            let l:match_parse_transform = matchlist(l:line, l:pattern_parse_transform)
+
+            if len(l:match_parse_transform) == 0 " also not a parse_transform error
+                continue
+            endif
+
+            call add(l:output, {
+            \   'bufnr': a:buffer,
+            \   'lnum': 0,
+            \   'col': 0,
+            \   'type': 'E',
+            \   'text': l:match_parse_transform[0],
+            \})
+
+            continue
+        endif
+
+        let l:line = l:match[2]
+        let l:warning_or_text = l:match[3]
+        let l:text = l:match[4]
+
+        " If this file is a header .hrl, ignore the following expected messages:
+        " - 'no module definition'
+        " - 'X is unused'
+        if l:is_hrl && (
+        \   match(l:text, l:pattern_no_module_definition) != -1
+        \   || match(l:text, l:pattern_unused) != -1
+        \)
+            continue
+        endif
+
+        if !empty(l:warning_or_text)
+            let l:type = 'W'
+        else
+            let l:type = 'E'
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:line,
+        \   'col': 0,
+        \   'type': l:type,
+        \   'text': l:text,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('erlang', {
+\   'name': 'erlc',
+\   'executable': 'erlc',
+\   'command_callback': 'ale_linters#erlang#erlc#GetCommand',
+\   'callback': 'ale_linters#erlang#erlc#Handle',
+\})

ale_linters/fortran/gcc.vim

@@ -1,24 +1,18 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: gcc for Fortran files
 
-if exists('g:loaded_ale_linters_fortran_gcc')
-    finish
-endif
-
-let g:loaded_ale_linters_fortran_gcc = 1
-
 " Set this option to change the GCC options for warnings for Fortran.
 if !exists('g:ale_fortran_gcc_options')
     let g:ale_fortran_gcc_options = '-Wall'
 endif
 
-function! ale_linters#fortran#gcc#Handle(buffer, lines)
+function! ale_linters#fortran#gcc#Handle(buffer, lines) abort
     " We have to match a starting line and a later ending line together,
     " like so.
     "
     " :21.34:
     " Error: Expected comma in I/O list at (1)
-    let l:line_marker_pattern = '^:\(\d\+\)\.\(\d\+\):$'
+    let l:line_marker_pattern = ':\(\d\+\)[.:]\=\(\d\+\)\=:\=$'
     let l:message_pattern = '^\(Error\|Warning\): \(.\+\)$'
     let l:looking_for_message = 0
     let l:last_loclist_obj = {}
@@ -47,9 +41,7 @@ function! ale_linters#fortran#gcc#Handle(buffer, lines)
             let l:last_loclist_obj = {
             \   'bufnr': a:buffer,
             \   'lnum': l:match[1] + 0,
-            \   'vcol': 0,
             \   'col': l:match[2] + 0,
-            \   'nr': -1,
             \}
 
             " Start looking for the message and error type.

ale_linters/go/gobuild.vim

@@ -0,0 +1,218 @@
+" Author: Joshua Rubin <joshua@rubixconsulting.com>
+" Description: go build for Go files
+
+" inspired by work from dzhou121 <dzhou121@gmail.com>
+
+function! ale_linters#go#gobuild#GoEnv(buffer) abort
+  if exists('s:go_env')
+    return ''
+  endif
+
+  return 'go env GOPATH GOROOT'
+endfunction
+
+let s:SplitChar = has('unix') ? ':' : ':'
+
+" get a list of all source directories from $GOPATH and $GOROOT
+function! s:SrcDirs() abort
+  let l:paths = split(s:go_env.GOPATH, s:SplitChar)
+  call add(l:paths, s:go_env.GOROOT)
+
+  return l:paths
+endfunction
+
+" figure out from a directory like `/home/user/go/src/some/package` that the
+" import for that path is simply `some/package`
+function! s:PackageImportPath(buffer) abort
+  let l:bufname = resolve(bufname(a:buffer))
+  let l:pkgdir = fnamemodify(l:bufname, ':p:h')
+
+  for l:path in s:SrcDirs()
+    let l:path = l:path . '/src/'
+
+    if stridx(l:pkgdir, l:path) == 0
+      return l:pkgdir[strlen(l:path):]
+    endif
+  endfor
+
+  return ''
+endfunction
+
+" get the package info data structure using `go list`
+function! ale_linters#go#gobuild#GoList(buffer, goenv_output) abort
+  if !empty(a:goenv_output)
+    let s:go_env = {
+    \ 'GOPATH': a:goenv_output[0],
+    \ 'GOROOT': a:goenv_output[1],
+    \}
+  endif
+
+  return 'go list -json ' . shellescape(s:PackageImportPath(a:buffer))
+endfunction
+
+let s:filekeys = [
+\ 'GoFiles',
+\ 'CgoFiles',
+\ 'CFiles',
+\ 'CXXFiles',
+\ 'MFiles',
+\ 'HFiles',
+\ 'FFiles',
+\ 'SFiles',
+\ 'SwigFiles',
+\ 'SwigCXXFiles',
+\ 'SysoFiles',
+\ 'TestGoFiles',
+\ 'XTestGoFiles',
+\]
+
+" get the go and test go files from the package
+" will return empty list if the package has any cgo or other invalid files
+function! s:PkgFiles(pkginfo) abort
+  let l:files = []
+
+  for l:key in s:filekeys
+    if has_key(a:pkginfo, l:key)
+      call extend(l:files, a:pkginfo[l:key])
+    endif
+  endfor
+
+  " resolve the path of the file relative to the window directory
+  return map(l:files, 'shellescape(fnamemodify(resolve(a:pkginfo.Dir . ''/'' . v:val), '':p''))')
+endfunction
+
+function! ale_linters#go#gobuild#CopyFiles(buffer, golist_output) abort
+  let l:tempdir = tempname()
+  let l:temppkgdir = l:tempdir . '/src/' . s:PackageImportPath(a:buffer)
+  call mkdir(l:temppkgdir, 'p', 0700)
+
+  if empty(a:golist_output)
+    return 'echo ' . shellescape(l:tempdir)
+  endif
+
+  " parse the output
+  let l:pkginfo = json_decode(join(a:golist_output, "\n"))
+
+  " get all files for the package
+  let l:files = s:PkgFiles(l:pkginfo)
+
+  " copy the files to a temp directory with $GOPATH structure
+  return 'cp ' . join(l:files, ' ') . ' ' . shellescape(l:temppkgdir) . ' && echo ' . shellescape(l:tempdir)
+endfunction
+
+function! ale_linters#go#gobuild#GetCommand(buffer, copy_output) abort
+  " If for some reason we don't get any output from the last command, stop
+  " here.
+  if empty(a:copy_output)
+    return ''
+  endif
+
+  let l:tempdir = a:copy_output[0]
+  let l:importpath = s:PackageImportPath(a:buffer)
+
+  " write the a:buffer and any modified buffers from the package to the tempdir
+  for l:bufnum in range(1, bufnr('$'))
+    " ignore unloaded buffers (can't be a:buffer or a modified buffer)
+    if !bufloaded(l:bufnum)
+      continue
+    endif
+
+    " ignore non-Go buffers
+    if getbufvar(l:bufnum, '&ft') !=# 'go'
+      continue
+    endif
+
+    " only consider buffers other than a:buffer if they have the same import
+    " path as a:buffer and are modified
+    if l:bufnum != a:buffer
+      if s:PackageImportPath(l:bufnum) !=# l:importpath
+        continue
+      endif
+
+      if !getbufvar(l:bufnum, '&mod')
+        continue
+      endif
+    endif
+
+    call writefile(getbufline(l:bufnum, 1, '$'), l:tempdir . '/src/' . s:PkgFile(l:bufnum))
+  endfor
+
+  let l:gopaths = [ l:tempdir ]
+  call extend(l:gopaths, split(s:go_env.GOPATH, s:SplitChar))
+
+  return 'GOPATH=' . shellescape(join(l:gopaths, s:SplitChar)) . ' go test -c -o /dev/null ' . shellescape(l:importpath)
+endfunction
+
+function! s:PkgFile(buffer) abort
+  let l:bufname = resolve(bufname(a:buffer))
+  let l:importpath = s:PackageImportPath(a:buffer)
+  let l:fname = fnamemodify(l:bufname, ':t')
+
+  return l:importpath . '/' . l:fname
+endfunction
+
+function! s:FindBuffer(file) abort
+  for l:buffer in range(1, bufnr('$'))
+    if !buflisted(l:buffer)
+      continue
+    endif
+
+    let l:pkgfile = s:PkgFile(l:buffer)
+
+    if a:file =~ '/' . l:pkgfile . '$'
+      return l:buffer
+    endif
+  endfor
+
+  return -1
+endfunction
+
+let s:path_pattern = '[a-zA-Z]\?\\\?:\?[[:alnum:]/\.\-_]\+'
+let s:handler_pattern = '^\(' . s:path_pattern . '\):\(\d\+\):\?\(\d\+\)\?: \(.\+\)$'
+
+let s:multibuffer = 0
+
+function! ale_linters#go#gobuild#Handler(buffer, lines) abort
+  let l:output = []
+
+  for l:line in a:lines
+    let l:match = matchlist(l:line, s:handler_pattern)
+
+    if len(l:match) == 0
+      continue
+    endif
+
+    let l:buffer = s:FindBuffer(l:match[1])
+
+    if l:buffer == -1
+      continue
+    endif
+
+    if !s:multibuffer && l:buffer != a:buffer
+      " strip lines from other buffers
+      continue
+    endif
+
+    call add(l:output, {
+    \   'bufnr': l:buffer,
+    \   'lnum': l:match[2] + 0,
+    \   'col': l:match[3] + 0,
+    \   'text': l:match[4],
+    \   'type': 'E',
+    \})
+  endfor
+
+  return l:output
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'go build',
+\   'executable': 'go',
+\   'command_chain': [
+\     {'callback': 'ale_linters#go#gobuild#GoEnv', 'output_stream': 'stdout'},
+\     {'callback': 'ale_linters#go#gobuild#GoList', 'output_stream': 'stdout'},
+\     {'callback': 'ale_linters#go#gobuild#CopyFiles', 'output_stream': 'stdout'},
+\     {'callback': 'ale_linters#go#gobuild#GetCommand', 'output_stream': 'stderr'},
+\   ],
+\   'callback': 'ale_linters#go#gobuild#Handler',
+\})

ale_linters/go/gofmt.vim

@@ -1,17 +1,10 @@
 " Author: neersighted <bjorn@neersighted.com>
 " Description: gofmt for Go files
 
-if exists('g:loaded_ale_linters_go_gofmt')
-    finish
-endif
-
-let g:loaded_ale_linters_go_gofmt = 1
-
 call ale#linter#Define('go', {
 \   'name': 'gofmt',
 \   'output_stream': 'stderr',
 \   'executable': 'gofmt',
-\   'command': g:ale#util#stdin_wrapper . ' .go gofmt -e',
+\   'command': 'gofmt -e %t',
 \   'callback': 'ale#handlers#HandleUnixFormatAsError',
 \})
-

ale_linters/go/golint.vim

@@ -1,15 +1,9 @@
 " Author: neersighted <bjorn@neersighted.com>
 " Description: golint for Go files
 
-if exists('g:loaded_ale_linters_go_golint')
-    finish
-endif
-
-let g:loaded_ale_linters_go_golint = 1
-
 call ale#linter#Define('go', {
 \   'name': 'golint',
 \   'executable': 'golint',
-\   'command': g:ale#util#stdin_wrapper . ' .go golint',
+\   'command': 'golint %t',
 \   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
 \})

ale_linters/go/govet.vim

@@ -1,17 +1,10 @@
 " Author: neersighted <bjorn@neersighted.com>
 " Description: go vet for Go files
 
-if exists('g:loaded_ale_linters_go_govet')
-    finish
-endif
-
-let g:loaded_ale_linters_go_govet = 1
-
 call ale#linter#Define('go', {
 \   'name': 'go vet',
 \   'output_stream': 'stderr',
 \   'executable': 'go',
-\   'command': g:ale#util#stdin_wrapper . ' .go go vet',
+\   'command': 'go vet %t',
 \   'callback': 'ale#handlers#HandleUnixFormatAsError',
 \})
-

ale_linters/haml/hamllint.vim

@@ -0,0 +1,33 @@
+" Author: Patrick Lewis - https://github.com/patricklewis
+" Description: haml-lint for Haml files
+
+function! ale_linters#haml#hamllint#Handle(buffer, lines) abort
+    " Matches patterns like the following:
+    " <path>:51 [W] RuboCop: Use the new Ruby 1.9 hash syntax.
+    let l:pattern = '\v^.*:(\d+) \[([EW])\] (.+)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[1] + 0,
+        \   'type': l:match[2],
+        \   'text': l:match[3]
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('haml', {
+\   'name': 'hamllint',
+\   'executable': 'haml-lint',
+\   'command': 'haml-lint %t',
+\   'callback': 'ale_linters#haml#hamllint#Handle'
+\})

ale_linters/haskell/ghc.vim

@@ -1,24 +1,18 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: ghc for Haskell files
 
-if exists('g:loaded_ale_linters_haskell_ghc')
-    finish
-endif
-
-let g:loaded_ale_linters_haskell_ghc = 1
-
 call ale#linter#Define('haskell', {
 \   'name': 'ghc',
 \   'output_stream': 'stderr',
 \   'executable': 'ghc',
-\   'command': g:ale#util#stdin_wrapper . ' .hs ghc -fno-code -v0',
-\   'callback': 'ale#handlers#HandleUnixFormatAsError',
+\   'command': 'ghc -fno-code -v0 %t',
+\   'callback': 'ale#handlers#HandleGhcFormat',
 \})
 
 call ale#linter#Define('haskell', {
 \   'name': 'stack-ghc',
 \   'output_stream': 'stderr',
 \   'executable': 'stack',
-\   'command': g:ale#util#stdin_wrapper . ' .hs stack ghc -- -fno-code -v0',
-\   'callback': 'ale#handlers#HandleUnixFormatAsError',
+\   'command': 'stack ghc -- -fno-code -v0 %t',
+\   'callback': 'ale#handlers#HandleGhcFormat',
 \})

ale_linters/haskell/hdevtools.vim

@@ -0,0 +1,9 @@
+" Author: rob-b
+" Description: hdevtools for Haskell files
+
+call ale#linter#Define('haskell', {
+\   'name': 'hdevtools',
+\   'executable': 'hdevtools',
+\   'command': 'hdevtools check -g -Wall -p %s %t',
+\   'callback': 'ale#handlers#HandleGhcFormat',
+\})

ale_linters/haskell/hlint.vim

@@ -1,25 +1,17 @@
 " Author: jparoz <jesse.paroz@gmail.com>
 " Description: hlint for Haskell files
 
-if exists('g:loaded_ale_linters_haskell_hlint')
-    finish
-endif
-
-let g:loaded_ale_linters_haskell_hlint = 1
-
-function! ale_linters#haskell#hlint#Handle(buffer, lines)
+function! ale_linters#haskell#hlint#Handle(buffer, lines) abort
     let l:errors = json_decode(join(a:lines, ''))
 
     let l:output = []
 
     for l:error in l:errors
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:error.startLine + 0,
-        \   'vcol': 0,
         \   'col': l:error.startColumn + 0,
-        \   'text': l:error.severity . ': ' . l:error.hint,
+        \   'text': l:error.severity . ': ' . l:error.hint . '. Found: ' . l:error.from . ' Why not: ' . l:error.to,
         \   'type': l:error.severity ==# 'Error' ? 'E' : 'W',
         \})
     endfor

ale_linters/help/proselint.vim

@@ -0,0 +1,9 @@
+" Author: Daniel M. Capella https://github.com/polyzen
+" Description: proselint for Vim help files
+
+call ale#linter#Define('help', {
+\   'name': 'proselint',
+\   'executable': 'proselint',
+\   'command': 'proselint %t',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/html/htmlhint.vim

@@ -1,15 +1,36 @@
-" Author: KabbAmine <amine.kabb@gmail.com>
+" Author: KabbAmine <amine.kabb@gmail.com>, deathmaz <00maz1987@gmail.com>, diartyz <diartyz@gmail.com>
 " Description: HTMLHint for checking html files
 
-if exists('g:loaded_ale_linters_html_htmlhint')
-    finish
-endif
+" CLI options
+let g:ale_html_htmlhint_options = get(g:, 'ale_html_htmlhint_options', '--format=unix')
 
-let g:loaded_ale_linters_html_htmlhint = 1
+let g:ale_html_htmlhint_executable =
+\   get(g:, 'ale_html_htmlhint_executable', 'htmlhint')
+
+let g:ale_html_htmlhint_use_global =
+\   get(g:, 'ale_html_htmlhint_use_global', 0)
+
+function! ale_linters#html#htmlhint#GetExecutable(buffer) abort
+    if g:ale_html_htmlhint_use_global
+        return g:ale_html_htmlhint_executable
+    endif
+
+    return ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/htmlhint',
+    \   g:ale_html_htmlhint_executable
+    \)
+endfunction
+
+function! ale_linters#html#htmlhint#GetCommand(buffer) abort
+    return ale_linters#html#htmlhint#GetExecutable(a:buffer)
+    \   . ' ' . g:ale_html_htmlhint_options
+    \   . ' %t'
+endfunction
 
 call ale#linter#Define('html', {
 \   'name': 'htmlhint',
-\   'executable': 'htmlhint',
-\   'command': 'htmlhint --format=unix stdin',
+\   'executable_callback': 'ale_linters#html#htmlhint#GetExecutable',
+\   'command_callback': 'ale_linters#html#htmlhint#GetCommand',
 \   'callback': 'ale#handlers#HandleUnixFormatAsError',
 \})

ale_linters/html/proselint.vim

@@ -0,0 +1,9 @@
+" Author: Daniel M. Capella https://github.com/polyzen
+" Description: proselint for HTML files
+
+call ale#linter#Define('html', {
+\   'name': 'proselint',
+\   'executable': 'proselint',
+\   'command': 'proselint %t',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/html/tidy.vim

@@ -1,12 +1,6 @@
 " Author: KabbAmine <amine.kabb@gmail.com>
 " Description: This file adds support for checking HTML code with tidy.
 
-if exists('g:loaded_ale_linters_html_tidy')
-    finish
-endif
-
-let g:loaded_ale_linters_html_tidy = 1
-
 " CLI options
 let g:ale_html_tidy_executable = get(g:, 'ale_html_tidy_executable', 'tidy')
 let g:ale_html_tidy_args = get(g:, 'ale_html_tidy_args', '-q -e -language en')
@@ -55,15 +49,12 @@ function! ale_linters#html#tidy#Handle(buffer, lines) abort
         let l:type = l:match[3] ==# 'Error' ? 'E' : 'W'
         let l:text = l:match[4]
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:line,
-        \   'vcol': 0,
         \   'col': l:col,
         \   'text': l:text,
         \   'type': l:type,
-        \   'nr': -1,
         \})
     endfor
 

ale_linters/java/javac.vim

@@ -0,0 +1,51 @@
+" Author: farenjihn <farenjihn@gmail.com>, w0rp <devw0rp@gmail.com>
+" Description: Lints java files using javac
+
+let g:ale_java_javac_options = get(g:, 'ale_java_javac_options', '')
+let g:ale_java_javac_classpath = get(g:, 'ale_java_javac_classpath', '')
+
+function! ale_linters#java#javac#GetCommand(buffer) abort
+    let l:cp_option = !empty(g:ale_java_javac_classpath)
+    \   ?  '-cp ' . g:ale_java_javac_classpath
+    \   : ''
+
+    return 'javac -Xlint '
+    \ . l:cp_option
+    \ . ' ' . g:ale_java_javac_options
+    \ . ' %t'
+endfunction
+
+function! ale_linters#java#javac#Handle(buffer, lines) abort
+    " Look for lines like the following.
+    "
+    " Main.java:13: warning: [deprecation] donaught() in Testclass has been deprecated
+    " Main.java:16: error: ';' expected
+
+    let l:pattern = '^.*\:\(\d\+\):\ \(.*\):\(.*\)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[1] + 0,
+        \   'text': l:match[2] . ':' . l:match[3],
+        \   'type': l:match[2] ==# 'error' ? 'E' : 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('java', {
+\   'name': 'javac',
+\   'output_stream': 'stderr',
+\   'executable': 'javac',
+\   'command_callback': 'ale_linters#java#javac#GetCommand',
+\   'callback': 'ale_linters#java#javac#Handle',
+\})

ale_linters/javascript/eslint.vim

@@ -1,48 +1,87 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: eslint for JavaScript files
 
-if exists('g:loaded_ale_linters_javascript_eslint')
-    finish
-endif
-
-let g:loaded_ale_linters_javascript_eslint = 1
-
 let g:ale_javascript_eslint_executable =
 \   get(g:, 'ale_javascript_eslint_executable', 'eslint')
 
-function! ale_linters#javascript#eslint#Handle(buffer, lines)
+let g:ale_javascript_eslint_options =
+\   get(g:, 'ale_javascript_eslint_options', '')
+
+let g:ale_javascript_eslint_use_global =
+\   get(g:, 'ale_javascript_eslint_use_global', 0)
+
+function! ale_linters#javascript#eslint#GetExecutable(buffer) abort
+    if g:ale_javascript_eslint_use_global
+        return g:ale_javascript_eslint_executable
+    endif
+
+    return ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/eslint',
+    \   g:ale_javascript_eslint_executable
+    \)
+endfunction
+
+function! ale_linters#javascript#eslint#GetCommand(buffer) abort
+    return ale_linters#javascript#eslint#GetExecutable(a:buffer)
+    \   . ' ' . g:ale_javascript_eslint_options
+    \   . ' -f unix --stdin --stdin-filename %s'
+endfunction
+
+function! ale_linters#javascript#eslint#Handle(buffer, lines) abort
+    let l:config_error_pattern = '\v^ESLint couldn''t find a configuration file'
+    \   . '|^Cannot read config file'
+
+    " Look for a message in the first few lines which indicates that
+    " a configuration file couldn't be found.
+    for l:line in a:lines[:10]
+        if len(matchlist(l:line, l:config_error_pattern)) > 0
+            return [{
+            \   'lnum': 1,
+            \   'text': 'eslint configuration error (type :ALEDetail for more information)',
+            \   'detail': join(a:lines, "\n"),
+            \}]
+        endif
+    endfor
+
     " Matches patterns line the following:
     "
     " /path/to/some-filename.js:47:14: Missing trailing comma. [Warning/comma-dangle]
     " /path/to/some-filename.js:56:41: Missing semicolon. [Error/semi]
     let l:pattern = '^.*:\(\d\+\):\(\d\+\): \(.\+\) \[\(.\+\)\]$'
+    " This second pattern matches lines like the following:
+    "
+    " /path/to/some-filename.js:13:3: Parsing error: Unexpected token
+    let l:parsing_pattern = '^.*:\(\d\+\):\(\d\+\): \(.\+\)$'
     let l:output = []
 
     for l:line in a:lines
         let l:match = matchlist(l:line, l:pattern)
 
+        if len(l:match) == 0
+            " Try the parsing pattern for parsing errors.
+            let l:match = matchlist(l:line, l:parsing_pattern)
+        endif
+
         if len(l:match) == 0
             continue
         endif
 
+        let l:type = 'Error'
         let l:text = l:match[3]
-        let l:marker = l:match[4]
-        let l:marker_parts = split(l:marker, '/')
-        let l:type = l:marker_parts[0]
 
-        if len(l:marker_parts) == 2
-            let l:text = l:text . ' (' . l:marker_parts[1] . ')'
+        " Take the error type from the output if available.
+        if !empty(l:match[4])
+            let l:type = split(l:match[4], '/')[0]
+            let l:text .= ' [' . l:match[4] . ']'
         endif
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
-        \   'vcol': 0,
         \   'col': l:match[2] + 0,
         \   'text': l:text,
         \   'type': l:type ==# 'Warning' ? 'W' : 'E',
-        \   'nr': -1,
         \})
     endfor
 
@@ -51,7 +90,7 @@ endfunction
 
 call ale#linter#Define('javascript', {
 \   'name': 'eslint',
-\   'executable': g:ale_javascript_eslint_executable,
-\   'command': g:ale_javascript_eslint_executable . ' -f unix --stdin --stdin-filename %s',
+\   'executable_callback': 'ale_linters#javascript#eslint#GetExecutable',
+\   'command_callback': 'ale_linters#javascript#eslint#GetCommand',
 \   'callback': 'ale_linters#javascript#eslint#Handle',
 \})

ale_linters/javascript/flow.vim

@@ -0,0 +1,85 @@
+" Author: Zach Perrault -- @zperrault
+" Description: FlowType checking for JavaScript files
+
+let g:ale_javascript_flow_executable =
+\   get(g:, 'ale_javascript_flow_executable', 'flow')
+
+let g:ale_javascript_flow_use_global =
+\   get(g:, 'ale_javascript_flow_use_global', 0)
+
+function! ale_linters#javascript#flow#GetExecutable(buffer) abort
+    if g:ale_javascript_flow_use_global
+        return g:ale_javascript_flow_executable
+    endif
+
+    return ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/flow',
+    \   g:ale_javascript_flow_executable
+    \)
+endfunction
+
+function! ale_linters#javascript#flow#GetCommand(buffer) abort
+    let l:flow_config = ale#util#FindNearestFile(a:buffer, '.flowconfig')
+
+    if empty(l:flow_config)
+        " Don't run Flow if we can't find a .flowconfig file.
+        return ''
+    endif
+
+    return ale_linters#javascript#flow#GetExecutable(a:buffer)
+    \   . ' check-contents --respect-pragma --json --from ale %s'
+endfunction
+
+function! ale_linters#javascript#flow#Handle(buffer, lines) abort
+    let l:str = join(a:lines, '')
+
+    if l:str ==# ''
+        return []
+    endif
+
+    let l:flow_output = json_decode(l:str)
+    let l:output = []
+
+    for l:error in get(l:flow_output, 'errors', [])
+        " Each error is broken up into parts
+        let l:text = ''
+        let l:line = 0
+        let l:col = 0
+
+        for l:message in l:error.message
+            " Comments have no line of column information
+            if has_key(l:message, 'loc') && l:line ==# 0
+                let l:line = l:message.loc.start.line + 0
+                let l:col = l:message.loc.start.column + 0
+            endif
+
+            if l:text ==# ''
+                let l:text = l:message.descr . ':'
+            else
+                let l:text = l:text . ' ' . l:message.descr
+            endif
+        endfor
+
+        if has_key(l:error, 'operation')
+            let l:text = l:text . ' See also: ' . l:error.operation.descr
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:line,
+        \   'col': l:col,
+        \   'text': l:text,
+        \   'type': l:error.level ==# 'error' ? 'E' : 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('javascript', {
+\   'name': 'flow',
+\   'executable_callback': 'ale_linters#javascript#flow#GetExecutable',
+\   'command_callback': 'ale_linters#javascript#flow#GetCommand',
+\   'callback': 'ale_linters#javascript#flow#Handle',
+\})

ale_linters/javascript/jscs.vim

@@ -1,12 +1,6 @@
 " Author: Chris Kyrouac - https://github.com/fijshion
 " Description: jscs for JavaScript files
 
-if exists('g:loaded_ale_linters_javascript_jscs')
-    finish
-endif
-
-let g:loaded_ale_linters_javascript_jscs = 1
-
 call ale#linter#Define('javascript', {
 \   'name': 'jscs',
 \   'executable': 'jscs',

ale_linters/javascript/jshint.vim

@@ -1,26 +1,34 @@
 " Author: Chris Kyrouac - https://github.com/fijshion
 " Description: JSHint for Javascript files
 
-if exists('g:loaded_ale_linters_javascript_jshint')
-    finish
-endif
-
-let g:loaded_ale_linters_javascript_jshint = 1
-
 let g:ale_javascript_jshint_executable =
 \   get(g:, 'ale_javascript_jshint_executable', 'jshint')
 
-function! ale_linters#javascript#jshint#GetCommand(buffer)
-    " Set this to the location of the jshint configuration file to
-    " use a fixed location for .jshintrc
-    if exists('g:ale_jshint_config_loc')
-        let l:jshint_config = g:ale_jshint_config_loc
-    else
-        " Look for the JSHint config in parent directories.
-        let l:jshint_config = ale#util#FindNearestFile(a:buffer, '.jshintrc')
+let g:ale_javascript_jshint_use_global =
+\   get(g:, 'ale_javascript_jshint_use_global', 0)
+
+function! ale_linters#javascript#jshint#GetExecutable(buffer) abort
+    if g:ale_javascript_jshint_use_global
+        return g:ale_javascript_jshint_executable
     endif
 
-    let l:command = g:ale_javascript_jshint_executable . ' --reporter unix'
+    return ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/jshint',
+    \   g:ale_javascript_jshint_executable
+    \)
+endfunction
+
+function! ale_linters#javascript#jshint#GetCommand(buffer) abort
+    " Search for a local JShint config locaation, and default to a global one.
+    let l:jshint_config = ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   '.jshintrc',
+    \   get(g:, 'ale_jshint_config_loc', '')
+    \)
+
+    let l:command = ale_linters#javascript#jshint#GetExecutable(a:buffer)
+    let l:command .= ' --reporter unix'
 
     if !empty(l:jshint_config)
         let l:command .= ' --config ' . fnameescape(l:jshint_config)
@@ -33,7 +41,7 @@ endfunction
 
 call ale#linter#Define('javascript', {
 \   'name': 'jshint',
-\   'executable': g:ale_javascript_jshint_executable,
+\   'executable_callback': 'ale_linters#javascript#jshint#GetExecutable',
 \   'command_callback': 'ale_linters#javascript#jshint#GetCommand',
 \   'callback': 'ale#handlers#HandleUnixFormatAsError',
 \})

ale_linters/javascript/standard.vim

@@ -0,0 +1,68 @@
+" Author: Ahmed El Gabri <@ahmedelgabri>
+" Description: standardjs for JavaScript files
+
+let g:ale_javascript_standard_executable =
+\   get(g:, 'ale_javascript_standard_executable', 'standard')
+
+let g:ale_javascript_standard_options =
+\   get(g:, 'ale_javascript_standard_options', '')
+
+let g:ale_javascript_standard_use_global =
+\   get(g:, 'ale_javascript_standard_use_global', 0)
+
+function! ale_linters#javascript#standard#GetExecutable(buffer) abort
+    if g:ale_javascript_standard_use_global
+        return g:ale_javascript_standard_executable
+    endif
+
+    return ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/standard',
+    \   g:ale_javascript_standard_executable
+    \)
+endfunction
+
+function! ale_linters#javascript#standard#GetCommand(buffer) abort
+    return ale_linters#javascript#standard#GetExecutable(a:buffer)
+    \   . ' ' . g:ale_javascript_standard_options
+    \   . ' --stdin %s'
+endfunction
+
+function! ale_linters#javascript#standard#Handle(buffer, lines) abort
+    " Matches patterns line the following:
+    "
+    " /path/to/some-filename.js:47:14: Strings must use singlequote.
+    " /path/to/some-filename.js:56:41: Expected indentation of 2 spaces but found 4.
+    " /path/to/some-filename.js:13:3: Parsing error: Unexpected token
+    let l:pattern = '^.*:\(\d\+\):\(\d\+\): \(.\+\)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        let l:type = 'Error'
+        let l:text = l:match[3]
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:match[2] + 0,
+        \   'text': l:text,
+        \   'type': 'E',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('javascript', {
+\   'name': 'standard',
+\   'executable_callback': 'ale_linters#javascript#standard#GetExecutable',
+\   'command_callback': 'ale_linters#javascript#standard#GetCommand',
+\   'callback': 'ale_linters#javascript#standard#Handle',
+\})
+

ale_linters/javascript/xo.vim

@@ -0,0 +1,41 @@
+" Author: Daniel Lupu <lupu.daniel.f@gmail.com>
+" Description: xo for JavaScript files
+
+let g:ale_javascript_xo_executable =
+\   get(g:, 'ale_javascript_xo_executable', 'xo')
+
+let g:ale_javascript_xo_options =
+\   get(g:, 'ale_javascript_xo_options', '')
+
+let g:ale_javascript_xo_use_global =
+\   get(g:, 'ale_javascript_xo_use_global', 0)
+
+function! ale_linters#javascript#xo#GetExecutable(buffer) abort
+    if g:ale_javascript_xo_use_global
+        return g:ale_javascript_xo_executable
+    endif
+
+    return ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/xo',
+    \   g:ale_javascript_xo_executable
+    \)
+endfunction
+
+function! ale_linters#javascript#xo#GetCommand(buffer) abort
+    return ale_linters#javascript#xo#GetExecutable(a:buffer)
+    \   . ' ' . g:ale_javascript_xo_options
+    \   . ' --reporter unix --stdin --stdin-filename %s'
+endfunction
+
+function! ale_linters#javascript#xo#Handle(buffer, lines) abort
+    " xo uses eslint and the output format is the same
+    return ale_linters#javascript#eslint#Handle(a:buffer, a:lines)
+endfunction
+
+call ale#linter#Define('javascript', {
+\   'name': 'xo',
+\   'executable_callback': 'ale_linters#javascript#xo#GetExecutable',
+\   'command_callback': 'ale_linters#javascript#xo#GetCommand',
+\   'callback': 'ale_linters#javascript#xo#Handle',
+\})

ale_linters/json/jsonlint.vim

@@ -1,12 +1,6 @@
 " Author: KabbAmine <amine.kabb@gmail.com>
 
-if exists('g:loaded_ale_linters_json_jsonlint')
-    finish
-endif
-
-let g:loaded_ale_linters_json_jsonlint = 1
-
-function! ale_linters#json#jsonlint#Handle(buffer, lines)
+function! ale_linters#json#jsonlint#Handle(buffer, lines) abort
     " Matches patterns like the following:
     " line 2, col 15, found: 'STRING' - expected: 'EOF', '}', ',', ']'.
 
@@ -20,15 +14,12 @@ function! ale_linters#json#jsonlint#Handle(buffer, lines)
             continue
         endif
 
-        " vcol is needed to indicate that the column is a character
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
-        \   'vcol': 0,
         \   'col': l:match[2] + 0,
         \   'text': l:match[3],
         \   'type': 'E',
-        \   'nr': -1,
         \})
     endfor
 

ale_linters/lua/luacheck.vim

@@ -1,16 +1,10 @@
 " Author: Sol Bekic https://github.com/s-ol
 " Description: luacheck linter for lua files
 
-if exists('g:loaded_ale_linters_lua_luacheck')
-    finish
-endif
-
-let g:loaded_ale_linters_lua_luacheck = 1
-
 let g:ale_lua_luacheck_executable =
 \   get(g:, 'ale_lua_luacheck_executable', 'luacheck')
 
-function! ale_linters#lua#luacheck#Handle(buffer, lines)
+function! ale_linters#lua#luacheck#Handle(buffer, lines) abort
     " Matches patterns line the following:
     "
     " artal.lua:159:17: (W111) shadowing definition of loop variable 'i' on line 106
@@ -25,15 +19,12 @@ function! ale_linters#lua#luacheck#Handle(buffer, lines)
             continue
         endif
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
-        \   'vcol': 0,
         \   'col': l:match[2] + 0,
         \   'text': l:match[4],
         \   'type': l:match[3],
-        \   'nr': -1,
         \})
     endfor
 

ale_linters/markdown/mdl.vim

@@ -0,0 +1,33 @@
+" Author: Steve Dignam <steve@dignam.xyz>
+" Description: Support for mdl, a markdown linter
+
+function! ale_linters#markdown#mdl#Handle(buffer, lines) abort
+    " matches: '(stdin):173: MD004 Unordered list style'
+    let l:pattern = ':\(\d*\): \(.*\)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[1] + 0,
+        \   'col': 0,
+        \   'text': l:match[2],
+        \   'type': 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('markdown', {
+\   'name': 'mdl',
+\   'executable': 'mdl',
+\   'command': 'mdl',
+\   'callback': 'ale_linters#markdown#mdl#Handle'
+\})

ale_linters/markdown/proselint.vim

@@ -0,0 +1,9 @@
+" Author: poohzrn https://github.com/poohzrn
+" Description: proselint for Markdown files
+
+call ale#linter#Define('markdown', {
+\   'name': 'proselint',
+\   'executable': 'proselint',
+\   'command': 'proselint %t',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/matlab/mlint.vim

@@ -0,0 +1,61 @@
+" Author: awlayton <alex@layton.in>
+" Description: mlint for MATLAB files
+
+let g:ale_matlab_mlint_executable =
+\   get(g:, 'ale_matlab_mlint_executable', 'mlint')
+
+function! ale_linters#matlab#mlint#GetExecutable(buffer) abort
+    return g:ale_matlab_mlint_executable
+endfunction
+
+function! ale_linters#matlab#mlint#GetCommand(buffer) abort
+    let l:executable = ale_linters#matlab#mlint#GetExecutable(a:buffer)
+
+    return l:executable . ' -id %t'
+endfunction
+
+function! ale_linters#matlab#mlint#Handle(buffer, lines) abort
+    " Matches patterns like the following:
+    "
+    " L 27 (C 1): FNDEF: Terminate statement with semicolon to suppress output.
+    " L 30 (C 13-15): FNDEF: A quoted string is unterminated.
+    let l:pattern = '^L \(\d\+\) (C \([0-9-]\+\)): \([A-Z]\+\): \(.\+\)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        let l:lnum = l:match[1] + 0
+        let l:col = l:match[2] + 0
+        let l:code = l:match[3]
+        let l:text = l:match[4]
+
+        " Suppress erroneous waring about filename
+        " TODO: Enable this error when copying filename is supported
+        if l:code ==# 'FNDEF'
+            continue
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:lnum,
+        \   'col': l:col,
+        \   'text': l:text,
+        \   'type': 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('matlab', {
+\   'name': 'mlint',
+\   'executable_callback': 'ale_linters#matlab#mlint#GetExecutable',
+\   'command_callback': 'ale_linters#matlab#mlint#GetCommand',
+\   'output_stream': 'stderr',
+\   'callback': 'ale_linters#matlab#mlint#Handle',
+\})

ale_linters/nim/nimcheck.vim

@@ -0,0 +1,65 @@
+" Author: Baabelfish
+" Description: Typechecking for nim files
+
+
+function! ale_linters#nim#nimcheck#Handle(buffer, lines) abort
+    let l:buffer_filename = fnamemodify(bufname(a:buffer), ':p:t')
+    let l:pattern = '^\(.\+\.nim\)(\(\d\+\), \(\d\+\)) \(.\+\)'
+    let l:output = [] 
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        " Only show errors of the current buffer
+        " NOTE: Checking filename only is OK because nim enforces unique
+        "       module names.
+
+        let l:temp_buffer_filename = fnamemodify(l:match[1], ':p:t')
+        if l:buffer_filename !=# '' && l:temp_buffer_filename !=# l:buffer_filename
+            continue
+        endif
+
+        let l:line = l:match[2] + 0
+        let l:column = l:match[3] + 0
+        let l:text = l:match[4]
+        let l:type = 'W'
+
+        " Extract error type from message of type 'Error: Some error message'
+        let l:textmatch = matchlist(l:match[4], '^\(.\{-}\): .\+$')
+
+        if len(l:textmatch) > 0
+            let l:errortype = l:textmatch[1]
+            if l:errortype ==# 'Error'
+                let l:type = 'E'
+            endif
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:line,
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+
+function! ale_linters#nim#nimcheck#GetCommand(buffer)
+    return 'nim check --path:' . fnameescape(fnamemodify(bufname(a:buffer), ':p:h')) . ' --verbosity:0 --colors:off --listFullPaths %t'
+endfunction
+
+
+call ale#linter#Define('nim', {
+\    'name': 'nimcheck',
+\    'executable': 'nim',
+\    'output_stream': 'both',
+\    'command_callback': 'ale_linters#nim#nimcheck#GetCommand',
+\    'callback': 'ale_linters#nim#nimcheck#Handle'
+\})

ale_linters/nix/nix.vim

@@ -0,0 +1,34 @@
+" Author: Alistair Bill <@alibabzo>
+" Description: nix-instantiate linter for nix files
+
+function! ale_linters#nix#nix#Handle(buffer, lines) abort
+
+    let l:pattern = '^\(.\+\): \(.\+\), at .*:\(\d\+\):\(\d\+\)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[3] + 0,
+        \   'col': l:match[4] + 0,
+        \   'text': l:match[1] . ': ' . l:match[2],
+        \   'type': l:match[1] =~# '^error' ? 'E' : 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('nix', {
+\   'name': 'nix',
+\   'output_stream': 'stderr',
+\   'executable': 'nix-instantiate',
+\   'command': 'nix-instantiate --parse -',
+\   'callback': 'ale_linters#nix#nix#Handle',
+\})

ale_linters/nroff/proselint.vim

@@ -0,0 +1,9 @@
+" Author: Daniel M. Capella https://github.com/polyzen
+" Description: proselint for nroff files
+
+call ale#linter#Define('nroff', {
+\   'name': 'proselint',
+\   'executable': 'proselint',
+\   'command': 'proselint %t',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/ocaml/merlin.vim

@@ -0,0 +1,19 @@
+" Author: Andrey Popp -- @andreypopp
+" Description: Report errors in OCaml code with Merlin
+
+if !exists('g:merlin')
+  finish
+endif
+
+function! ale_linters#ocaml#merlin#Handle(buffer, lines) abort
+  let l:errors = merlin#ErrorLocList()
+  return l:errors
+endfunction
+
+call ale#linter#Define('ocaml', {
+\   'name': 'merlin',
+\   'executable': 'ocamlmerlin',
+\   'command': 'true',
+\   'callback': 'ale_linters#ocaml#merlin#Handle',
+\})
+

ale_linters/perl/perl.vim

@@ -1,12 +1,23 @@
 " Author: Vincent Lequertier <https://github.com/SkySymbol>
 " Description: This file adds support for checking perl syntax
 
-if exists('g:loaded_ale_linters_perl_perlcritic')
-    finish
-endif
+let g:ale_perl_perl_executable =
+\   get(g:, 'ale_perl_perl_executable', 'perl')
 
-let g:loaded_ale_linters_perl_perl = 1
-function! ale_linters#perl#perl#Handle(buffer, lines)
+let g:ale_perl_perl_options =
+\   get(g:, 'ale_perl_perl_options', '-X -c -Mwarnings -Ilib')
+
+function! ale_linters#perl#perl#GetExecutable(buffer) abort
+    return g:ale_perl_perl_executable
+endfunction
+
+function! ale_linters#perl#perl#GetCommand(buffer) abort
+    return ale_linters#perl#perl#GetExecutable(a:buffer)
+    \   . ' ' . g:ale_perl_perl_options
+    \   . ' %t'
+endfunction
+
+function! ale_linters#perl#perl#Handle(buffer, lines) abort
     let l:pattern = '\(.\+\) at \(.\+\) line \(\d\+\)'
     let l:output = []
 
@@ -18,19 +29,14 @@ function! ale_linters#perl#perl#Handle(buffer, lines)
         endif
 
         let l:line = l:match[3]
-        let l:column = 1
         let l:text = l:match[1]
         let l:type = 'E'
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:line,
-        \   'vcol': 0,
-        \   'col': l:column,
         \   'text': l:text,
         \   'type': l:type,
-        \   'nr': -1,
         \})
     endfor
 
@@ -39,8 +45,8 @@ endfunction
 
 call ale#linter#Define('perl', {
 \   'name': 'perl',
-\   'executable': 'perl',
+\   'executable_callback': 'ale_linters#perl#perl#GetExecutable',
 \   'output_stream': 'both',
-\   'command': 'perl -X -c -Mwarnings -Ilib',
+\   'command_callback': 'ale_linters#perl#perl#GetCommand',
 \   'callback': 'ale_linters#perl#perl#Handle',
 \})

ale_linters/perl/perlcritic.vim

@@ -1,12 +1,7 @@
 " Author: Vincent Lequertier <https://github.com/SkySymbol>
 " Description: This file adds support for checking perl with perl critic
 
-if exists('g:loaded_ale_linters_perl_perlcritic')
-    finish
-endif
-
-let g:loaded_ale_linters_perl_perlcritic = 1
-function! ale_linters#perl#perlcritic#Handle(buffer, lines)
+function! ale_linters#perl#perlcritic#Handle(buffer, lines) abort
     let l:pattern = '\(.\+\) at \(.\+\) line \(\d\+\)'
     let l:output = []
 
@@ -18,19 +13,14 @@ function! ale_linters#perl#perlcritic#Handle(buffer, lines)
         endif
 
         let l:line = l:match[3]
-        let l:column = 1
         let l:text = l:match[1]
         let l:type = 'E'
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:line,
-        \   'vcol': 0,
-        \   'col': l:column,
         \   'text': l:text,
         \   'type': l:type,
-        \   'nr': -1,
         \})
     endfor
 
@@ -40,7 +30,7 @@ endfunction
 call ale#linter#Define('perl', {
 \   'name': 'perlcritic',
 \   'executable': 'perlcritic',
-\   'output_stream': 'sdtout',
+\   'output_stream': 'stdout',
 \   'command': 'perlcritic --verbose 3 --nocolor',
 \   'callback': 'ale_linters#perl#perlcritic#Handle',
 \})

ale_linters/php/hack.vim

@@ -0,0 +1,36 @@
+" Author: Zefei Xuan <https://github.com/zefei>
+" Description: Hack type checking (http://hacklang.org/)
+
+function! ale_linters#php#hack#Handle(buffer, lines) abort
+    let l:pattern = '^\(.*\):\(\d\+\):\(\d\+\),\(\d\+\): \(.\+])\)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        if a:buffer != bufnr(l:match[1])
+          continue
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'text': l:match[5],
+        \   'type': 'E',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('php', {
+\   'name': 'hack',
+\   'executable': 'hh_client',
+\   'command': 'hh_client --retries 0 --retry-if-init false',
+\   'callback': 'ale_linters#php#hack#Handle',
+\})

ale_linters/php/php.vim

@@ -1,17 +1,12 @@
-" Author: Spencer Wood <https://github.com/scwood>
+" Author: Spencer Wood <https://github.com/scwood>, Adriaan Zonnenberg <amz@adriaan.xyz>
 " Description: This file adds support for checking PHP with php-cli
 
-if exists('g:loaded_ale_linters_php_php')
-    finish
-endif
-
-let g:loaded_ale_linters_php_php = 1
-
-function! ale_linters#php#php#Handle(buffer, lines)
+function! ale_linters#php#php#Handle(buffer, lines) abort
     " Matches patterns like the following:
     "
-    " Parse error: parse error in - on line 7
-    let l:pattern = 'Parse error:\s\+\(.\+\) on line \(\d\+\)'
+    " PHP Parse error:  syntax error, unexpected ';', expecting ']' in - on line 15
+    let l:pattern = '\vPHP %(Fatal|Parse) error:\s+(.+unexpected ''(.+)%(expecting.+)@<!''.*|.+) in - on line (\d+)'
+
     let l:output = []
 
     for l:line in a:lines
@@ -21,15 +16,12 @@ function! ale_linters#php#php#Handle(buffer, lines)
             continue
         endif
 
-        " vcol is needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
-        \   'lnum': l:match[2] + 0,
-        \   'vcol': 0,
-        \   'col': 1,
+        \   'lnum': l:match[3] + 0,
+        \   'col': empty(l:match[2]) ? 0 : stridx(getline(l:match[3]), l:match[2]) + 1,
         \   'text': l:match[1],
         \   'type': 'E',
-        \   'nr': -1,
         \})
     endfor
 
@@ -40,6 +32,6 @@ call ale#linter#Define('php', {
 \   'name': 'php',
 \   'executable': 'php',
 \   'output_stream': 'both',
-\   'command': 'php -l --',
+\   'command': 'php -l -d display_errors=1 --',
 \   'callback': 'ale_linters#php#php#Handle',
 \})

ale_linters/php/phpcs.vim

@@ -1,13 +1,7 @@
 " Author: jwilliams108 <https://github.com/jwilliams108>
 " Description: phpcs for PHP files
 
-if exists('g:loaded_ale_linters_php_phpcs')
-    finish
-endif
-
-let g:loaded_ale_linters_php_phpcs = 1
-
-function! ale_linters#php#phpcs#GetCommand(buffer)
+function! ale_linters#php#phpcs#GetCommand(buffer) abort
     let l:command = 'phpcs -s --report=emacs --stdin-path=%s'
 
     " This option can be set to change the standard used by phpcs
@@ -18,7 +12,7 @@ function! ale_linters#php#phpcs#GetCommand(buffer)
     return l:command
 endfunction
 
-function! ale_linters#php#phpcs#Handle(buffer, lines)
+function! ale_linters#php#phpcs#Handle(buffer, lines) abort
     " Matches against lines like the following:
     "
     " /path/to/some-filename.php:18:3: error - Line indented incorrectly; expected 4 spaces, found 2 (Generic.WhiteSpace.ScopeIndent.IncorrectExact)
@@ -35,15 +29,12 @@ function! ale_linters#php#phpcs#Handle(buffer, lines)
         let l:text = l:match[4]
         let l:type = l:match[3]
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
-        \   'vcol': 0,
         \   'col': l:match[2] + 0,
         \   'text': l:text,
         \   'type': l:type ==# 'error' ? 'E' : 'W',
-        \   'nr': -1,
         \})
     endfor
 

ale_linters/php/phpmd.vim

@@ -0,0 +1,38 @@
+" Author: medains <https://github.com/medains>
+" Description: phpmd for PHP files
+
+" Set to change the ruleset
+let g:ale_php_phpmd_ruleset = get(g:, 'ale_php_phpmd_ruleset', 'cleancode,codesize,controversial,design,naming,unusedcode')
+
+function! ale_linters#php#phpmd#Handle(buffer, lines) abort
+    " Matches against lines like the following:
+    "
+    " /path/to/some-filename.php:18 message
+    let l:pattern = '^.*:\(\d\+\)\t\(.\+\)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[1] + 0,
+        \   'col': 0,
+        \   'text': l:match[2],
+        \   'type': 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('php', {
+\   'name': 'phpmd',
+\   'executable': 'phpmd',
+\   'command': 'phpmd %s text ' . g:ale_php_phpmd_ruleset . ' --ignore-violations-on-exit %t',
+\   'callback': 'ale_linters#php#phpmd#Handle',
+\})

ale_linters/pod/proselint.vim

@@ -0,0 +1,9 @@
+" Author: Daniel M. Capella https://github.com/polyzen
+" Description: proselint for Pod files
+
+call ale#linter#Define('pod', {
+\   'name': 'proselint',
+\   'executable': 'proselint',
+\   'command': 'proselint %t',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/pug/puglint.vim

@@ -1,16 +1,10 @@
 " Author: w0rp - <devw0rp@gmail.com>
 " Description: pug-lint for checking Pug/Jade files.
 
-if exists('g:loaded_ale_linters_pug_puglint')
-    finish
-endif
-
-let g:loaded_ale_linters_pug_puglint = 1
-
 call ale#linter#Define('pug', {
 \   'name': 'puglint',
 \   'executable': 'pug-lint',
 \   'output_stream': 'stderr',
-\   'command': g:ale#util#stdin_wrapper . ' .pug pug-lint -r inline',
+\   'command': 'pug-lint -r inline %t',
 \   'callback': 'ale#handlers#HandleUnixFormatAsError',
 \})

ale_linters/puppet/puppet.vim

@@ -0,0 +1,35 @@
+" Author: Alexander Olofsson <alexander.olofsson@liu.se>
+
+function! ale_linters#puppet#puppet#Handle(buffer, lines) abort
+    " Matches patterns like the following:
+    " Error: Could not parse for environment production: Syntax error at ':' at /root/puppetcode/modules/nginx/manifests/init.pp:43:12
+
+    let l:pattern = '^Error: .*: \(.\+\) at .\+:\(\d\+\):\(\d\+\)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'text': l:match[1],
+        \   'type': 'E',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('puppet', {
+\   'name': 'puppet',
+\   'executable': 'puppet',
+\   'output_stream': 'stderr',
+\   'command': 'puppet parser validate --color=false %t',
+\   'callback': 'ale_linters#puppet#puppet#Handle',
+\})

ale_linters/puppet/puppetlint.vim

@@ -0,0 +1,10 @@
+" Author: Alexander Olofsson <alexander.olofsson@liu.se>
+
+call ale#linter#Define('puppet', {
+\   'name': 'puppetlint',
+\   'executable': 'puppet-lint',
+\   'command': 'puppet-lint --no-autoloader_layout-check'
+\   .   ' --log-format "-:%{line}:%{column}: %{kind}: [%{check}] %{message}"'
+\   .   ' %t',
+\   'callback': 'ale#handlers#HandleGCCFormat',
+\})

ale_linters/pyrex/cython.vim

@@ -5,8 +5,6 @@ call ale#linter#Define('pyrex', {
 \   'name': 'cython',
 \   'output_stream': 'stderr',
 \   'executable': 'cython',
-\   'command': g:ale#util#stdin_wrapper
-\       . ' .pyx cython --warning-extra -o '
-\       . g:ale#util#nul_file,
+\   'command': 'cython --warning-extra -o ' . g:ale#util#nul_file . ' %t',
 \   'callback': 'ale#handlers#HandleUnixFormatAsError',
 \})

ale_linters/python/flake8.vim

@@ -1,55 +1,76 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: flake8 for python files
 
-if exists('g:loaded_ale_linters_python_flake8')
-    finish
-endif
+let g:ale_python_flake8_executable =
+\   get(g:, 'ale_python_flake8_executable', 'flake8')
 
-let g:loaded_ale_linters_python_flake8 = 1
+let g:ale_python_flake8_args =
+\   get(g:, 'ale_python_flake8_args', '')
 
-function! ale_linters#python#flake8#Handle(buffer, lines)
-    " Matches patterns line the following:
-    "
-    " stdin:6:6: E111 indentation is not a multiple of four
-    let l:pattern = '^stdin:\(\d\+\):\(\d\+\): \([^ ]\+\) \(.\+\)$'
-    let l:output = []
+" A map from Python executable paths to semver strings parsed for those
+" executables, so we don't have to look up the version number constantly.
+let s:version_cache = {}
 
-    for l:line in a:lines
-        let l:match = matchlist(l:line, l:pattern)
+function! ale_linters#python#flake8#GetExecutable(buffer) abort
+    return g:ale_python_flake8_executable
+endfunction
 
-        if len(l:match) == 0
-            continue
-        endif
+function! ale_linters#python#flake8#VersionCheck(buffer) abort
+    let l:executable = ale_linters#python#flake8#GetExecutable(a:buffer)
 
-        let l:line = l:match[1] + 0
-        let l:column = l:match[2] + 0
-        let l:code = l:match[3]
-        let l:text = l:code . ': ' . l:match[4]
-        let l:type = l:code[0] ==# 'E' ? 'E' : 'W'
+    " If we have previously stored the version number in a cache, then
+    " don't look it up again.
+    if has_key(s:version_cache, l:executable)
+        " Returning an empty string skips this command.
+        return ''
+    endif
 
-        if (l:code ==# 'W291' || l:code ==# 'W293') && !g:ale_warn_about_trailing_whitespace
-            " Skip warnings for trailing whitespace if the option is off.
-            continue
-        endif
+    return ale_linters#python#flake8#GetExecutable(a:buffer) . ' --version'
+endfunction
 
-        " vcol is Needed to indicate that the column is a character.
-        call add(l:output, {
-        \   'bufnr': a:buffer,
-        \   'lnum': l:line,
-        \   'vcol': 0,
-        \   'col': l:column,
-        \   'text': l:text,
-        \   'type': l:type,
-        \   'nr': -1,
-        \})
-    endfor
+" Get the flake8 version from the output, or the cache.
+function! s:GetVersion(buffer, version_output) abort
+    let l:executable = ale_linters#python#flake8#GetExecutable(a:buffer)
+    let l:version = []
 
-    return l:output
+    " Get the version from the cache.
+    if has_key(s:version_cache, l:executable)
+        return s:version_cache[l:executable]
+    endif
+
+    if !empty(a:version_output)
+        " Parse the version string, and store it in the cache.
+        let l:version = ale#semver#Parse(a:version_output[0])
+        let s:version_cache[l:executable] = l:version
+    endif
+
+    return l:version
+endfunction
+
+" flake8 versions 3 and up support the --stdin-display-name argument.
+function! s:SupportsDisplayName(version) abort
+    return !empty(a:version) && ale#semver#GreaterOrEqual(a:version, [3, 0, 0])
+endfunction
+
+function! ale_linters#python#flake8#GetCommand(buffer, version_output) abort
+    let l:version = s:GetVersion(a:buffer, a:version_output)
+
+    " Only include the --stdin-display-name argument if we can parse the
+    " flake8 version, and it is recent enough to support it.
+    let l:display_name_args = s:SupportsDisplayName(l:version)
+    \   ? '--stdin-display-name %s'
+    \   : ''
+
+    return ale_linters#python#flake8#GetExecutable(a:buffer)
+    \   . ' ' . g:ale_python_flake8_args . ' ' . l:display_name_args . ' -'
 endfunction
 
 call ale#linter#Define('python', {
 \   'name': 'flake8',
-\   'executable': 'flake8',
-\   'command': 'flake8 -',
-\   'callback': 'ale_linters#python#flake8#Handle',
+\   'executable_callback': 'ale_linters#python#flake8#GetExecutable',
+\   'command_chain': [
+\       {'callback': 'ale_linters#python#flake8#VersionCheck'},
+\       {'callback': 'ale_linters#python#flake8#GetCommand'},
+\   ],
+\   'callback': 'ale#handlers#HandlePEP8Format',
 \})

ale_linters/python/mypy.vim

@@ -0,0 +1,61 @@
+" Author: Keith Smiley <k@keith.so>, w0rp <devw0rp@gmail.com>
+" Description: mypy support for optional python typechecking
+
+let g:ale_python_mypy_options = get(g:, 'ale_python_mypy_options', '')
+
+function! g:ale_linters#python#mypy#GetCommand(buffer) abort
+    let l:automatic_stubs_dir = ale#util#FindNearestDirectory(a:buffer, 'stubs')
+    " TODO: Add Windows support
+    let l:automatic_stubs_command = (has('unix') && !empty(l:automatic_stubs_dir))
+    \   ?  'MYPYPATH=' . l:automatic_stubs_dir . ' '
+    \   : ''
+
+    return 'mypy --show-column-numbers '
+    \   . g:ale_python_mypy_options
+    \   . ' %t'
+endfunction
+
+let s:path_pattern = '[a-zA-Z]\?\\\?:\?[[:alnum:]/\.\-_]\+'
+
+function! g:ale_linters#python#mypy#Handle(buffer, lines) abort
+    " Look for lines like the following:
+    "
+    " file.py:4: error: No library stub file for module 'django.db'
+    "
+    " Lines like these should be ignored below:
+    "
+    " file.py:4: note: (Stub files are from https://github.com/python/typeshed)
+    let l:pattern = '^' . s:path_pattern . ':\(\d\+\):\?\(\d\+\)\?: \([^:]\+\): \(.\+\)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        if l:match[4] =~# 'Stub files are from'
+            " The lines telling us where to get stub files from make it so
+            " we can't read the actual errors, so exclude them.
+            continue
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:match[2] + 0,
+        \   'text': l:match[4],
+        \   'type': l:match[3] =~# 'error' ? 'E' : 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call g:ale#linter#Define('python', {
+\   'name': 'mypy',
+\   'executable': 'mypy',
+\   'command_callback': 'ale_linters#python#mypy#GetCommand',
+\   'callback': 'ale_linters#python#mypy#Handle',
+\})

ale_linters/python/pylint.vim

@@ -0,0 +1,26 @@
+" Author: keith <k@keith.so>
+" Description: pylint for python files
+
+let g:ale_python_pylint_executable =
+\   get(g:, 'ale_python_pylint_executable', 'pylint')
+
+let g:ale_python_pylint_options =
+\   get(g:, 'ale_python_pylint_options', '')
+
+function! ale_linters#python#pylint#GetExecutable(buffer) abort
+    return g:ale_python_pylint_executable
+endfunction
+
+function! ale_linters#python#pylint#GetCommand(buffer) abort
+    return ale_linters#python#pylint#GetExecutable(a:buffer)
+    \   . ' ' . g:ale_python_pylint_options
+    \   . ' --output-format text --msg-template="{path}:{line}:{column}: {msg_id} ({symbol}) {msg}" --reports n'
+    \   . ' %t'
+endfunction
+
+call ale#linter#Define('python', {
+\   'name': 'pylint',
+\   'executable_callback': 'ale_linters#python#pylint#GetExecutable',
+\   'command_callback': 'ale_linters#python#pylint#GetCommand',
+\   'callback': 'ale#handlers#HandlePEP8Format',
+\})

ale_linters/rst/proselint.vim

@@ -0,0 +1,9 @@
+" Author: Daniel M. Capella https://github.com/polyzen
+" Description: proselint for reStructuredText files
+
+call ale#linter#Define('rst', {
+\   'name': 'proselint',
+\   'executable': 'proselint',
+\   'command': 'proselint %t',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/ruby/rubocop.vim

@@ -1,18 +1,12 @@
 " Author: ynonp - https://github.com/ynonp
 " Description: rubocop for Ruby files
 
-if exists('g:loaded_ale_linters_ruby_rubocop')
-    finish
-endif
-
-let g:loaded_ale_linters_ruby_rubocop = 1
-
-function! ale_linters#ruby#rubocop#Handle(buffer, lines)
+function! ale_linters#ruby#rubocop#Handle(buffer, lines) abort
     " Matches patterns line the following:
     "
-    " <path>/_:47:14: 83:29: C: Prefer single-quoted strings when you don't
+    " <path>:83:29: C: Prefer single-quoted strings when you don't
     " need string interpolation or special symbols.
-    let l:pattern = '\v_:(\d+):(\d+): (.): (.+)'
+    let l:pattern = '\v:(\d+):(\d+): (.): (.+)'
     let l:output = []
 
     for l:line in a:lines
@@ -25,25 +19,33 @@ function! ale_linters#ruby#rubocop#Handle(buffer, lines)
         let l:text = l:match[4]
         let l:type = l:match[3]
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
-        \   'vcol': 0,
         \   'col': l:match[2] + 0,
         \   'text': l:text,
-        \   'type': l:type ==# 'C' ? 'E' : 'W',
-        \   'nr': -1,
+        \   'type': index(['C', 'E'], l:type) != -1 ? 'E' : 'W',
         \})
     endfor
 
     return l:output
 endfunction
 
+function! ale_linters#ruby#rubocop#GetCommand(buffer) abort
+  return 'rubocop --format emacs --force-exclusion ' .
+        \ g:ale_ruby_rubocop_options .
+        \ ' --stdin ' . bufname(a:buffer)
+endfunction
+
+" Set this option to change Rubocop options.
+if !exists('g:ale_ruby_rubocop_options')
+    " let g:ale_ruby_rubocop_options = '--lint'
+    let g:ale_ruby_rubocop_options = ''
+endif
+
 call ale#linter#Define('ruby', {
 \   'name': 'rubocop',
 \   'executable': 'rubocop',
-\   'command': 'rubocop --format emacs --stdin _',
+\   'command_callback': 'ale_linters#ruby#rubocop#GetCommand',
 \   'callback': 'ale_linters#ruby#rubocop#Handle',
 \})
-

ale_linters/rust/cargo.vim

@@ -0,0 +1,20 @@
+" Author: Daniel Schemala <istjanichtzufassen@gmail.com>
+" Description: rustc invoked by cargo for rust files
+
+function! ale_linters#rust#cargo#GetCargoExecutable(bufnr) abort
+    if ale#util#FindNearestFile(a:bufnr, 'Cargo.toml') !=# ''
+        return 'cargo'
+    else
+        " if there is no Cargo.toml file, we don't use cargo even if it exists,
+        " so we return '', because executable('') apparently always fails
+        return ''
+    endif
+endfunction
+
+call ale#linter#Define('rust', {
+\   'name': 'cargo',
+\   'executable_callback': 'ale_linters#rust#cargo#GetCargoExecutable',
+\   'command': 'cargo build --message-format=json -q',
+\   'callback': 'ale#handlers#rust#HandleRustErrors',
+\   'output_stream': 'stdout',
+\})

ale_linters/rust/rustc.vim

@@ -0,0 +1,27 @@
+" Author: Daniel Schemala <istjanichtzufassen@gmail.com>
+" Description: rustc for rust files
+
+function! ale_linters#rust#rustc#RustcCommand(buffer_number) abort
+    " Try to guess the library search path. If the project is managed by cargo,
+    " it's usually <project root>/target/debug/deps/ or
+    " <project root>/target/release/deps/
+    let l:cargo_file = ale#util#FindNearestFile(a:buffer_number, 'Cargo.toml')
+
+    if l:cargo_file !=# ''
+        let l:project_root = fnamemodify(l:cargo_file, ':h')
+        let l:dependencies = '-L ' . l:project_root . '/target/debug/deps -L ' .
+        \   l:project_root . '/target/release/deps'
+    else
+        let l:dependencies = ''
+    endif
+
+    return 'rustc --error-format=json -Z no-trans ' . l:dependencies . ' -'
+endfunction
+
+call ale#linter#Define('rust', {
+\   'name': 'rustc',
+\   'executable': 'rustc',
+\   'command_callback': 'ale_linters#rust#rustc#RustcCommand',
+\   'callback': 'ale#handlers#rust#HandleRustErrors',
+\   'output_stream': 'stderr',
+\})

ale_linters/sass/sasslint.vim

@@ -1,14 +1,8 @@
 " Author: KabbAmine - https://github.com/KabbAmine
 
-if exists('g:loaded_ale_linters_sass_sasslint')
-    finish
-endif
-
-let g:loaded_ale_linters_sass_sasslint = 1
-
 call ale#linter#Define('sass', {
 \   'name': 'sasslint',
 \   'executable': 'sass-lint',
-\   'command': g:ale#util#stdin_wrapper . ' .sass sass-lint -v -q -f compact',
+\   'command': 'sass-lint -v -q -f compact %t',
 \   'callback': 'ale#handlers#HandleCSSLintFormat',
 \})

ale_linters/sass/stylelint.vim

@@ -0,0 +1,31 @@
+" Author: diartyz <diartyz@gmail.com>
+
+let g:ale_sass_stylelint_executable =
+\   get(g:, 'ale_sass_stylelint_executable', 'stylelint')
+
+let g:ale_sass_stylelint_use_global =
+\   get(g:, 'ale_sass_stylelint_use_global', 0)
+
+function! ale_linters#sass#stylelint#GetExecutable(buffer) abort
+    if g:ale_sass_stylelint_use_global
+        return g:ale_sass_stylelint_executable
+    endif
+
+    return ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/stylelint',
+    \   g:ale_sass_stylelint_executable
+    \)
+endfunction
+
+function! ale_linters#sass#stylelint#GetCommand(buffer) abort
+    return ale_linters#sass#stylelint#GetExecutable(a:buffer)
+    \   . ' --stdin-filename %s'
+endfunction
+
+call ale#linter#Define('sass', {
+\   'name': 'stylelint',
+\   'executable_callback': 'ale_linters#sass#stylelint#GetExecutable',
+\   'command_callback': 'ale_linters#sass#stylelint#GetCommand',
+\   'callback': 'ale#handlers#HandleStyleLintFormat',
+\})

ale_linters/scala/scalac.vim

@@ -1,14 +1,7 @@
-" vim: set et:
 " Author: Zoltan Kalmar - https://github.com/kalmiz
 " Description: Basic scala support using scalac
 
-if exists('g:loaded_ale_linters_scala_scalac')
-    finish
-endif
-
-let g:loaded_ale_linters_scala_scalac = 1
-
-function! ale_linters#scala#scalac#Handle(buffer, lines)
+function! ale_linters#scala#scalac#Handle(buffer, lines) abort
     " Matches patterns line the following:
     "
     " /var/folders/5q/20rgxx3x1s34g3m14n5bq0x80000gn/T/vv6pSsy/0:26: error: expected class or object definition
@@ -27,22 +20,17 @@ function! ale_linters#scala#scalac#Handle(buffer, lines)
         let l:text = l:match[3]
         let l:type = l:match[2] ==# 'error' ? 'E' : 'W'
         let l:col = 0
+
         if l:ln + 1 < len(a:lines)
             let l:col = stridx(a:lines[l:ln + 1], '^')
-            if l:col == -1
-                let l:col = 0
-            endif
         endif
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
-        \   'vcol': 0,
         \   'col': l:col + 1,
         \   'text': l:text,
         \   'type': l:type,
-        \   'nr': -1,
         \})
     endfor
 
@@ -53,6 +41,6 @@ call ale#linter#Define('scala', {
 \   'name': 'scalac',
 \   'executable': 'scalac',
 \   'output_stream': 'stderr',
-\   'command': g:ale#util#stdin_wrapper . ' .scala scalac -Ystop-after:parser',
+\   'command': 'scalac -Ystop-after:parser %t',
 \   'callback': 'ale_linters#scala#scalac#Handle',
 \})

ale_linters/scss/sasslint.vim

@@ -1,14 +1,8 @@
 " Author: KabbAmine - https://github.com/KabbAmine
 
-if exists('g:loaded_ale_linters_scss_sasslint')
-    finish
-endif
-
-let g:loaded_ale_linters_scss_sasslint = 1
-
 call ale#linter#Define('scss', {
 \   'name': 'sasslint',
 \   'executable': 'sass-lint',
-\   'command': g:ale#util#stdin_wrapper . ' .scss sass-lint -v -q -f compact',
+\   'command': 'sass-lint -v -q -f compact %t',
 \   'callback': 'ale#handlers#HandleCSSLintFormat',
 \})

ale_linters/scss/scsslint.vim

@@ -1,13 +1,7 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: This file add scsslint support for SCSS support
 
-if exists('g:loaded_ale_linters_scss_scsslint')
-    finish
-endif
-
-let g:loaded_ale_linters_scss_scsslint = 1
-
-function! ale_linters#scss#scsslint#Handle(buffer, lines)
+function! ale_linters#scss#scsslint#Handle(buffer, lines) abort
     " Matches patterns like the following:
     "
     " test.scss:2:1 [W] Indentation: Line should be indented 2 spaces, but was indented 4 spaces
@@ -26,15 +20,12 @@ function! ale_linters#scss#scsslint#Handle(buffer, lines)
             continue
         endif
 
-        " vcol is needed to indicate that the column is a character
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
-        \   'vcol': 0,
         \   'col': l:match[2] + 0,
         \   'text': l:match[4],
         \   'type': l:match[3] ==# 'E' ? 'E' : 'W',
-        \   'nr': -1,
         \})
     endfor
 

ale_linters/scss/stylelint.vim

@@ -0,0 +1,31 @@
+" Author: diartyz <diartyz@gmail.com>
+
+let g:ale_scss_stylelint_executable =
+\   get(g:, 'ale_scss_stylelint_executable', 'stylelint')
+
+let g:ale_scss_stylelint_use_global =
+\   get(g:, 'ale_scss_stylelint_use_global', 0)
+
+function! ale_linters#scss#stylelint#GetExecutable(buffer) abort
+    if g:ale_scss_stylelint_use_global
+        return g:ale_scss_stylelint_executable
+    endif
+
+    return ale#util#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/stylelint',
+    \   g:ale_scss_stylelint_executable
+    \)
+endfunction
+
+function! ale_linters#scss#stylelint#GetCommand(buffer) abort
+    return ale_linters#scss#stylelint#GetExecutable(a:buffer)
+    \   . ' --stdin-filename %s'
+endfunction
+
+call ale#linter#Define('scss', {
+\   'name': 'stylelint',
+\   'executable_callback': 'ale_linters#scss#stylelint#GetExecutable',
+\   'command_callback': 'ale_linters#scss#stylelint#GetCommand',
+\   'callback': 'ale#handlers#HandleStyleLintFormat',
+\})

ale_linters/sh/shell.vim

@@ -1,12 +1,6 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: Lints sh files using bash -n
 
-if exists('g:loaded_ale_linters_sh_shell')
-    finish
-endif
-
-let g:loaded_ale_linters_sh_shell = 1
-
 " This option can be changed to change the default shell when the shell
 " cannot be taken from the hashbang line.
 if !exists('g:ale_linters_sh_shell_default_shell')
@@ -17,7 +11,7 @@ if !exists('g:ale_linters_sh_shell_default_shell')
     endif
 endif
 
-function! ale_linters#sh#shell#GetExecutable(buffer)
+function! ale_linters#sh#shell#GetExecutable(buffer) abort
     let l:banglines = getbufline(a:buffer, 1)
 
     " Take the shell executable from the hashbang, if we can.
@@ -35,16 +29,16 @@ function! ale_linters#sh#shell#GetExecutable(buffer)
     return g:ale_linters_sh_shell_default_shell
 endfunction
 
-function! ale_linters#sh#shell#GetCommand(buffer)
-    return ale_linters#sh#shell#GetExecutable(a:buffer) . ' -n'
+function! ale_linters#sh#shell#GetCommand(buffer) abort
+    return ale_linters#sh#shell#GetExecutable(a:buffer) . ' -n %t'
 endfunction
 
-function! ale_linters#sh#shell#Handle(buffer, lines)
+function! ale_linters#sh#shell#Handle(buffer, lines) abort
     " Matches patterns line the following:
     "
     " bash: line 13: syntax error near unexpected token `d'
     " sh: 11: Syntax error: "(" unexpected
-    let l:pattern = '^[^:]\+: \%(\w\+ \|\)\(\d\+\): \(.\+\)'
+    let l:pattern = '\v(line |: ?)(\d+): (.+)$'
     let l:output = []
 
     for l:line in a:lines
@@ -54,20 +48,15 @@ function! ale_linters#sh#shell#Handle(buffer, lines)
             continue
         endif
 
-        let l:line = l:match[1] + 0
-        let l:column = 1
-        let l:text = l:match[2]
+        let l:line = l:match[2] + 0
+        let l:text = l:match[3]
         let l:type = 'E'
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:line,
-        \   'vcol': 0,
-        \   'col': l:column,
         \   'text': l:text,
         \   'type': l:type,
-        \   'nr': -1,
         \})
     endfor
 

ale_linters/sh/shellcheck.vim

@@ -2,12 +2,6 @@
 " Description: This file adds support for using the shellcheck linter with
 "   shell scripts.
 
-if exists('g:loaded_ale_linters_sh_shellcheck')
-    finish
-endif
-
-let g:loaded_ale_linters_sh_shellcheck = 1
-
 " This global variable can be set with a string of comma-seperated error
 " codes to exclude from shellcheck. For example:
 "
@@ -22,9 +16,25 @@ else
     let s:exclude_option = ''
 endif
 
+function! s:GetDialectArgument() abort
+    if exists('b:is_bash') && b:is_bash
+        return '-s bash'
+    elseif exists('b:is_sh') && b:is_sh
+        return '-s sh'
+    elseif exists('b:is_kornshell') && b:is_kornshell
+        return '-s ksh'
+    endif
+
+    return ''
+endfunction
+
+function! ale_linters#sh#shellcheck#GetCommand(buffer) abort
+  return 'shellcheck ' . s:exclude_option . ' ' . s:GetDialectArgument() . ' -f gcc -'
+endfunction
+
 call ale#linter#Define('sh', {
 \   'name': 'shellcheck',
 \   'executable': 'shellcheck',
-\   'command': 'shellcheck ' . s:exclude_option . ' -f gcc -',
+\   'command_callback': 'ale_linters#sh#shellcheck#GetCommand',
 \   'callback': 'ale#handlers#HandleGCCFormat',
 \})

ale_linters/slim/slimlint.vim

@@ -0,0 +1,33 @@
+" Author: Markus Doits - https://github.com/doits
+" Description: slim-lint for Slim files, based on hamllint.vim
+
+function! ale_linters#slim#slimlint#Handle(buffer, lines) abort
+    " Matches patterns like the following:
+    " <path>:5 [W] LineLength: Line is too long. [150/120]
+    let l:pattern = '\v^.*:(\d+) \[([EW])\] (.+)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[1] + 0,
+        \   'type': l:match[2],
+        \   'text': l:match[3]
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('slim', {
+\   'name': 'slimlint',
+\   'executable': 'slim-lint',
+\   'command': 'slim-lint %t',
+\   'callback': 'ale_linters#slim#slimlint#Handle'
+\})

ale_linters/sml/smlnj.vim

@@ -0,0 +1,39 @@
+" Author: Paulo Alem    <paulo.alem@gmail.com>
+" Description: Rudimentary SML checking with smlnj compiler
+
+if exists('g:loaded_ale_sml_smlnj_checker')
+    finish
+endif
+
+let g:loaded_ale_sml_smlnj_checker = 1
+
+function! ale_linters#sml#smlnj#Handle(buffer, lines) abort
+    " Try to match basic sml errors
+
+    let l:out = []
+    let l:pattern = '^.*\:\([0-9\.]\+\)\ \(\w\+\)\:\ \(.*\)'
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        call add(l:out, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[1] + 0,
+        \   'text': l:match[2] . ': ' . l:match[3],
+        \   'type': l:match[2] ==# 'error' ? 'E' : 'W',
+        \})
+    endfor
+
+    return l:out
+endfunction
+
+call g:ale#linter#Define('sml', {
+\   'name': 'smlnj',
+\   'executable': 'sml',
+\   'command': 'sml',
+\   'callback': 'ale_linters#sml#smlnj#Handle',
+\})

ale_linters/swift/swiftlint.vim

@@ -0,0 +1,9 @@
+" Author: David Mohundro <david@mohundro.com>
+" Description: swiftlint for swift files
+
+call ale#linter#Define('swift', {
+\   'name': 'swiftlint',
+\   'executable': 'swiftlint',
+\   'command': 'swiftlint lint --use-stdin',
+\   'callback': 'ale#handlers#HandleGCCFormat',
+\})

ale_linters/testft/testlinter.vim

@@ -0,0 +1,10 @@
+" Author: neersighted <bjorn@neersighted.com>
+" Description: dummy linter to use in tests
+
+call ale#linter#Define('testft', {
+\   'name': 'testlinter',
+\   'output_stream': 'stdout',
+\   'executable': 'testlinter',
+\   'command': 'testlinter',
+\   'callback': 'testCB',
+\})

ale_linters/tex/chktex.vim

@@ -0,0 +1,61 @@
+" Author: Andrew Balmos - <andrew@balmos.org>
+" Description: chktex for LaTeX files
+
+let g:ale_tex_chktex_executable =
+\   get(g:, 'ale_tex_chktex_executable', 'chktex')
+
+let g:ale_tex_chktex_options =
+\   get(g:, 'ale_tex_chktex_options', '-I')
+
+function! ale_linters#tex#chktex#GetCommand(buffer) abort
+  " Check for optional .chktexrc
+  let l:chktex_config = ale#util#FindNearestFile(
+  \   a:buffer,
+  \   '.chktexrc')
+
+  let l:command = g:ale_tex_chktex_executable
+  " Avoid bug when used without -p (last warning has gibberish for a filename)
+  let l:command .= ' -v0 -p stdin -q'
+
+  if !empty(l:chktex_config)
+    let l:command .= ' -l ' . fnameescape(l:chktex_config)
+  endif
+
+  let l:command .= ' ' . g:ale_tex_chktex_options
+
+  return l:command
+endfunction
+
+function! ale_linters#tex#chktex#Handle(buffer, lines) abort
+  " Mattes lines like:
+  "
+  " stdin:499:2:24:Delete this space to maintain correct pagereferences.
+  " stdin:507:81:3:You should enclose the previous parenthesis with `{}'.
+  let l:pattern = '^stdin:\(\d\+\):\(\d\+\):\(\d\+\):\(.\+\)$'
+  let l:output = []
+
+  for l:line in a:lines
+    let l:match = matchlist(l:line, l:pattern)
+
+    if len(l:match) == 0
+      continue
+    endif
+
+    call add(l:output, {
+    \   'bufnr': a:buffer,
+    \   'lnum': l:match[1] + 0,
+    \   'col': l:match[2] + 0,
+    \   'text': l:match[4] . ' (' . (l:match[3]+0) . ')',
+    \   'type': 'W',
+    \})
+  endfor
+
+  return l:output
+endfunction
+
+call ale#linter#Define('tex', {
+\   'name': 'chktex',
+\   'executable': 'chktex',
+\   'command_callback': 'ale_linters#tex#chktex#GetCommand',
+\   'callback': 'ale_linters#tex#chktex#Handle'
+\})

ale_linters/tex/lacheck.vim

@@ -0,0 +1,55 @@
+" Author: Andrew Balmos - <andrew@balmos.org>
+" Description: lacheck for LaTeX files
+
+let g:ale_tex_lacheck_executable =
+\   get(g:, 'ale_tex_lacheck_executable', 'lacheck')
+
+function! ale_linters#tex#lacheck#GetExecutable(buffer) abort
+    return g:ale_tex_lacheck_executable
+endfunction
+
+function! ale_linters#tex#lacheck#GetCommand(buffer) abort
+    return g:ale_tex_lacheck_executable . ' %t'
+endfunction
+
+function! ale_linters#tex#lacheck#Handle(buffer, lines) abort
+  " Mattes lines like:
+  "
+  " "book.tex", line 37: possible unwanted space at "{"
+  " "book.tex", line 38: missing `\ ' after "etc."
+
+  let l:pattern = '^".\+", line \(\d\+\): \(.\+\)$'
+  let l:output = []
+
+  for l:line in a:lines
+    let l:match = matchlist(l:line, l:pattern)
+
+    if len(l:match) == 0
+      continue
+    endif
+
+    " lacheck follows `\input{}` commands. If the cwd is not the same as the
+    " file in the buffer then it will fail to find the inputed items. We do not
+    " want warnings from those items anyway
+    if !empty(matchstr(l:match[2], '^Could not open ".\+"$'))
+      continue
+    endif
+
+    call add(l:output, {
+    \   'bufnr': a:buffer,
+    \   'lnum': l:match[1] + 0,
+    \   'col': 0,
+    \   'text': l:match[2],
+    \   'type': 'W',
+    \})
+  endfor
+
+  return l:output
+endfunction
+
+call ale#linter#Define('tex', {
+\   'name': 'lacheck',
+\   'executable_callback': 'ale_linters#tex#lacheck#GetExecutable',
+\   'command_callback': 'ale_linters#tex#lacheck#GetCommand',
+\   'callback': 'ale_linters#tex#lacheck#Handle'
+\})

ale_linters/tex/proselint.vim

@@ -0,0 +1,9 @@
+" Author: poohzrn https://github.com/poohzrn
+" Description: proselint for TeX files
+
+call ale#linter#Define('tex', {
+\   'name': 'proselint',
+\   'executable': 'proselint',
+\   'command': 'proselint %t',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/texinfo/proselint.vim

@@ -0,0 +1,9 @@
+" Author: Daniel M. Capella https://github.com/polyzen
+" Description: proselint for Texinfo files
+
+call ale#linter#Define('texinfo', {
+\   'name': 'proselint',
+\   'executable': 'proselint',
+\   'command': 'proselint %t',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/text/proselint.vim

@@ -0,0 +1,9 @@
+" Author: poohzrn https://github.com/poohzrn
+" Description: proselint for text files
+
+call ale#linter#Define('text', {
+\   'name': 'proselint',
+\   'executable': 'proselint',
+\   'command': 'proselint %t',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/typescript/tslint.vim

@@ -1,19 +1,28 @@
 " Author: Prashanth Chandra https://github.com/prashcr
 " Description: tslint for TypeScript files
 
-if exists('g:loaded_ale_linters_typescript_tslint')
-    finish
-endif
+let g:ale_typescript_tslint_executable =
+\   get(g:, 'ale_typescript_tslint_executable', 'tslint')
 
-let g:loaded_ale_linters_typescript_tslint = 1
+let g:ale_typescript_tslint_config_path =
+\   get(g:, 'ale_typescript_tslint_config_path', '')
 
-function! ale_linters#typescript#tslint#Handle(buffer, lines)
+function! ale_linters#typescript#tslint#GetExecutable(buffer) abort
+  return ale#util#ResolveLocalPath(
+  \   a:buffer,
+  \   'node_modules/.bin/tslint',
+  \   g:ale_typescript_tslint_executable
+  \)
+endfunction
+
+function! ale_linters#typescript#tslint#Handle(buffer, lines) abort
     " Matches patterns like the following:
     "
     " hello.ts[7, 41]: trailing whitespace
     " hello.ts[5, 1]: Forbidden 'var' keyword, use 'let' or 'const' instead
     "
-    let l:pattern = '.\+.ts\[\(\d\+\), \(\d\+\)\]: \(.\+\)'
+    let l:ext = '.' . fnamemodify(bufname(a:buffer), ':e')
+    let l:pattern = '.\+' . l:ext . '\[\(\d\+\), \(\d\+\)\]: \(.\+\)'
     let l:output = []
 
     for l:line in a:lines
@@ -28,24 +37,37 @@ function! ale_linters#typescript#tslint#Handle(buffer, lines)
         let l:type = 'E'
         let l:text = l:match[3]
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:line,
-        \   'vcol': 0,
         \   'col': l:column,
         \   'text': l:text,
         \   'type': l:type,
-        \   'nr': -1,
         \})
     endfor
 
     return l:output
 endfunction
 
+function! ale_linters#typescript#tslint#BuildLintCommand(buffer) abort
+  let g:ale_typescript_tslint_config_path = 
+  \   empty(g:ale_typescript_tslint_config_path) ? 
+  \         ale#util#FindNearestFile(a:buffer, 'tslint.json') 
+  \         : g:ale_typescript_tslint_config_path
+
+  let l:tslint_options = 
+  \   empty(g:ale_typescript_tslint_config_path) ? 
+  \         '' 
+  \         : '-c ' . fnameescape(g:ale_typescript_tslint_config_path)
+
+  return ale_linters#typescript#tslint#GetExecutable(a:buffer)
+  \   . ' ' . l:tslint_options
+  \   . ' %t'
+endfunction
+
 call ale#linter#Define('typescript', {
 \   'name': 'tslint',
-\   'executable': 'tslint',
-\   'command': g:ale#util#stdin_wrapper . ' .ts tslint',
+\   'executable_callback': 'ale_linters#typescript#tslint#GetExecutable',
+\   'command_callback': 'ale_linters#typescript#tslint#BuildLintCommand',
 \   'callback': 'ale_linters#typescript#tslint#Handle',
 \})

ale_linters/typescript/typecheck.vim

@@ -0,0 +1,42 @@
+" Author: Prashanth Chandra https://github.com/prashcr, Aleh Kashnikau https://github.com/mkusher
+" Description: type checker for TypeScript files
+
+function! ale_linters#typescript#typecheck#Handle(buffer, lines) abort
+    " Matches patterns like the following:
+    "
+    " hello.ts[7, 41]: Property 'a' does not exist on type 'A'
+    " hello.ts[16, 7]: Type 'A' is not assignable to type 'B'
+    "
+    let l:pattern = '.\+\.ts\[\(\d\+\), \(\d\+\)\]: \(.\+\)'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        let l:line = l:match[1] + 0
+        let l:column = l:match[2] + 0
+        let l:type = 'E'
+        let l:text = l:match[3]
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:line,
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('typescript', {
+\   'name': 'typecheck',
+\   'executable': 'typecheck',
+\   'command': 'typecheck %s',
+\   'callback': 'ale_linters#typescript#typecheck#Handle',
+\})

ale_linters/verilog/iverilog.vim

@@ -1,13 +1,7 @@
 " Author: Masahiro H https://github.com/mshr-h
 " Description: iverilog for verilog files
 
-if exists('g:loaded_ale_linters_verilog_iverilog')
-    finish
-endif
-
-let g:loaded_ale_linters_verilog_iverilog = 1
-
-function! ale_linters#verilog#iverilog#Handle(buffer, lines)
+function! ale_linters#verilog#iverilog#Handle(buffer, lines) abort
     " Look for lines like the following.
     "
     " tb_me_top.v:37: warning: Instantiating module me_top with dangling input port 1 (rst_n) floating.
@@ -31,11 +25,8 @@ function! ale_linters#verilog#iverilog#Handle(buffer, lines)
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:line,
-        \   'vcol': 0,
-        \   'col': 1,
         \   'text': l:text,
         \   'type': l:type,
-        \   'nr': -1,
         \})
     endfor
 
@@ -46,6 +37,6 @@ call ale#linter#Define('verilog', {
 \   'name': 'iverilog',
 \   'output_stream': 'stderr',
 \   'executable': 'iverilog',
-\   'command': g:ale#util#stdin_wrapper . ' .v iverilog -t null -Wall',
+\   'command': 'iverilog -t null -Wall %t',
 \   'callback': 'ale_linters#verilog#iverilog#Handle',
 \})

ale_linters/verilog/verilator.vim

@@ -1,13 +1,17 @@
 " Author: Masahiro H https://github.com/mshr-h
 " Description: verilator for verilog files
 
-if exists('g:loaded_ale_linters_verilog_verilator')
-    finish
-endif
+function! ale_linters#verilog#verilator#GetCommand(buffer) abort
+    let l:filename = tempname() . '_verilator_linted.v'
 
-let g:loaded_ale_linters_verilog_verilator = 1
+    " Create a special filename, so we can detect it in the handler.
+    call ale#engine#ManageFile(a:buffer, l:filename)
+    call writefile(getbufline(a:buffer, 1, '$'), l:filename)
 
-function! ale_linters#verilog#verilator#Handle(buffer, lines)
+    return 'verilator --lint-only -Wall -Wno-DECLFILENAME ' . fnameescape(l:filename)
+endfunction
+
+function! ale_linters#verilog#verilator#Handle(buffer, lines) abort
     " Look for lines like the following.
     "
     " %Error: addr_gen.v:3: syntax error, unexpected IDENTIFIER
@@ -16,7 +20,7 @@ function! ale_linters#verilog#verilator#Handle(buffer, lines)
     " %Warning-UNDRIVEN: test.v:3: Signal is not driven: clk
     " %Warning-UNUSED: test.v:4: Signal is not used: dout
     " %Warning-BLKSEQ: test.v:10: Blocking assignments (=) in sequential (flop or latch) block; suggest delayed assignments (<=).
-    let l:pattern = '^%\(Warning\|Error\)[^:]*:[^:]\+:\(\d\+\): \(.\+\)$'
+    let l:pattern = '^%\(Warning\|Error\)[^:]*:\([^:]\+\):\(\d\+\): \(.\+\)$'
     let l:output = []
 
     for l:line in a:lines
@@ -26,19 +30,19 @@ function! ale_linters#verilog#verilator#Handle(buffer, lines)
             continue
         endif
 
-        let l:line = l:match[2] + 0
+        let l:line = l:match[3] + 0
         let l:type = l:match[1] ==# 'Error' ? 'E' : 'W'
-        let l:text = l:match[3]
+        let l:text = l:match[4]
+        let l:file = l:match[2]
 
-        call add(l:output, {
-        \   'bufnr': a:buffer,
-        \   'lnum': l:line,
-        \   'vcol': 0,
-        \   'col': 1,
-        \   'text': l:text,
-        \   'type': l:type,
-        \   'nr': -1,
-        \})
+        if l:file =~# '_verilator_linted.v'
+            call add(l:output, {
+            \   'bufnr': a:buffer,
+            \   'lnum': l:line,
+            \   'text': l:text,
+            \   'type': l:type,
+            \})
+        endif
     endfor
 
     return l:output
@@ -48,6 +52,7 @@ call ale#linter#Define('verilog', {
 \   'name': 'verilator',
 \   'output_stream': 'stderr',
 \   'executable': 'verilator',
-\   'command': g:ale#util#stdin_wrapper . ' .v verilator --lint-only -Wall -Wno-DECLFILENAME',
+\   'command_callback': 'ale_linters#verilog#verilator#GetCommand',
 \   'callback': 'ale_linters#verilog#verilator#Handle',
+\   'read_buffer': 0,
 \})

ale_linters/vim/vint.vim

@@ -1,26 +1,24 @@
 " Author: w0rp <devw0rp@gmail.com>, KabbAmine <amine.kabb@gmail.com>
 " Description: This file adds support for checking Vim code with Vint.
 
-if exists('g:loaded_ale_linters_vim_vint')
-    finish
-endif
-
-let g:loaded_ale_linters_vim_vint = 1
-
 " This flag can be used to change enable/disable style issues.
 let g:ale_vim_vint_show_style_issues =
 \   get(g:, 'ale_vim_vint_show_style_issues', 1)
 
 let s:warning_flag = g:ale_vim_vint_show_style_issues ? '-s' : '-w'
+let s:vint_version = ale#semver#Parse(system('vint --version'))
+let s:has_no_color_support = ale#semver#GreaterOrEqual(s:vint_version, [0, 3, 7])
+let s:enable_neovim = has('nvim') ? ' --enable-neovim ' : ''
 let s:format = '-f "{file_path}:{line_number}:{column_number}: {severity}: {description} (see {reference})"'
 
 call ale#linter#Define('vim', {
 \   'name': 'vint',
 \   'executable': 'vint',
-\   'command': g:ale#util#stdin_wrapper
-\       . ' .vim vint '
-\       . s:warning_flag
-\       . ' --no-color '
-\       . s:format,
+\   'command': 'vint '
+\       . s:warning_flag . ' '
+\       . (s:has_no_color_support ? '--no-color ' : '')
+\       . s:enable_neovim
+\       . s:format
+\       . ' %t',
 \   'callback': 'ale#handlers#HandleGCCFormat',
 \})

ale_linters/xhtml/proselint.vim

@@ -0,0 +1,9 @@
+" Author: Daniel M. Capella https://github.com/polyzen
+" Description: proselint for XHTML files
+
+call ale#linter#Define('xhtml', {
+\   'name': 'proselint',
+\   'executable': 'proselint',
+\   'command': 'proselint %t',
+\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\})

ale_linters/yaml/yamllint.vim

@@ -1,12 +1,22 @@
 " Author: KabbAmine <amine.kabb@gmail.com>
 
-if exists('g:loaded_ale_linters_yaml_yamllint')
-    finish
-endif
+let g:ale_yaml_yamllint_executable =
+\   get(g:, 'ale_yaml_yamllint_executable', 'yamllint')
 
-let g:loaded_ale_linters_yaml_yamllint = 1
+let g:ale_yaml_yamllint_options =
+\   get(g:, 'ale_yaml_yamllint_options', '')
 
-function! ale_linters#yaml#yamllint#Handle(buffer, lines)
+function! ale_linters#yaml#yamllint#GetExecutable(buffer) abort
+    return g:ale_yaml_yamllint_executable
+endfunction
+
+function! ale_linters#yaml#yamllint#GetCommand(buffer) abort
+    return ale_linters#yaml#yamllint#GetExecutable(a:buffer)
+    \   . ' ' . g:ale_yaml_yamllint_options
+    \   . ' -f parsable %t'
+endfunction
+
+function! ale_linters#yaml#yamllint#Handle(buffer, lines) abort
     " Matches patterns line the following:
     " something.yaml:1:1: [warning] missing document start "---" (document-start)
     " something.yml:2:1: [error] syntax error: expected the node content, but found '<stream end>'
@@ -25,15 +35,12 @@ function! ale_linters#yaml#yamllint#Handle(buffer, lines)
         let l:type = l:match[3]
         let l:text = l:match[4]
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:line,
-        \   'vcol': 0,
         \   'col': l:col,
         \   'text': l:text,
         \   'type': l:type ==# 'error' ? 'E' : 'W',
-        \   'nr': -1,
         \})
     endfor
 
@@ -42,7 +49,7 @@ endfunction
 
 call ale#linter#Define('yaml', {
 \   'name': 'yamllint',
-\   'executable': 'yamllint',
-\   'command': g:ale#util#stdin_wrapper . ' .yml yamllint -f parsable',
+\   'executable_callback': 'ale_linters#yaml#yamllint#GetExecutable',
+\   'command_callback': 'ale_linters#yaml#yamllint#GetCommand',
 \   'callback': 'ale_linters#yaml#yamllint#Handle',
 \})

autoload/ale.vim

@@ -3,8 +3,41 @@
 "   Manages execution of linters when requested by autocommands
 
 let s:lint_timer = -1
+let s:should_lint_file_for_buffer = {}
+
+" A function for checking various conditions whereby ALE just shouldn't
+" attempt to do anything, say if particular buffer types are open in Vim.
+function! ale#ShouldDoNothing() abort
+    " Do nothing for blacklisted files
+    " OR if ALE is running in the sandbox
+    return index(g:ale_filetype_blacklist, &filetype) >= 0
+    \   || (exists('*getcmdwintype') && !empty(getcmdwintype()))
+    \   || ale#util#InSandbox()
+endfunction
+
+" (delay, [linting_flag])
+function! ale#Queue(delay, ...) abort
+    if len(a:0) > 1
+        throw 'too many arguments!'
+    endif
+
+    " Default linting_flag to ''
+    let l:linting_flag = get(a:000, 0, '')
+
+    if l:linting_flag !=# '' && l:linting_flag !=# 'lint_file'
+        throw "linting_flag must be either '' or 'lint_file'"
+    endif
+
+    if ale#ShouldDoNothing()
+        return
+    endif
+
+    " Remember that we want to check files for this buffer.
+    " We will remember this until we finally run the linters, via any event.
+    if l:linting_flag ==# 'lint_file'
+        let s:should_lint_file_for_buffer[bufnr('%')] = 1
+    endif
 
-function! ale#Queue(delay) abort
     if s:lint_timer != -1
         call timer_stop(s:lint_timer)
         let s:lint_timer = -1
@@ -24,25 +57,42 @@ function! ale#Queue(delay) abort
 endfunction
 
 function! ale#Lint(...) abort
+    if ale#ShouldDoNothing()
+        return
+    endif
+
     let l:buffer = bufnr('%')
     let l:linters = ale#linter#Get(&filetype)
+    let l:should_lint_file = 0
 
-    " Set a variable telling us to clear the loclist later.
-    let g:ale_buffer_should_reset_map[l:buffer] = 1
+    " Check if we previously requested checking the file.
+    if has_key(s:should_lint_file_for_buffer, l:buffer)
+        unlet s:should_lint_file_for_buffer[l:buffer]
+        let l:should_lint_file = 1
+    endif
+
+    " Initialise the buffer information if needed.
+    call ale#engine#InitBufferInfo(l:buffer)
+
+    " Clear the new loclist again, so we will work with all new items.
+    let g:ale_buffer_info[l:buffer].new_loclist = []
+
+    if l:should_lint_file
+        " Clear loclist items for files if we are checking files again.
+        let g:ale_buffer_info[l:buffer].lint_file_loclist = []
+    else
+        " Otherwise, don't run any `lint_file` linters
+        " We will continue running any linters which are currently checking
+        " the file, and the items will be mixed together with any new items.
+        call filter(l:linters, '!v:val.lint_file')
+    endif
 
     for l:linter in l:linters
-        " Check if a given linter has a program which can be executed.
-        if has_key(l:linter, 'executable_callback')
-            let l:executable = ale#util#GetFunction(l:linter.executable_callback)(l:buffer)
-        else
-            let l:executable = l:linter.executable
-        endif
-
-        if !executable(l:executable)
-            " The linter's program cannot be executed, so skip it.
-            continue
-        endif
-
         call ale#engine#Invoke(l:buffer, l:linter)
     endfor
 endfunction
+
+" Reset flags indicating that files should be checked for all buffers.
+function! ale#ResetLintFileMarkers() abort
+    let s:should_lint_file_for_buffer = {}
+endfunction