Remove style classification from E999 (#696)

* Remove style classification from E999

* Update test_flake8_handler to reflect E999 changes

.eslintrc.js

@@ -1,11 +0,0 @@
-module.exports = {
-    parserOptions: {
-        ecmaVersion: 6,
-        sourceType: "module",
-    },
-    rules: {
-        semi: 'error',
-        'space-infix-ops': 'warn',
-        radix: 'error',
-    }
-}

.gitattributes

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

.gitignore

@@ -2,3 +2,4 @@
 /doc/tags
 .*
 *.obj
+tags

.travis.yml

@@ -7,4 +7,4 @@ branches:
         - master
 language: python
 script: |
-    make test
+    ./run-tests

CODE_OF_CONDUCT.md

@@ -0,0 +1,3 @@
+Codes of conduct are totally unnecessary and dumb.
+
+Just don't be a jerk and have fun.

CONTRIBUTING.md

@@ -5,13 +5,24 @@
 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-linter-options)
+5. [In Case of Busses](#in-case-of-busses)
 
 <a name="guidelines"></a>
 
-# 1. Guidelines
+## 1. Guidelines
 
 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
@@ -20,7 +31,7 @@ will check your code while you type.
 
 <a name="issues"></a>
 
-# 2. Creating Issues
+## 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
@@ -41,7 +52,7 @@ can understand you.
 
 <a name="pull-requests"></a>
 
-# 3. 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
@@ -60,7 +71,7 @@ If you want to credit multiple authors, you can comma separate them.
 
 <a name="adding-a-new-linter"></a>
 
-# 3.i. Adding a New Linter
+### 3.i. Adding a New Linter
 
 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
@@ -76,7 +87,7 @@ alphabetically in the table and list.
 
 <a name="adding-new-options"></a>
 
-# 3.ii. Adding New Options
+### 3.ii. Adding New Options
 
 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).
@@ -90,3 +101,73 @@ global variable names.
 
 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...`.
+
+<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.

Dockerfile

@@ -1,20 +1,18 @@
 FROM tweekmonster/vim-testbed:latest
 
-RUN install_vim -tag v8.0.0000 -build \
-                -tag v8.0.0027 -build
+RUN install_vim -tag v8.0.0027 -build \
+                -tag neovim:v0.1.7 -build
 
 ENV PACKAGES="\
+    bash \
     git \
-    python=2.7.12-r0 \
-    py-pip=8.1.2-r0 \
-    nodejs \
+    python \
+    py-pip \
 "
 RUN apk --update add $PACKAGES && \
     rm -rf /var/cache/apk/* /tmp/* /var/tmp/*
 
 RUN pip install vim-vint==0.3.9
 
-RUN npm install -g eslint@3.7.1
-
 RUN git clone https://github.com/junegunn/vader.vim vader && \
     cd vader && git checkout c6243dd81c98350df4dec608fa972df98fa2a3af

ISSUE_TEMPLATE.md

@@ -0,0 +1,12 @@
+<!--
+READ THIS FIRST: If you are experiencing any bug whatsoever dealing with
+the output of linters, please use `let g:ale_history_log_output = 1` before
+pasting output. It will capture the output of commands that are run.
+
+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.
+
+Whatever the case, describe the your issue here.
+-->

Makefile

@@ -1,44 +0,0 @@
-SHELL := /usr/bin/env bash
-IMAGE ?= w0rp/ale
-CURRENT_IMAGE_ID = 107e4efc4267
-DOCKER_FLAGS = --rm -v $(PWD):/testplugin -v $(PWD)/test:/home "$(IMAGE)"
-
-test-setup:
-	docker images -q w0rp/ale | grep ^$(CURRENT_IMAGE_ID) > /dev/null || \
-		docker pull $(IMAGE)
-
-test: 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; \
-	EXIT=0; \
-	for vim in $$vims; do \
-		echo; \
-		echo '========================================'; \
-		echo "Running tests for $$vim"; \
-		echo '========================================'; \
-		echo; \
-		docker run -a stderr $(DOCKER_FLAGS) $$vim '+Vader! test/*' || EXIT=$$?; \
-	done; \
-	echo; \
-	echo '========================================'; \
-	echo 'Running Vint to lint our code'; \
-	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;
-
-.DEFAULT_GOAL := test

PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,17 @@
+<!--
+When creating new pull requests, please consider the following.
+
+* Read the Contributing guide linked above first.
+* If you are adding a new linter, remember to update the README.md file and
+  doc/ale.txt first.
+* If you add or modify a function for converting error lines into loclist items
+  that ALE can work with, please add Vader tests for them. Look at existing
+  tests in the test/handler directory, etc.
+* If you add or modify a function for computing a command line string for
+  running a command, please add Vader tests for that.
+* Generally try and cover anything with Vader tests, although some things just
+  can't be tested with Vader, or at least they can be hard to test. Consider
+  breaking up your code so that some parts can be tested, and generally open up
+  a discussion about it.
+* Have fun!
+-->

README.md

@@ -15,6 +15,9 @@ back to a filesystem.
 
 In other words, this plugin allows you to lint while you type.
 
+ALE also supports fixing problems with files by running commands in the
+background with a command `ALEFix`.
+
 ## Table of Contents
 
 1. [Supported Languages and Tools](#supported-languages)
@@ -23,9 +26,10 @@ In other words, this plugin allows you to lint while you type.
     1. [Installation with Pathogen](#installation-with-pathogen)
     2. [Installation with Vundle](#installation-with-vundle)
     3. [Manual Installation](#manual-installation)
-4. [FAQ](#faq)
+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)
+    2. [How can I keep the sign gutter open?](#faq-keep-signs)
     3. [How can I change the signs ALE uses?](#faq-change-signs)
     4. [How can I show errors or warnings in my statusline?](#faq-statusline)
     5. [How can I change the format for echo messages?](#faq-echo-format)
@@ -33,6 +37,8 @@ In other words, this plugin allows you to lint while you type.
     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>
 
@@ -49,57 +55,77 @@ name. That seems to be the fairest way to arrange this table.
 
 | Language | Tools |
 | -------- | ----- |
+| ASM | [gcc](https://gcc.gnu.org) |
 | Ansible | [ansible-lint](https://github.com/willthames/ansible-lint) |
+| AsciiDoc | [proselint](http://proselint.com/)|
+| Awk | [gawk](https://www.gnu.org/software/gawk/)|
 | 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 | [cppcheck](http://cppcheck.sourceforge.net), [gcc](https://gcc.gnu.org/), [clang](http://clang.llvm.org/)|
-| C++ (filetype cpp) | [cppcheck] (http://cppcheck.sourceforge.net), [gcc](https://gcc.gnu.org/)|
+| C++ (filetype cpp) | [clang](http://clang.llvm.org/), [clangcheck](http://clang.llvm.org/docs/ClangCheck.html), [clangtidy](http://clang.llvm.org/extra/clang-tidy/), [cppcheck](http://cppcheck.sourceforge.net), [cpplint](https://github.com/google/styleguide/tree/gh-pages/cpplint), [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) |
+| Crystal | [crystal](https://crystal-lang.org/) |
 | 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) |
 | Dockerfile | [hadolint](https://github.com/lukasmartinelli/hadolint) |
-| Elixir | [credo](https://github.com/rrrene/credo) |
+| Elixir | [credo](https://github.com/rrrene/credo), [dogma](https://github.com/lpil/dogma) |
 | Elm | [elm-make](https://github.com/elm-lang/elm-make) |
+| Erb | [erb](https://github.com/jeremyevans/erubi) |
 | 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), [go build](https://golang.org/cmd/go/) |
-| 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/), [flow](https://flowtype.org/) |
+| FusionScript | [fusion-lint](https://github.com/RyanSquared/fusionscript) |
+| Go | [gofmt -e](https://golang.org/cmd/gofmt/), [go vet](https://golang.org/cmd/vet/), [golint](https://godoc.org/github.com/golang/lint), [gometalinter](https://github.com/alecthomas/gometalinter), [go build](https://golang.org/cmd/go/), [gosimple](https://github.com/dominikh/go-tools/tree/master/cmd/gosimple), [staticcheck](https://github.com/dominikh/go-tools/tree/master/cmd/staticcheck) |
+| Haml | [haml-lint](https://github.com/brigade/haml-lint)
+| Handlebars | [ember-template-lint](https://github.com/rwjblue/ember-template-lint) |
+| Haskell | [ghc](https://www.haskell.org/ghc/), [ghc-mod](https://github.com/DanielG/ghc-mod), [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 | [checkstyle](http://checkstyle.sourceforge.net), [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/), [prettier](https://github.com/prettier/prettier) (and `prettier-eslint`), [xo](https://github.com/sindresorhus/xo)
 | JSON | [jsonlint](http://zaa.ch/jsonlint/) |
-| LaTeX | [chktex](http://www.nongnu.org/chktex/), [lacheck](https://www.ctan.org/pkg/lacheck) |
+| Kotlin | [kotlinc](https://kotlinlang.org), [ktlint](https://ktlint.github.io) see `:help ale-integration-kotlin` for configuration instructions
+| LaTeX | [chktex](http://www.nongnu.org/chktex/), [lacheck](https://www.ctan.org/pkg/lacheck), [proselint](http://proselint.com/) |
 | Lua | [luacheck](https://github.com/mpeterv/luacheck) |
-| Markdown | [mdl](https://github.com/mivok/markdownlint), [proselint](http://proselint.com/)|
+| Markdown | [mdl](https://github.com/mivok/markdownlint), [proselint](http://proselint.com/), [vale](https://github.com/ValeLint/vale) |
 | 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/)|
+| Objective-C | [clang](http://clang.llvm.org/) |
+| Objective-C++ | [clang](http://clang.llvm.org/) |
 | 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 | [hack](http://hacklang.org/), [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) |
 | 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/) |
-| Ruby | [rubocop](https://github.com/bbatsov/rubocop) |
+| Python | [autopep8](https://github.com/hhatto/autopep8), [flake8](http://flake8.pycqa.org/en/latest/), [isort](https://github.com/timothycrosley/isort), [mypy](http://mypy-lang.org/), [pylint](https://www.pylint.org/), [yapf](https://github.com/google/yapf) |
+| ReasonML | [merlin](https://github.com/the-lambda-church/merlin) see `:help ale-integration-reason-merlin` for configuration instructions
+| reStructuredText | [proselint](http://proselint.com/)|
+| RPM spec | [rpmlint](https://github.com/rpm-software-management/rpmlint) (disabled by default; see `:help ale-integration-spec`) |
+| Ruby | [brakeman](http://brakemanscanner.org/), [reek](https://github.com/troessner/reek), [rubocop](https://github.com/bbatsov/rubocop), [ruby](https://www.ruby-lang.org) |
 | 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) |
+| Slim | [slim-lint](https://github.com/sds/slim-lint)
+| SML | [smlnj](http://www.smlnj.org/) |
+| SQL | [sqlint](https://github.com/purcell/sqlint) |
 | Swift | [swiftlint](https://swift.org/) |
-| Tex | [proselint](http://proselint.com/) |
-| Text^^ | [proselint](http://proselint.com/) |
-| TypeScript | [tslint](https://github.com/palantir/tslint), typecheck |
+| Texinfo | [proselint](http://proselint.com/)|
+| Text^ | [proselint](http://proselint.com/), [vale](https://github.com/ValeLint/vale) |
+| TypeScript | [eslint](http://eslint.org/), [tslint](https://github.com/palantir/tslint), tsserver, 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/)|
+| XML | [xmllint](http://xmlsoft.org/xmllint.html/)|
 | YAML | [yamllint](https://yamllint.readthedocs.io/) |
 
-* *^^ No text linters 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 it.
+* *^ No linters for text or Vim help filetypes are enabled by default.*
 
 <a name="usage"></a>
 
@@ -117,6 +143,9 @@ 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.
 
+ALE can fix files with the `ALEFix` command. Functions need to be configured
+for different filetypes with the `g:ale_fixers` variable. See `:help ale-fix`.
+
 <a name="installation"></a>
 
 ## 3. Installation
@@ -189,13 +218,30 @@ 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.
+
+If you'd liked to discuss the project more directly, check out the `#vim-ale` channel
+on Freenode. Web chat is available [here](https://webchat.freenode.net/?channels=vim-ale).
+
 <a name="faq"></a>
 
-## 4. FAQ
+## 5. FAQ
 
 <a name="faq-disable-linters"></a>
 
-### 4.i. How do I disable particular linters?
+### 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
@@ -219,7 +265,7 @@ in each directory corresponds to the name of a particular linter.
 
 <a name="faq-keep-signs"></a>
 
-### 4.ii. How can I keep the sign gutter open?
+### 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
@@ -230,7 +276,7 @@ let g:ale_sign_column_always = 1
 
 <a name="faq-change-signs"></a>
 
-### 4.iii. How can I change the signs ALE uses?
+### 5.iii. How can I change the signs ALE uses?
 
 Use these options to specify what text should be used for signs:
 
@@ -250,34 +296,47 @@ highlight clear ALEWarningSign
 
 <a name="faq-statusline"></a>
 
-### 4.iv. How can I show errors or warnings in my statusline?
+### 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
+[vim-airline](https://github.com/vim-airline/vim-airline) integrates with ALE
+for displaying error information in the status bar. If you want to see the
+status for ALE in a nice format, it is recommended to use vim-airline with ALE.
+The airline extension can be enabled by adding the following to your vimrc:
 
 ```vim
-%{ALEGetStatusLine()}
+" Set this. Airline will handle the rest.
+let g:airline#extensions#ale#enabled = 1
 ```
 
-When errors are detected a string showing the number of errors will be shown.
-You can customize the output format using the global list `g:ale_statusline_format` where:
+If you don't want to use vim-airline, you can implement your own statusline
+function without adding any other plugins. ALE provides a function for counting
+the number of problems for this purpose, named `ale#statusline#Count`.
 
-- The 1st element is for errors
-- The 2nd element is for warnings
-- The 3rd element is for when no errors are detected
-
-e.g
+Say you want to display all errors as one figure, and all non-errors as another
+figure. You can do the following:
 
 ```vim
-let g:ale_statusline_format = ['⨉ %d', '⚠ %d', '⬥ ok']
+function! LinterStatus() abort
+    let l:counts = ale#statusline#Count(bufnr(''))
+
+    let l:all_errors = l:counts.error + l:counts.style_error
+    let l:all_non_errors = l:counts.total - l:all_errors
+
+    return l:counts.total == 0 ? 'OK' : printf(
+    \   '%dW %dE',
+    \   all_non_errors,
+    \   all_errors
+    \)
+endfunction
+
+set statusline=%{LinterStatus()}
 ```
 
-![Statusline with issues](img/issues.png)
-![Statusline with no issues](img/no_issues.png)
+See `:help ale#statusline#Count()` for more information.
 
 <a name="faq-echo-format"></a>
 
-### 4.v. How can I change the format for echo messages?
+### 5.v. How can I change the format for echo messages?
 
 There are 3 global options that allow customizing the echoed message.
 
@@ -302,7 +361,7 @@ Will give you:
 
 <a name="faq-autocmd"></a>
 
-### 4.vi. How can I execute some code when ALE stops linting?
+### 5.vi. How can I execute some code when ALE stops linting?
 
 ALE runs its own [autocmd](http://vimdoc.sourceforge.net/htmldoc/autocmd.html)
 event whenever has a linter has been successfully executed and processed. This
@@ -317,7 +376,7 @@ augroup END
 
 <a name="faq-navigation"></a>
 
-### 4.vii. How can I navigate between errors quickly?
+### 5.vii. How can I navigate between errors quickly?
 
 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
@@ -333,25 +392,27 @@ For more information, consult the online documentation with
 
 <a name="faq-lint-on-save"></a>
 
-### 4.viii. How can I run linters only when I save files?
+### 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.
+when files are saved. This option is enabled by default. If you only
+wish to run linters when files are saved, you can turn the other
+options off.
 
 ```vim
 " Write this in your vimrc file
-let g:ale_lint_on_save = 1
-let g:ale_lint_on_text_changed = 0
+let g:ale_lint_on_text_changed = 'never'
 " 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
 ```
 
+If for whatever reason you don't wish to run linters again when you save
+files, you can set `g:ale_lint_on_save` to `0`.
+
 <a name="faq-quickfix"></a>
 
-### 4.ix. How can I use the quickfix list instead of the loclist?
+### 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
@@ -375,3 +436,61 @@ let g:ale_open_list = 1
 " 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
+[stylelint-processor-styled-components](https://github.com/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 `never` or `normal`. 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
+`:ALELint`.

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

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

ale_linters/ansible/ansible_lint.vim

@@ -0,0 +1,48 @@
+" Author: Bjorn Neergaard <bjorn@neersighted.com>
+" Description: ansible-lint for ansible-yaml files
+
+function! ale_linters#ansible#ansible_lint#Handle(buffer, lines) abort
+    for l:line in a:lines[:10]
+        if match(l:line, '^Traceback') >= 0
+            return [{
+            \   'lnum': 1,
+            \   'text': 'An exception was thrown. See :ALEDetail',
+            \   'detail': join(a:lines, "\n"),
+            \}]
+        endif
+    endfor
+
+    " Matches patterns line the following:
+    "
+    " test.yml:35: [EANSIBLE0002] Trailing whitespace
+    let l:pattern = '\v^[a-zA-Z]?:?[^:]+:(\d+):?(\d+)?: \[?([[:alnum:]]+)\]? (.*)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:code = l:match[3]
+
+        if (l:code ==# 'EANSIBLE002')
+        \ && !ale#Var(a:buffer, 'warn_about_trailing_whitespace')
+            " Skip warnings for trailing whitespace if the option is off.
+            continue
+        endif
+
+        let l:item = {
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:match[2] + 0,
+        \   'text': l:code . ': ' . l:match[4],
+        \   'type': l:code[:0] ==# 'E' ? 'E' : 'W',
+        \}
+
+        call add(l:output, l:item)
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('ansible', {
+\   'name': 'ansible',
+\   'executable': 'ansible',
+\   'command': 'ansible-lint -p %t',
+\   'callback': 'ale_linters#ansible#ansible_lint#Handle',
+\})

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#unix#HandleAsWarning',
+\})

ale_linters/asm/gcc.vim

@@ -0,0 +1,33 @@
+" Author: Lucas Kolstad <lkolstad@uw.edu>
+" Description: gcc linter for asm files
+
+let g:ale_asm_gcc_options = get(g:, 'ale_asm_gcc_options', '-Wall')
+
+function! ale_linters#asm#gcc#GetCommand(buffer) abort
+    return 'gcc -x assembler -fsyntax-only '
+    \    . '-iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \    . ' ' . ale#Var(a:buffer, 'asm_gcc_options') . ' -'
+endfunction
+
+function! ale_linters#asm#gcc#Handle(buffer, lines) abort
+    let l:pattern = '^.\+:\(\d\+\): \([^:]\+\): \(.\+\)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \ 'lnum': l:match[1] + 0,
+        \ 'type': l:match[2] =~? 'error' ? 'E' : 'W',
+        \ 'text': l:match[3],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('asm', {
+\    'name': 'gcc',
+\    'output_stream': 'stderr',
+\    'executable': 'gcc',
+\    'command_callback': 'ale_linters#asm#gcc#GetCommand',
+\    'callback': 'ale_linters#asm#gcc#Handle',
+\})

ale_linters/awk/gawk.vim

@@ -0,0 +1,26 @@
+" Author: kmarc <korondi.mark@gmail.com>
+" Description: This file adds support for using GNU awk with sripts.
+
+let g:ale_awk_gawk_executable =
+\   get(g:, 'ale_awk_gawk_executable', 'gawk')
+
+let g:ale_awk_gawk_options =
+\   get(g:, 'ale_awk_gawk_options', '')
+
+function! ale_linters#awk#gawk#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'awk_gawk_executable')
+endfunction
+
+function! ale_linters#awk#gawk#GetCommand(buffer) abort
+    return ale_linters#awk#gawk#GetExecutable(a:buffer)
+    \   . ' ' . ale#Var(a:buffer, 'awk_gawk_options')
+    \   . ' ' . '-f %t --lint /dev/null'
+endfunction
+
+call ale#linter#Define('awk', {
+\   'name': 'gawk',
+\   'executable_callback': 'ale_linters#awk#gawk#GetExecutable',
+\   'command_callback': 'ale_linters#awk#gawk#GetCommand',
+\   'callback': 'ale#handlers#cpplint#HandleCppLintFormat',
+\   'output_stream': 'both'
+\})

ale_linters/c/clang.vim

@@ -9,12 +9,21 @@ if !exists('g:ale_c_clang_options')
     let g:ale_c_clang_options = '-std=c11 -Wall'
 endif
 
+function! ale_linters#c#clang#GetCommand(buffer) abort
+    let l:paths = ale#c#FindLocalHeaderPaths(a:buffer)
+
+    " -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 ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h')) . ' '
+    \   . ale#c#IncludeOptions(l:paths)
+    \   . ale#Var(a:buffer, 'c_clang_options') . ' -'
+endfunction
+
 call ale#linter#Define('c', {
 \   'name': 'clang',
 \   'output_stream': 'stderr',
 \   'executable': 'clang',
-\   'command': 'clang -S -x c -fsyntax-only '
-\       . g:ale_c_clang_options
-\       . ' -',
-\   'callback': 'ale#handlers#HandleGCCFormat',
+\   'command_callback': 'ale_linters#c#clang#GetCommand',
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \})

ale_linters/c/cppcheck.vim

@@ -2,15 +2,33 @@
 " Description: cppcheck linter for c files
 
 " Set this option to change the cppcheck options
-if !exists('g:ale_c_cppcheck_options')
-    let g:ale_c_cppcheck_options = '--enable=style'
-endif
+let g:ale_c_cppcheck_options = get(g:, 'ale_c_cppcheck_options', '--enable=style')
+
+function! ale_linters#c#cppcheck#GetCommand(buffer) abort
+    " Search upwards from the file for compile_commands.json.
+    "
+    " If we find it, we'll `cd` to where the compile_commands.json file is,
+    " then use the file to set up import paths, etc.
+    let l:compile_commmands_path = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    let l:cd_command = !empty(l:compile_commmands_path)
+    \   ? ale#path#CdString(fnamemodify(l:compile_commmands_path, ':h'))
+    \   : ''
+    let l:compile_commands_option = !empty(l:compile_commmands_path)
+    \   ? '--project=compile_commands.json '
+    \   : ''
+
+    return l:cd_command
+    \   . 'cppcheck -q --language=c '
+    \   . l:compile_commands_option
+    \   . ale#Var(a:buffer, 'c_cppcheck_options')
+    \   . ' %t'
+endfunction
 
 call ale#linter#Define('c', {
 \   'name': 'cppcheck',
 \   'output_stream': 'both',
 \   'executable': 'cppcheck',
-\   'command': g:ale#util#stdin_wrapper . ' .c cppcheck -q --language=c '
-\       . g:ale_c_cppcheck_options,
-\   'callback': 'ale#handlers#HandleCppCheckFormat',
+\   'command_callback': 'ale_linters#c#cppcheck#GetCommand',
+\   'callback': 'ale#handlers#cppcheck#HandleCppCheckFormat',
 \})

ale_linters/c/gcc.vim

@@ -10,9 +10,14 @@ if !exists('g:ale_c_gcc_options')
 endif
 
 function! ale_linters#c#gcc#GetCommand(buffer) abort
-    return 'gcc -S -x c -fsyntax-only '
-    \      . g:ale_c_gcc_options . ' -'
+    let l:paths = ale#c#FindLocalHeaderPaths(a:buffer)
 
+    " -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 ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h')) . ' '
+    \   . ale#c#IncludeOptions(l:paths)
+    \   . ale#Var(a:buffer, 'c_gcc_options') . ' -'
 endfunction
 
 call ale#linter#Define('c', {
@@ -20,5 +25,5 @@ call ale#linter#Define('c', {
 \   'output_stream': 'stderr',
 \   'executable': 'gcc',
 \   'command_callback': 'ale_linters#c#gcc#GetCommand',
-\   'callback': 'ale#handlers#HandleGCCFormat',
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \})

ale_linters/chef/foodcritic.vim

@@ -1,6 +1,11 @@
 " Author: Edward Larkey <edwlarkey@mac.com>
+" Author: Jose Junior <jose.junior@gmail.com>
 " Description: This file adds the foodcritic linter for Chef files.
 
+" Support options!
+let g:ale_chef_foodcritic_options = get(g:, 'ale_chef_foodcritic_options', '')
+let g:ale_chef_foodcritic_executable = get(g:, 'ale_chef_foodcritic_executable', 'foodcritic')
+
 function! ale_linters#chef#foodcritic#Handle(buffer, lines) abort
     " Matches patterns line the following:
     "
@@ -8,34 +13,30 @@ function! ale_linters#chef#foodcritic#Handle(buffer, lines) abort
     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
-
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         let l:text = l:match[1]
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
-        \   'bufnr': a:buffer,
         \   'lnum': l:match[3] + 0,
-        \   'vcol': 0,
-        \   'col': 0,
         \   'text': l:text,
         \   'type': 'W',
-        \   'nr': -1,
         \})
     endfor
 
     return l:output
 endfunction
 
+function! ale_linters#chef#foodcritic#GetCommand(buffer) abort
+    return printf('%s %s %%t',
+    \   ale#Var(a:buffer, 'chef_foodcritic_executable'),
+    \   escape(ale#Var(a:buffer, 'chef_foodcritic_options'), '~')
+    \)
+endfunction
+
+
 call ale#linter#Define('chef', {
 \   'name': 'foodcritic',
 \   'executable': 'foodcritic',
-\   'command': g:ale#util#stdin_wrapper . ' .rb foodcritic',
+\   'command_callback': 'ale_linters#chef#foodcritic#GetCommand',
 \   '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 ale#Var(a:buffer, 'cmake_cmakelint_executable')
+endfunction
+
+function! ale_linters#cmake#cmakelint#Command(buffer) abort
+    return ale_linters#cmake#cmakelint#Executable(a:buffer)
+    \   . ' ' . ale#Var(a:buffer, '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#unix#HandleAsWarning',
+\})

ale_linters/coffee/coffee.vim

@@ -1,10 +1,23 @@
 " Author: KabbAmine - https://github.com/KabbAmine
 " Description: Coffee for checking coffee files
 
+function! ale_linters#coffee#coffee#GetExecutable(buffer) abort
+    return ale#path#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/coffee',
+    \   'coffee'
+    \)
+endfunction
+
+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',
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \})

ale_linters/coffee/coffeelint.vim

@@ -1,6 +1,19 @@
 " Author: Prashanth Chandra https://github.com/prashcr
 " Description: coffeelint linter for coffeescript files
 
+function! ale_linters#coffee#coffeelint#GetExecutable(buffer) abort
+    return ale#path#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/coffeelint',
+    \   'coffeelint'
+    \)
+endfunction
+
+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) abort
     " Matches patterns like the following:
     "
@@ -8,30 +21,14 @@ function! ale_linters#coffee#coffeelint#Handle(buffer, lines) abort
     " 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
-        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 = 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
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         call add(l:output, {
-        \   'bufnr': a:buffer,
-        \   'lnum': l:line,
-        \   'vcol': 0,
-        \   'col': l:column,
-        \   'text': l:text,
-        \   'type': l:type,
-        \   'nr': -1,
+        \   'lnum': str2nr(l:match[1]),
+        \   'type': l:match[3] ==# 'error' ? 'E' : 'W',
+        \   'text': l:match[4],
         \})
     endfor
 
@@ -40,7 +37,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,26 @@
+" 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
+    let l:paths = ale#c#FindLocalHeaderPaths(a:buffer)
+
+    " -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 ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h')) . ' '
+    \   . ale#c#IncludeOptions(l:paths)
+    \   . ale#Var(a:buffer, '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#gcc#HandleGCCFormat',
+\})

ale_linters/cpp/clangcheck.vim

@@ -0,0 +1,37 @@
+" Author: gagbo <gagbobada@gmail.com>
+" Description: clang-check linter for cpp files
+
+" Set this option to manually set some options for clang-check.
+let g:ale_cpp_clangcheck_options = get(g:, 'ale_cpp_clangcheck_options', '')
+
+" Set this option to manually point to the build directory for clang-tidy.
+" This will disable all the other clangtidy_options, since compilation
+" flags are contained in the json
+let g:ale_c_build_dir = get(g:, 'ale_c_build_dir', '')
+
+function! ale_linters#cpp#clangcheck#GetCommand(buffer) abort
+    let l:user_options = ale#Var(a:buffer, 'cpp_clangcheck_options')
+    let l:extra_options = !empty(l:user_options)
+    \   ? l:user_options
+    \   : ''
+
+    " Try to find compilation database to link automatically
+    let l:user_build_dir = ale#Var(a:buffer, 'c_build_dir')
+    if empty(l:user_build_dir)
+        let l:user_build_dir = ale#c#FindCompileCommands(a:buffer)
+    endif
+    let l:build_options = !empty(l:user_build_dir)
+    \   ? ' -p ' . ale#Escape(l:user_build_dir)
+    \   : ''
+
+    return 'clang-check -analyze ' . '%s' . l:extra_options . l:build_options
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'clangcheck',
+\   'output_stream': 'stderr',
+\   'executable': 'clang-check',
+\   'command_callback': 'ale_linters#cpp#clangcheck#GetCommand',
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})

ale_linters/cpp/clangtidy.vim

@@ -0,0 +1,53 @@
+" Author: vdeurzen <tim@kompiler.org>, w0rp <devw0rp@gmail.com>,
+" gagbo <gagbobada@gmail.com>
+" Description: clang-tidy linter for cpp files
+
+" Set this option to check the checks clang-tidy will apply.
+let g:ale_cpp_clangtidy_checks = get(g:, 'ale_cpp_clangtidy_checks', ['*'])
+
+" Set this option to manually set some options for clang-tidy.
+" This will disable compile_commands.json detection.
+let g:ale_cpp_clangtidy_options = get(g:, 'ale_cpp_clangtidy_options', '')
+
+" Set this option to manually point to the build directory for clang-tidy.
+" This will disable all the other clangtidy_options, since compilation
+" flags are contained in the json
+let g:ale_c_build_dir = get(g:, 'ale_c_build_dir', '')
+
+
+function! ale_linters#cpp#clangtidy#GetCommand(buffer) abort
+    let l:check_list = ale#Var(a:buffer, 'cpp_clangtidy_checks')
+    let l:check_option = !empty(l:check_list)
+    \   ? '-checks=' . ale#Escape(join(l:check_list, ',')) . ' '
+    \   : ''
+    let l:user_options = ale#Var(a:buffer, 'cpp_clangtidy_options')
+    let l:user_build_dir = ale#Var(a:buffer, 'c_build_dir')
+
+    " c_build_dir has the priority if defined
+    if empty(l:user_build_dir)
+        let l:user_build_dir = ale#c#FindCompileCommands(a:buffer)
+    endif
+
+    " We check again if user_builddir stayed empty after the
+    " c_build_dir_names check
+    " If we found the compilation database we override the value of
+    " l:extra_options
+    if empty(l:user_build_dir)
+        let l:extra_options = !empty(l:user_options)
+        \   ? ' -- ' . l:user_options
+        \   : ''
+    else
+        let l:extra_options = ' -p ' . ale#Escape(l:user_build_dir)
+    endif
+
+    return 'clang-tidy ' . l:check_option . '%s' . l:extra_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#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})

ale_linters/cpp/cppcheck.vim

@@ -2,15 +2,33 @@
 " Description: cppcheck linter for cpp files
 
 " Set this option to change the cppcheck options
-if !exists('g:ale_cpp_cppcheck_options')
-    let g:ale_cpp_cppcheck_options = '--enable=style'
-endif
+let g:ale_cpp_cppcheck_options = get(g:, 'ale_cpp_cppcheck_options', '--enable=style')
+
+function! ale_linters#cpp#cppcheck#GetCommand(buffer) abort
+    " Search upwards from the file for compile_commands.json.
+    "
+    " If we find it, we'll `cd` to where the compile_commands.json file is,
+    " then use the file to set up import paths, etc.
+    let l:compile_commmands_path = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    let l:cd_command = !empty(l:compile_commmands_path)
+    \   ? ale#path#CdString(fnamemodify(l:compile_commmands_path, ':h'))
+    \   : ''
+    let l:compile_commands_option = !empty(l:compile_commmands_path)
+    \   ? '--project=compile_commands.json '
+    \   : ''
+
+    return l:cd_command
+    \   . 'cppcheck -q --language=c++ '
+    \   . l:compile_commands_option
+    \   . ale#Var(a:buffer, 'cpp_cppcheck_options')
+    \   . ' %t'
+endfunction
 
 call ale#linter#Define('cpp', {
 \   'name': 'cppcheck',
 \   'output_stream': 'both',
 \   'executable': 'cppcheck',
-\   'command': g:ale#util#stdin_wrapper . ' .cpp cppcheck -q --language=c++ '
-\       . g:ale_cpp_cppcheck_options,
-\   'callback': 'ale#handlers#HandleCppCheckFormat',
+\   'command_callback': 'ale_linters#cpp#cppcheck#GetCommand',
+\   'callback': 'ale#handlers#cppcheck#HandleCppCheckFormat',
 \})

ale_linters/cpp/cpplint.vim

@@ -0,0 +1,15 @@
+" Author: Dawid Kurek https://github.com/dawikur
+" Description: cpplint for cpp files
+
+if !exists('g:ale_cpp_cpplint_options')
+    let g:ale_cpp_cpplint_options = ''
+endif
+
+call ale#linter#Define('cpp', {
+\   'name': 'cpplint',
+\   'output_stream': 'stderr',
+\   'executable': 'cpplint',
+\   'command': 'cpplint %s',
+\   'callback': 'ale#handlers#cpplint#HandleCppLintFormat',
+\   'lint_file': 1,
+\})

ale_linters/cpp/gcc.vim

@@ -3,22 +3,28 @@
 
 " Set this option to change the GCC options for warnings for C.
 if !exists('g:ale_cpp_gcc_options')
-  " 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 s:version = ale#handlers#gcc#ParseGCCVersion(systemlist('gcc --version'))
+
+    if !empty(s:version) && ale#semver#GreaterOrEqual(s:version, [4, 9, 0])
+        " Use c++14 support in 4.9 and above.
         let g:ale_cpp_gcc_options = '-std=c++14 -Wall'
+    else
+        " Use c++1y in older versions.
+        let g:ale_cpp_gcc_options = '-std=c++1y -Wall'
+    endif
+
+    unlet! s:version
 endif
 
 function! ale_linters#cpp#gcc#GetCommand(buffer) abort
-    return 'gcc -S -x c++ -fsyntax-only '
-    \      . g:ale_cpp_gcc_options . ' -'
+    let l:paths = ale#c#FindLocalHeaderPaths(a:buffer)
 
+    " -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 ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h')) . ' '
+    \   . ale#c#IncludeOptions(l:paths)
+    \   . ale#Var(a:buffer, 'cpp_gcc_options') . ' -'
 endfunction
 
 call ale#linter#Define('cpp', {
@@ -26,5 +32,5 @@ call ale#linter#Define('cpp', {
 \   'output_stream': 'stderr',
 \   'executable': 'g++',
 \   'command_callback': 'ale_linters#cpp#gcc#GetCommand',
-\   'callback': 'ale#handlers#HandleGCCFormat',
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \})

ale_linters/crystal/crystal.vim

@@ -0,0 +1,41 @@
+" Author: Jordan Andree <https://github.com/jordanandree>, David Alexander <opensource@thelonelyghost.com>
+" Description: This file adds support for checking Crystal with crystal build
+
+function! ale_linters#crystal#crystal#Handle(buffer, lines) abort
+    let l:output = []
+
+    let l:lines = join(a:lines, '')
+
+    if !empty(l:lines)
+      let l:errors = json_decode(l:lines)
+
+      for l:error in l:errors
+          call add(l:output, {
+          \   'bufnr': a:buffer,
+          \   'lnum': l:error.line + 0,
+          \   'col': l:error.column + 0,
+          \   'text': l:error.message,
+          \   'type': 'E',
+          \})
+      endfor
+    endif
+
+    return l:output
+endfunction
+
+function! ale_linters#crystal#crystal#GetCommand(buffer) abort
+    let l:crystal_cmd = 'crystal build -f json --no-codegen --no-color -o '
+    let l:crystal_cmd .= ale#Escape(g:ale#util#nul_file)
+    let l:crystal_cmd .= ' %s'
+
+    return l:crystal_cmd
+endfunction
+
+call ale#linter#Define('crystal', {
+\   'name': 'crystal',
+\   'executable': 'crystal',
+\   'output_stream': 'both',
+\   'lint_file': 1,
+\   'command_callback': 'ale_linters#crystal#crystal#GetCommand',
+\   'callback': 'ale_linters#crystal#crystal#Handle',
+\})

ale_linters/cs/mcs.vim

@@ -1,6 +1,8 @@
-if !exists('g:ale_cs_mcs_options')
-    let g:ale_cs_mcs_options = ''
-endif
+let g:ale_cs_mcs_options = get(g:, 'ale_cs_mcs_options', '')
+
+function! ale_linters#cs#mcs#GetCommand(buffer) abort
+    return 'mcs -unsafe --parse ' . ale#Var(a:buffer, 'cs_mcs_options') . ' %t'
+endfunction
 
 function! ale_linters#cs#mcs#Handle(buffer, lines) abort
     " Look for lines like the following.
@@ -9,21 +11,12 @@ function! ale_linters#cs#mcs#Handle(buffer, lines) abort
     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
-
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         call add(l:output, {
-        \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
-        \   'vcol': 0,
         \   'col': l:match[2] + 0,
         \   'text': l:match[3] . ': ' . l:match[4],
         \   'type': l:match[3] =~# '^error' ? 'E' : 'W',
-        \   'nr': -1,
         \})
     endfor
 
@@ -34,7 +27,6 @@ call ale#linter#Define('cs',{
 \   'name': 'mcs',
 \   'output_stream': 'stderr',
 \   'executable': 'mcs',
-\ 'command': g:ale#util#stdin_wrapper . ' .cs mcs -unsafe --parse' . g:ale_cs_mcs_options,
+\   'command_callback': 'ale_linters#cs#mcs#GetCommand',
 \   'callback': 'ale_linters#cs#mcs#Handle',
-\ })
-
+\})

ale_linters/css/csslint.vim

@@ -1,9 +1,18 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: This file adds support for checking CSS code with csslint.
 
+function! ale_linters#css#csslint#GetCommand(buffer) abort
+    let l:csslintrc = ale#path#FindNearestFile(a:buffer, '.csslintrc')
+    let l:config_option = !empty(l:csslintrc)
+    \   ? '--config=' . ale#Escape(l:csslintrc)
+    \   : ''
+
+    return 'csslint --format=compact ' . l:config_option . ' %t'
+endfunction
+
 call ale#linter#Define('css', {
 \   'name': 'csslint',
 \   'executable': 'csslint',
-\   'command': g:ale#util#stdin_wrapper . ' .css csslint --format=compact',
-\   'callback': 'ale#handlers#HandleCSSLintFormat',
+\   'command_callback': 'ale_linters#css#csslint#GetCommand',
+\   'callback': 'ale#handlers#css#HandleCSSLintFormat',
 \})

ale_linters/css/stylelint.vim

@@ -1,25 +1,18 @@
 " Author: diartyz <diartyz@gmail.com>
 
-let g:ale_css_stylelint_executable =
-\   get(g:, 'ale_css_stylelint_executable', 'stylelint')
-
-let g:ale_css_stylelint_use_global =
-\   get(g:, 'ale_css_stylelint_use_global', 0)
+call ale#Set('css_stylelint_executable', 'stylelint')
+call ale#Set('css_stylelint_options', '')
+call ale#Set('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,
+    return ale#node#FindExecutable(a:buffer, 'css_stylelint', [
     \   '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)
+    \   . ' ' . ale#Var(a:buffer, 'css_stylelint_options')
     \   . ' --stdin-filename %s'
 endfunction
 
@@ -27,5 +20,5 @@ 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',
+\   'callback': 'ale#handlers#css#HandleStyleLintFormat',
 \})

ale_linters/d/dmd.vim

@@ -5,7 +5,7 @@ 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 l:dub_file = ale#path#FindNearestFile(a:buffer, l:possible_filename)
 
         if !empty(l:dub_file)
             return l:dub_file
@@ -31,7 +31,7 @@ function! ale_linters#d#dmd#DUBCommand(buffer) abort
     " 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'))
+    return 'cd ' . ale#Escape(fnamemodify(l:dub_file, ':h'))
     \   . ' && dub describe --import-paths'
 endfunction
 
@@ -42,13 +42,11 @@ function! ale_linters#d#dmd#DMDCommand(buffer, dub_output) abort
     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))
+            call add(l:import_list, '-I' . ale#Escape(l:line))
         endif
     endfor
 
-    return g:ale#util#stdin_wrapper . ' .d dmd '
-    \   . join(l:import_list)
-    \   . ' -o- -vcolumns -c'
+    return 'dmd '. join(l:import_list) . ' -o- -vcolumns -c %t'
 endfunction
 
 function! ale_linters#d#dmd#Handle(buffer, lines) abort
@@ -58,27 +56,12 @@ function! ale_linters#d#dmd#Handle(buffer, lines) abort
     let l:pattern = '^[^(]\+(\([0-9]\+\)\,\?\([0-9]*\)): \([^:]\+\): \(.\+\)'
     let l:output = []
 
-    for l:line in a:lines
-        let l:match = matchlist(l:line, l:pattern)
-
-        if len(l:match) == 0
-            break
-        endif
-
-        let l:line = l:match[1] + 0
-        let l:column = l:match[2] + 0
-        let l:type = l:match[3]
-        let l:text = l:match[4]
-
-        " vcol is Needed to indicate that the column is a character.
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         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,
+        \   'lnum': l:match[1],
+        \   'col': l:match[2],
+        \   'type': l:match[3] ==# 'Warning' ? 'W' : 'E',
+        \   'text': l:match[4],
         \})
     endfor
 

ale_linters/dockerfile/hadolint.vim

@@ -7,13 +7,7 @@ function! ale_linters#dockerfile#hadolint#Handle(buffer, lines) abort
     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
-
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         let l:lnum = 0
 
         if l:match[1] !=# ''
@@ -23,11 +17,8 @@ function! ale_linters#dockerfile#hadolint#Handle(buffer, lines) abort
         let l:type = 'W'
         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:lnum,
-    \   'vcol': 0,
         \   'col': 0,
         \   'type': l:type,
         \   'text': l:text,
@@ -39,7 +30,8 @@ function! ale_linters#dockerfile#hadolint#Handle(buffer, lines) abort
 endfunction
 
 call ale#linter#Define('dockerfile', {
-      \ 'name': 'hadolint',
-      \ 'executable': 'hadolint',
-      \ 'command': 'hadolint -',
-      \ 'callback': 'ale_linters#dockerfile#hadolint#Handle' })
+\   'name': 'hadolint',
+\   'executable': 'hadolint',
+\   'command': 'hadolint -',
+\   'callback': 'ale_linters#dockerfile#hadolint#Handle',
+\})

ale_linters/elixir/credo.vim

@@ -3,17 +3,11 @@
 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
-    let l:match = matchlist(l:line, l:pattern)
-
-    if len(l:match) == 0
-        continue
-    endif
-
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         let l:type = l:match[3]
         let l:text = l:match[4]
 
@@ -23,15 +17,12 @@ function! ale_linters#elixir#credo#Handle(buffer, lines) abort
             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
 
@@ -39,7 +30,8 @@ function! ale_linters#elixir#credo#Handle(buffer, lines) abort
 endfunction
 
 call ale#linter#Define('elixir', {
-      \ 'name': 'credo',
-      \ 'executable': 'mix',
-      \ 'command': 'mix credo suggest --format=flycheck --read-from-stdin',
-      \ 'callback': 'ale_linters#elixir#credo#Handle' })
+\   'name': 'credo',
+\   'executable': 'mix',
+\   'command': 'mix credo suggest --format=flycheck --read-from-stdin %s',
+\   'callback': 'ale_linters#elixir#credo#Handle',
+\})

ale_linters/elixir/dogma.vim

@@ -0,0 +1,38 @@
+" Author: archseer - https://github.com/archSeer
+
+function! ale_linters#elixir#dogma#Handle(buffer, lines) abort
+    " Matches patterns line the following:
+    "
+    " 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:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:type = l:match[3]
+        let l:text = l:match[4]
+
+        if l:type ==# 'C'
+            let l:type = 'E'
+        elseif l:type ==# 'R'
+            let l:type = 'W'
+        endif
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:match[2] + 0,
+        \   'type': l:type,
+        \   'text': l:text,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('elixir', {
+\   'name': 'dogma',
+\   'executable': 'mix',
+\   'command': 'mix dogma %s --format=flycheck',
+\   'lint_file': 1,
+\   'callback': 'ale_linters#elixir#dogma#Handle',
+\})

ale_linters/elm/make.vim

@@ -5,6 +5,7 @@ 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
+    let l:unparsed_lines = []
     for l:line in a:lines
         if l:line[0] ==# '['
             let l:errors = json_decode(l:line)
@@ -20,41 +21,49 @@ function! ale_linters#elm#make#Handle(buffer, lines) abort
 
                 if l:file_is_buffer
                     call add(l:output, {
-                    \    'bufnr': a:buffer,
                     \    'lnum': l:error.region.start.line,
-                    \    'vcol': 0,
                     \    'col': l:error.region.start.column,
                     \    'type': (l:error.type ==? 'error') ? 'E' : 'W',
                     \    'text': l:error.overview,
-                    \    'nr': -1,
+                    \    'detail': l:error.overview . "\n\n" . l:error.details
                     \})
                 endif
             endfor
+        elseif l:line !=# 'Successfully generated /dev/null'
+            call add(l:unparsed_lines, l:line)
         endif
     endfor
 
+    if len(l:unparsed_lines) > 0
+        call add(l:output, {
+        \    'lnum': 1,
+        \    'type': 'E',
+        \    'text': l:unparsed_lines[0],
+        \    'detail': join(l:unparsed_lines, "\n")
+        \})
+    endif
+
     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')
+    let l:elm_package = ale#path#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) . ' && '
+        let l:dir_set_cmd = 'cd ' . ale#Escape(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')
-    let l:stdin_wrapper = g:ale#util#stdin_wrapper . ' .elm'
+    let l:elm_cmd = 'elm-make --report=json --output='.ale#Escape('/dev/null')
 
-    return l:dir_set_cmd . ' ' . l:stdin_wrapper . ' ' . l:elm_cmd
+    return l:dir_set_cmd . ' ' . l:elm_cmd . ' %t'
 endfunction
 
 call ale#linter#Define('elm', {
@@ -64,4 +73,3 @@ call ale#linter#Define('elm', {
 \    'command_callback': 'ale_linters#elm#make#GetCommand',
 \    'callback': 'ale_linters#elm#make#Handle'
 \})
-

ale_linters/erlang/erlc.vim

@@ -3,7 +3,12 @@
 let g:ale_erlang_erlc_options = get(g:, 'ale_erlang_erlc_options', '')
 
 function! ale_linters#erlang#erlc#GetCommand(buffer) abort
-    return g:ale#util#stdin_wrapper . ' .erl erlc ' . g:ale_erlang_erlc_options
+    let l:output_file = tempname()
+    call ale#engine#ManageFile(a:buffer, l:output_file)
+
+    return 'erlc -o ' . ale#Escape(l:output_file)
+    \   . ' ' . ale#Var(a:buffer, 'erlang_erlc_options')
+    \   . ' %t'
 endfunction
 
 function! ale_linters#erlang#erlc#Handle(buffer, lines) abort
@@ -43,11 +48,9 @@ function! ale_linters#erlang#erlc#Handle(buffer, lines) abort
             call add(l:output, {
             \   'bufnr': a:buffer,
             \   'lnum': 0,
-            \   'vcol': 0,
             \   'col': 0,
             \   'type': 'E',
             \   'text': l:match_parse_transform[0],
-            \   'nr': -1,
             \})
 
             continue
@@ -73,15 +76,12 @@ function! ale_linters#erlang#erlc#Handle(buffer, lines) abort
             let l:type = 'E'
         endif
 
-        " vcol is Needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:line,
-        \   'vcol': 0,
         \   'col': 0,
         \   'type': l:type,
         \   'text': l:text,
-        \   'nr': -1,
         \})
     endfor
 

ale_linters/eruby/erubylint.vim

@@ -0,0 +1,11 @@
+" Author: Matthias Guenther - https://wikimatze.de
+" Description: erb-lint for eruby/erb files
+
+call ale#linter#Define('eruby', {
+\   'name': 'erubylint',
+\   'executable': 'erb',
+\    'output_stream': 'stderr',
+\   'command': 'erb -P -x %t | ruby -c',
+\   'callback': 'ale#handlers#ruby#HandleSyntaxErrors',
+\})
+

ale_linters/fortran/gcc.vim

@@ -1,6 +1,15 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: gcc for Fortran files
 
+" This option can be set to 0 to use -ffixed-form
+if !exists('g:ale_fortran_gcc_use_free_form')
+    let g:ale_fortran_gcc_use_free_form = 1
+endif
+
+if !exists('g:ale_fortran_gcc_executable')
+    let g:ale_fortran_gcc_executable = 'gcc'
+endif
+
 " 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'
@@ -12,7 +21,7 @@ function! ale_linters#fortran#gcc#Handle(buffer, lines) abort
     "
     " :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 = {}
@@ -41,9 +50,7 @@ function! ale_linters#fortran#gcc#Handle(buffer, lines) abort
             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.
@@ -54,12 +61,26 @@ function! ale_linters#fortran#gcc#Handle(buffer, lines) abort
     return l:output
 endfunction
 
+function! ale_linters#fortran#gcc#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'fortran_gcc_executable')
+endfunction
+
+function! ale_linters#fortran#gcc#GetCommand(buffer) abort
+    let l:layout_option = ale#Var(a:buffer, 'fortran_gcc_use_free_form')
+    \   ? '-ffree-form'
+    \   : '-ffixed-form'
+
+    return ale_linters#fortran#gcc#GetExecutable(a:buffer)
+    \   . ' -S -x f95 -fsyntax-only '
+    \   . l:layout_option . ' '
+    \   . ale#Var(a:buffer, 'fortran_gcc_options') . ' '
+    \   . '-'
+endfunction
+
 call ale#linter#Define('fortran', {
 \   'name': 'gcc',
 \   'output_stream': 'stderr',
-\   'executable': 'gcc',
-\   'command': 'gcc -S -x f95 -fsyntax-only -ffree-form '
-\       . g:ale_fortran_gcc_options
-\       . ' -',
+\   'executable_callback': 'ale_linters#fortran#gcc#GetExecutable',
+\   'command_callback': 'ale_linters#fortran#gcc#GetCommand',
 \   'callback': 'ale_linters#fortran#gcc#Handle',
 \})

ale_linters/fuse/fusionlint.vim

@@ -0,0 +1,41 @@
+" Author: RyanSquared <vandor2012@gmail.com>
+" Description: `fusion-lint` linter for FusionScript files
+
+let g:ale_fuse_fusionlint_executable =
+\   get(g:, 'ale_fuse_fusionlint_executable', 'fusion-lint')
+
+let g:ale_fuse_fusionlint_options =
+\   get(g:, 'ale_fuse_fusionlint_options', '')
+
+function! ale_linters#fuse#fusionlint#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'fuse_fusionlint_executable')
+endfunction
+
+function! ale_linters#fuse#fusionlint#GetCommand(buffer) abort
+    return ale#Escape(ale_linters#fuse#fusionlint#GetExecutable(a:buffer))
+    \   . ' ' . ale#Var(a:buffer, 'fuse_fusionlint_options')
+    \   . ' --filename %s -i'
+endfunction
+
+function! ale_linters#fuse#fusionlint#Handle(buffer, lines) abort
+    let l:pattern = '^.*:\(\d\+\):\(\d\+\): (\([WE]\)\d\+) \(.\+\)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:match[2] + 0,
+        \   'text': l:match[4],
+        \   'type': l:match[3],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('fuse', {
+\   'name': 'fusionlint',
+\   'executable_callback': 'ale_linters#fuse#fusionlint#GetExecutable',
+\   'command_callback': 'ale_linters#fuse#fusionlint#GetCommand',
+\   'callback': 'ale_linters#fuse#fusionlint#Handle',
+\})

ale_linters/go/gobuild.vim

@@ -1,4 +1,4 @@
-" Author: Joshua Rubin <joshua@rubixconsulting.com>
+" Author: Joshua Rubin <joshua@rubixconsulting.com>, Ben Reedy <https://github.com/breed808>
 " Description: go build for Go files
 
 " inspired by work from dzhou121 <dzhou121@gmail.com>
@@ -11,190 +11,47 @@ function! ale_linters#go#gobuild#GoEnv(buffer) abort
     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)
+function! ale_linters#go#gobuild#GetCommand(buffer, goenv_output) abort
+    if !exists('s:go_env')
         let s:go_env = {
         \   'GOPATH': a:goenv_output[0],
         \   'GOROOT': a:goenv_output[1],
         \}
     endif
 
-  return 'go list -json ' . shellescape(s:PackageImportPath(a:buffer))
+    " Run go test in local directory with relative path
+    return 'GOPATH=' . s:go_env.GOPATH
+    \   . ' cd ' . fnamemodify(bufname(a:buffer), ':.:h')
+    \   . ' && go test -c -o /dev/null ./'
 endfunction
 
-let s:filekeys = [
-\ 'GoFiles',
-\ 'CgoFiles',
-\ 'CFiles',
-\ 'CXXFiles',
-\ 'MFiles',
-\ 'HFiles',
-\ 'FFiles',
-\ 'SFiles',
-\ 'SwigFiles',
-\ 'SwigCXXFiles',
-\ 'SysoFiles',
-\ 'TestGoFiles',
-\ 'XTestGoFiles',
-\]
+function! ale_linters#go#gobuild#GetMatches(lines) abort
+    " Matches patterns like the following:
+    "
+    " file.go:27: missing argument for Printf("%s"): format reads arg 2, have only 1 args
+    " file.go:53:10: if block ends with a return statement, so drop this else and outdent its block (move short variable declaration to its own line if necessary)
+    " file.go:5:2: expected declaration, found 'STRING' "log"
 
-" 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 = []
+    " go test returns relative paths so use tail of filename as part of pattern matcher
+    let l:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+):?(\d+)?:? (.+)$'
 
-  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''))')
+    return ale#util#GetMatches(a:lines, l:pattern)
 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
-  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
+    for l:match in ale_linters#go#gobuild#GetMatches(a:lines)
+        " Omit errors from imported go packages
+        if !ale#path#IsBufferPath(a:buffer, l:match[1])
             continue
         endif
 
         call add(l:output, {
-    \   'bufnr': l:buffer,
         \   'lnum': l:match[2] + 0,
-    \   'vcol': 0,
         \   'col': l:match[3] + 0,
         \   'text': l:match[4],
         \   'type': 'E',
-    \   'nr': -1,
         \})
     endfor
 
@@ -206,9 +63,8 @@ call ale#linter#Define('go', {
 \   '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',
+\   'lint_file': 1,
 \})

ale_linters/go/gofmt.vim

@@ -5,6 +5,6 @@ call ale#linter#Define('go', {
 \   'name': 'gofmt',
 \   'output_stream': 'stderr',
 \   'executable': 'gofmt',
-\   'command': g:ale#util#stdin_wrapper . ' .go gofmt -e',
-\   'callback': 'ale#handlers#HandleUnixFormatAsError',
+\   'command': 'gofmt -e %t',
+\   'callback': 'ale#handlers#unix#HandleAsError',
 \})

ale_linters/go/golint.vim

@@ -4,6 +4,6 @@
 call ale#linter#Define('go', {
 \   'name': 'golint',
 \   'executable': 'golint',
-\   'command': g:ale#util#stdin_wrapper . ' .go golint',
-\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\   'command': 'golint %t',
+\   'callback': 'ale#handlers#unix#HandleAsWarning',
 \})

ale_linters/go/gometalinter.vim

@@ -0,0 +1,43 @@
+" Author: Ben Reedy <https://github.com/breed808>
+" Description: Adds support for the gometalinter suite for Go files
+
+if !exists('g:ale_go_gometalinter_options')
+    let g:ale_go_gometalinter_options = ''
+endif
+
+function! ale_linters#go#gometalinter#GetCommand(buffer) abort
+    let l:filename = expand('#' . a:buffer . ':p')
+
+    return 'gometalinter --include=''^' . l:filename . '.*$'' '
+    \   . ale#Var(a:buffer, 'go_gometalinter_options')
+    \   . ' ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
+endfunction
+
+function! ale_linters#go#gometalinter#GetMatches(lines) abort
+    let l:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+):?(\d+)?:?:?(warning|error):?\s\*?(.+)$'
+
+    return ale#util#GetMatches(a:lines, l:pattern)
+endfunction
+
+function! ale_linters#go#gometalinter#Handler(buffer, lines) abort
+    let l:output = []
+
+    for l:match in ale_linters#go#gometalinter#GetMatches(a:lines)
+        call add(l:output, {
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'type': tolower(l:match[4]) ==# 'warning' ? 'W' : 'E',
+        \   'text': l:match[5],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'gometalinter',
+\   'executable': 'gometalinter',
+\   'command_callback': 'ale_linters#go#gometalinter#GetCommand',
+\   'callback': 'ale_linters#go#gometalinter#Handler',
+\   'lint_file': 1,
+\})

ale_linters/go/gosimple.vim

@@ -0,0 +1,9 @@
+" Author: Ben Reedy <https://github.com/breed808>
+" Description: gosimple for Go files
+
+call ale#linter#Define('go', {
+\   'name': 'gosimple',
+\   'executable': 'gosimple',
+\   'command': 'gosimple %t',
+\   'callback': 'ale#handlers#unix#HandleAsWarning',
+\})

ale_linters/go/govet.vim

@@ -5,6 +5,6 @@ call ale#linter#Define('go', {
 \   'name': 'go vet',
 \   'output_stream': 'stderr',
 \   'executable': 'go',
-\   'command': g:ale#util#stdin_wrapper . ' .go go vet',
-\   'callback': 'ale#handlers#HandleUnixFormatAsError',
+\   'command': 'go vet %t',
+\   'callback': 'ale#handlers#unix#HandleAsError',
 \})

ale_linters/go/staticcheck.vim

@@ -0,0 +1,9 @@
+" Author: Ben Reedy <https://github.com/breed808>
+" Description: staticcheck for Go files
+
+call ale#linter#Define('go', {
+\   'name': 'staticcheck',
+\   'executable': 'staticcheck',
+\   'command': 'staticcheck %t',
+\   'callback': 'ale#handlers#unix#HandleAsWarning',
+\})

ale_linters/haml/hamllint.vim

@@ -0,0 +1,26 @@
+" 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:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   '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/handlebars/embertemplatelint.vim

@@ -0,0 +1,56 @@
+" Author: Adrian Zalewski <aazalewski@hotmail.com>
+" Description: Ember-template-lint for checking Handlebars files
+
+call ale#Set('handlebars_embertemplatelint_executable', 'ember-template-lint')
+call ale#Set('handlebars_embertemplatelint_use_global', 0)
+
+function! ale_linters#handlebars#embertemplatelint#GetExecutable(buffer) abort
+    return ale#node#FindExecutable(a:buffer, 'handlebars_embertemplatelint', [
+    \   'node_modules/.bin/ember-template-lint',
+    \])
+endfunction
+
+function! ale_linters#handlebars#embertemplatelint#GetCommand(buffer) abort
+    return ale_linters#handlebars#embertemplatelint#GetExecutable(a:buffer)
+    \   . ' --json %t'
+endfunction
+
+function! ale_linters#handlebars#embertemplatelint#Handle(buffer, lines) abort
+    if len(a:lines) == 0
+      return []
+    endif
+
+    let l:output = []
+
+    let l:input_json = json_decode(join(a:lines, ''))
+    let l:file_errors = values(l:input_json)[0]
+
+    for l:error in l:file_errors
+        if has_key(l:error, 'fatal')
+            call add(l:output, {
+            \   'bufnr': a:buffer,
+            \   'lnum': 1,
+            \   'col': 1,
+            \   'text': l:error.message,
+            \   'type': l:error.severity == 1 ? 'W' : 'E',
+            \})
+        else
+            call add(l:output, {
+            \   'bufnr': a:buffer,
+            \   'lnum': l:error.line,
+            \   'col': l:error.column,
+            \   'text': l:error.rule . ': ' . l:error.message,
+            \   'type': l:error.severity == 1 ? 'W' : 'E',
+            \})
+        endif
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('handlebars', {
+\   'name': 'ember-template-lint',
+\   'executable_callback': 'ale_linters#handlebars#embertemplatelint#GetExecutable',
+\   'command_callback': 'ale_linters#handlebars#embertemplatelint#GetCommand',
+\   'callback': 'ale_linters#handlebars#embertemplatelint#Handle',
+\})

ale_linters/haskell/ghc-mod.vim

@@ -0,0 +1,16 @@
+" Author: wizzup <wizzup@gmail.com>
+" Description: ghc-mod for Haskell files
+
+call ale#linter#Define('haskell', {
+\   'name': 'ghc-mod',
+\   'executable': 'ghc-mod',
+\   'command': 'ghc-mod check %t',
+\   'callback': 'ale#handlers#haskell#HandleGHCFormat',
+\})
+
+call ale#linter#Define('haskell', {
+\   'name': 'stack-ghc-mod',
+\   'executable': 'stack',
+\   'command': 'stack exec ghc-mod check %t',
+\   'callback': 'ale#handlers#haskell#HandleGHCFormat',
+\})

ale_linters/haskell/ghc.vim

@@ -1,73 +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
-
-function! ale_linters#haskell#ghc#Handle(buffer, lines) abort
-    " Look for lines like the following.
-    "
-    " /dev/stdin:28:26: Not in scope: `>>>>>'
-    let l:pattern = '^[^:]\+:\(\d\+\):\(\d\+\): \(.\+\)$'
-    let l:output = []
-
-    " For some reason the output coming out of the GHC through the wrapper
-    " script breaks the lines up in strange ways. So we have to join some
-    " lines back together again.
-    let l:corrected_lines = []
-
-    for l:line in a:lines
-        if len(matchlist(l:line, l:pattern)) > 0
-            call add(l:corrected_lines, l:line)
-            if l:line !~# ': error:$'
-                call add(l:corrected_lines, '')
-            endif
-        elseif l:line ==# ''
-            call add(l:corrected_lines, l:line)
-        else
-            if len(l:corrected_lines) > 0
-                let l:line = substitute(l:line, '\v\s+', ' ', '')
-                let l:corrected_lines[-1] .= l:line
-            endif
-        endif
-    endfor
-
-    for l:line in l:corrected_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,
-        \   'vcol': 0,
-        \   'col': l:match[2] + 0,
-        \   'text': l:match[3],
-        \   'type': 'E',
-        \   'nr': -1,
-        \})
-    endfor
-
-    return l:output
-endfunction
-
 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_linters#haskell#ghc#Handle',
+\   'command': 'ghc -fno-code -v0 %t',
+\   'callback': 'ale#handlers#haskell#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_linters#haskell#ghc#Handle',
+\   'command': 'stack ghc -- -fno-code -v0 %t',
+\   'callback': 'ale#handlers#haskell#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#haskell#HandleGHCFormat',
+\})

ale_linters/haskell/hlint.vim

@@ -7,11 +7,9 @@ function! ale_linters#haskell#hlint#Handle(buffer, lines) abort
     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 . '. Found: ' . l:error.from . ' Why not: ' . l:error.to,
         \   'type': l:error.severity ==# 'Error' ? 'E' : 'W',

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#unix#HandleAsWarning',
+\})

ale_linters/html/htmlhint.vim

@@ -1,36 +1,25 @@
 " Author: KabbAmine <amine.kabb@gmail.com>, deathmaz <00maz1987@gmail.com>, diartyz <diartyz@gmail.com>
 " Description: HTMLHint for checking html files
 
-" CLI options
-let g:ale_html_htmlhint_options = get(g:, 'ale_html_htmlhint_options', '--format=unix')
-
-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)
+call ale#Set('html_htmlhint_options', '--format=unix')
+call ale#Set('html_htmlhint_executable', 'htmlhint')
+call ale#Set('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,
+    return ale#node#FindExecutable(a:buffer, 'html_htmlhint', [
     \   'node_modules/.bin/htmlhint',
-    \   g:ale_html_htmlhint_executable
-    \)
+    \])
 endfunction
 
 function! ale_linters#html#htmlhint#GetCommand(buffer) abort
-    return g:ale#util#stdin_wrapper . ' .html '
-    \   . ale_linters#html#htmlhint#GetExecutable(a:buffer)
-    \   . ' ' . g:ale_html_htmlhint_options
+    return ale_linters#html#htmlhint#GetExecutable(a:buffer)
+    \   . ' ' . ale#Var(a:buffer, 'html_htmlhint_options')
+    \   . ' %t'
 endfunction
 
 call ale#linter#Define('html', {
 \   'name': 'htmlhint',
 \   'executable_callback': 'ale_linters#html#htmlhint#GetExecutable',
 \   'command_callback': 'ale_linters#html#htmlhint#GetCommand',
-\   'callback': 'ale#handlers#HandleUnixFormatAsError',
+\   'callback': 'ale#handlers#unix#HandleAsError',
 \})

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#unix#HandleAsWarning',
+\})

ale_linters/html/tidy.vim

@@ -3,7 +3,9 @@
 
 " 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')
+" Look for the old _args variable first.
+let s:default_options = get(g:, 'ale_html_tidy_args', '-q -e -language en')
+let g:ale_html_tidy_options = get(g:, 'ale_html_tidy_options', s:default_options)
 
 function! ale_linters#html#tidy#GetCommand(buffer) abort
     " Specify file encoding in options
@@ -24,10 +26,14 @@ function! ale_linters#html#tidy#GetCommand(buffer) abort
     \ }, &fileencoding, '-utf8')
 
     return printf('%s %s %s -',
-    \   g:ale_html_tidy_executable,
-    \   g:ale_html_tidy_args,
+    \   ale#Var(a:buffer, 'html_tidy_executable'),
+    \   ale#Var(a:buffer, 'html_tidy_options'),
     \   l:file_encoding
-    \ )
+    \)
+endfunction
+
+function! ale_linters#html#tidy#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'html_tidy_executable')
 endfunction
 
 function! ale_linters#html#tidy#Handle(buffer, lines) abort
@@ -37,27 +43,17 @@ function! ale_linters#html#tidy#Handle(buffer, lines) abort
     let l:pattern = '^line \(\d\+\) column \(\d\+\) - \(Warning\|Error\): \(.\+\)$'
     let l:output = []
 
-    for l:line in a:lines
-        let l:match = matchlist(l:line, l:pattern)
-
-        if len(l:match) == 0
-            continue
-        endif
-
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         let l:line = l:match[1] + 0
         let l:col = l:match[2] + 0
         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
 
@@ -66,7 +62,7 @@ endfunction
 
 call ale#linter#Define('html', {
 \   'name': 'tidy',
-\   'executable': g:ale_html_tidy_executable,
+\   'executable_callback': 'ale_linters#html#tidy#GetExecutable',
 \   'output_stream': 'stderr',
 \   'command_callback': 'ale_linters#html#tidy#GetCommand',
 \   'callback': 'ale_linters#html#tidy#Handle',

ale_linters/java/checkstyle.vim

@@ -0,0 +1,46 @@
+" Author: Devon Meunier <devon.meunier@gmail.com>
+" Description: checkstyle for Java files
+
+function! ale_linters#java#checkstyle#Handle(buffer, lines) abort
+    let l:patterns = [
+        \ '\v\[(WARN|ERROR)\] .*:(\d+):(\d+): (.*)',
+        \ '\v\[(WARN|ERROR)\] .*:(\d+): (.*)',
+        \]
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:patterns)
+        let l:args = {
+        \   'lnum': l:match[2] + 0,
+        \   'type': l:match[1] =~? 'WARN' ? 'W' : 'E'
+        \ }
+
+        let l:col = l:match[3] + 0
+        if l:col > 0
+            let l:args['col'] = l:col
+            let l:args['text'] = l:match[4]
+        else
+            let l:args['text'] = l:match[3]
+        endif
+
+        call add(l:output, l:args)
+    endfor
+
+    return l:output
+endfunction
+
+function! ale_linters#java#checkstyle#GetCommand(buffer) abort
+    return 'checkstyle '
+    \ . ale#Var(a:buffer, 'java_checkstyle_options')
+    \ . ' %t'
+endfunction
+
+if !exists('g:ale_java_checkstyle_options')
+    let g:ale_java_checkstyle_options = '-c /google_checks.xml'
+endif
+
+call ale#linter#Define('java', {
+\   'name': 'checkstyle',
+\   'executable': 'checkstyle',
+\   'command_callback': 'ale_linters#java#checkstyle#GetCommand',
+\   'callback': 'ale_linters#java#checkstyle#Handle',
+\})

ale_linters/java/javac.vim

@@ -0,0 +1,94 @@
+" Author: farenjihn <farenjihn@gmail.com>, w0rp <devw0rp@gmail.com>
+" Description: Lints java files using javac
+
+let s:classpath_sep = has('unix') ? ':' : ';'
+
+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#GetImportPaths(buffer) abort
+    let l:pom_path = ale#path#FindNearestFile(a:buffer, 'pom.xml')
+
+    if !empty(l:pom_path) && executable('mvn')
+        return ale#path#CdString(fnamemodify(l:pom_path, ':h'))
+        \ . 'mvn dependency:build-classpath'
+    endif
+
+    return ''
+endfunction
+
+function! s:BuildClassPathOption(buffer, import_paths) abort
+    " Filter out lines like [INFO], etc.
+    let l:class_paths = filter(a:import_paths[:], 'v:val !~# ''[''')
+    call extend(
+    \   l:class_paths,
+    \   split(ale#Var(a:buffer, 'java_javac_classpath'), s:classpath_sep),
+    \)
+
+    return !empty(l:class_paths)
+    \   ? '-cp ' . ale#Escape(join(l:class_paths, s:classpath_sep))
+    \   : ''
+endfunction
+
+function! ale_linters#java#javac#GetCommand(buffer, import_paths) abort
+    let l:cp_option = s:BuildClassPathOption(a:buffer, a:import_paths)
+    let l:sp_option = ''
+
+    " Find the src directory, for files in this project.
+    let l:src_dir = ale#path#FindNearestDirectory(a:buffer, 'src/main/java')
+
+    if !empty(l:src_dir)
+        let l:sp_option = '-sourcepath ' . ale#Escape(l:src_dir)
+    endif
+
+    " Create .class files in a temporary directory, which we will delete later.
+    let l:class_file_directory = ale#engine#CreateDirectory(a:buffer)
+
+    return 'javac -Xlint'
+    \ . ' ' . l:cp_option
+    \ . ' ' . l:sp_option
+    \ . ' -d ' . ale#Escape(l:class_file_directory)
+    \ . ' ' . ale#Var(a:buffer, '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 = '\v^.*:(\d+): (.+):(.+)$'
+    let l:col_pattern = '\v^(\s*\^)$'
+    let l:symbol_pattern = '\v^ +symbol: *(class|method) +([^ ]+)'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, [l:pattern, l:col_pattern, l:symbol_pattern])
+        if empty(l:match[2]) && empty(l:match[3])
+                let l:output[-1].col = len(l:match[1])
+        elseif empty(l:match[3])
+            " Add symbols to 'cannot find symbol' errors.
+            if l:output[-1].text ==# 'error: cannot find symbol'
+                let l:output[-1].text .= ': ' . l:match[2]
+            endif
+        else
+            call add(l:output, {
+            \   'lnum': l:match[1] + 0,
+            \   'text': l:match[2] . ':' . l:match[3],
+            \   'type': l:match[2] ==# 'error' ? 'E' : 'W',
+            \})
+        endif
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('java', {
+\   'name': 'javac',
+\   'executable': 'javac',
+\   'command_chain': [
+\       {'callback': 'ale_linters#java#javac#GetImportPaths', 'output_stream': 'stdout'},
+\       {'callback': 'ale_linters#java#javac#GetCommand', 'output_stream': 'stderr'},
+\   ],
+\   'callback': 'ale_linters#java#javac#Handle',
+\})

ale_linters/javascript/eslint.vim

@@ -1,84 +1,9 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: eslint for JavaScript files
 
-let g:ale_javascript_eslint_executable =
-\   get(g:, 'ale_javascript_eslint_executable', 'eslint')
-
-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
-    " 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]
-
-        " 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
-
-    return l:output
-endfunction
-
 call ale#linter#Define('javascript', {
 \   'name': 'eslint',
-\   'executable_callback': 'ale_linters#javascript#eslint#GetExecutable',
-\   'command_callback': 'ale_linters#javascript#eslint#GetCommand',
-\   'callback': 'ale_linters#javascript#eslint#Handle',
+\   'executable_callback': 'ale#handlers#eslint#GetExecutable',
+\   'command_callback': 'ale#handlers#eslint#GetCommand',
+\   'callback': 'ale#handlers#eslint#Handle',
 \})

ale_linters/javascript/flow.vim

@@ -1,50 +1,54 @@
 " 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)
+call ale#Set('javascript_flow_executable', 'flow')
+call ale#Set('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,
+    return ale#node#FindExecutable(a:buffer, 'javascript_flow', [
     \   'node_modules/.bin/flow',
-  \   g:ale_javascript_flow_executable
-  \)
+    \])
 endfunction
 
 function! ale_linters#javascript#flow#GetCommand(buffer) abort
-  return ale_linters#javascript#flow#GetExecutable(a:buffer)
+    let l:flow_config = ale#path#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#Escape(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)
 
-  if has_key(l:flow_output, 'errors')
+    let l:flow_output = json_decode(l:str)
     let l:output = []
 
-    for l:error in l:flow_output.errors
+    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
+            " Comments have no line of column information, so we skip them.
+            " In certain cases, `l:message.loc.source` points to a different path
+            " than the buffer one, thus we skip this loc information too.
+            if has_key(l:message, 'loc')
+            \&& l:line ==# 0
+            \&& ale#path#IsBufferPath(a:buffer, l:message.loc.source)
                 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
@@ -57,9 +61,7 @@ function! ale_linters#javascript#flow#Handle(buffer, lines) abort
         endif
 
         call add(l:output, {
-      \   'bufnr': a:buffer,
         \   'lnum': l:line,
-      \   'vcol': 0,
         \   'col': l:col,
         \   'text': l:text,
         \   'type': l:error.level ==# 'error' ? 'E' : 'W',
@@ -67,9 +69,6 @@ function! ale_linters#javascript#flow#Handle(buffer, lines) abort
     endfor
 
     return l:output
-  else
-    return []
-  endif
 endfunction
 
 call ale#linter#Define('javascript', {

ale_linters/javascript/jscs.vim

@@ -5,5 +5,5 @@ call ale#linter#Define('javascript', {
 \   'name': 'jscs',
 \   'executable': 'jscs',
 \   'command': 'jscs -r unix -n -',
-\   'callback': 'ale#handlers#HandleUnixFormatAsError',
+\   'callback': 'ale#handlers#unix#HandleAsError',
 \})

ale_linters/javascript/jshint.vim

@@ -1,37 +1,28 @@
 " Author: Chris Kyrouac - https://github.com/fijshion
 " Description: JSHint for Javascript files
 
-let g:ale_javascript_jshint_executable =
-\   get(g:, 'ale_javascript_jshint_executable', 'jshint')
-
-let g:ale_javascript_jshint_use_global =
-\   get(g:, 'ale_javascript_jshint_use_global', 0)
+call ale#Set('javascript_jshint_executable', 'jshint')
+call ale#Set('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
-
-    return ale#util#ResolveLocalPath(
-    \   a:buffer,
+    return ale#node#FindExecutable(a:buffer, 'javascript_jshint', [
     \   '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(
+    let l:jshint_config = ale#path#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'
+    let l:command = ale#Escape(ale_linters#javascript#jshint#GetExecutable(a:buffer))
+    let l:command .= ' --reporter unix --extract auto'
 
     if !empty(l:jshint_config)
-        let l:command .= ' --config ' . fnameescape(l:jshint_config)
+        let l:command .= ' --config ' . ale#Escape(l:jshint_config)
     endif
 
     let l:command .= ' -'
@@ -43,5 +34,5 @@ call ale#linter#Define('javascript', {
 \   'name': 'jshint',
 \   'executable_callback': 'ale_linters#javascript#jshint#GetExecutable',
 \   'command_callback': 'ale_linters#javascript#jshint#GetCommand',
-\   'callback': 'ale#handlers#HandleUnixFormatAsError',
+\   'callback': 'ale#handlers#unix#HandleAsError',
 \})

ale_linters/javascript/standard.vim

@@ -0,0 +1,26 @@
+" Author: Ahmed El Gabri <@ahmedelgabri>
+" Description: standardjs for JavaScript files
+
+call ale#Set('javascript_standard_executable', 'standard')
+call ale#Set('javascript_standard_use_global', 0)
+call ale#Set('javascript_standard_options', '')
+
+function! ale_linters#javascript#standard#GetExecutable(buffer) abort
+    return ale#node#FindExecutable(a:buffer, 'javascript_standard', [
+    \   'node_modules/.bin/standard',
+    \])
+endfunction
+
+function! ale_linters#javascript#standard#GetCommand(buffer) abort
+    return ale#Escape(ale_linters#javascript#standard#GetExecutable(a:buffer))
+    \   . ' ' . ale#Var(a:buffer, 'javascript_standard_options')
+    \   . ' --stdin %s'
+endfunction
+
+" standard uses eslint and the output format is the same
+call ale#linter#Define('javascript', {
+\   'name': 'standard',
+\   'executable_callback': 'ale_linters#javascript#standard#GetExecutable',
+\   'command_callback': 'ale_linters#javascript#standard#GetCommand',
+\   'callback': 'ale#handlers#eslint#Handle',
+\})

ale_linters/javascript/xo.vim

@@ -0,0 +1,26 @@
+" Author: Daniel Lupu <lupu.daniel.f@gmail.com>
+" Description: xo for JavaScript files
+
+call ale#Set('javascript_xo_executable', 'xo')
+call ale#Set('javascript_xo_use_global', 0)
+call ale#Set('javascript_xo_options', '')
+
+function! ale_linters#javascript#xo#GetExecutable(buffer) abort
+    return ale#node#FindExecutable(a:buffer, 'javascript_xo', [
+    \   'node_modules/.bin/xo',
+    \])
+endfunction
+
+function! ale_linters#javascript#xo#GetCommand(buffer) abort
+    return ale#Escape(ale_linters#javascript#xo#GetExecutable(a:buffer))
+    \   . ' ' . ale#Var(a:buffer, 'javascript_xo_options')
+    \   . ' --reporter unix --stdin --stdin-filename %s'
+endfunction
+
+" xo uses eslint and the output format is the same
+call ale#linter#Define('javascript', {
+\   'name': 'xo',
+\   'executable_callback': 'ale_linters#javascript#xo#GetExecutable',
+\   'command_callback': 'ale_linters#javascript#xo#GetCommand',
+\   'callback': 'ale#handlers#eslint#Handle',
+\})

ale_linters/json/jsonlint.vim

@@ -7,22 +7,11 @@ function! ale_linters#json#jsonlint#Handle(buffer, lines) abort
     let l:pattern = '^line \(\d\+\), col \(\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
-
-        " vcol is needed to indicate that the column is a character
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         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/kotlin/kotlinc.vim

@@ -0,0 +1,157 @@
+" Author: Francis Agyapong <francisgyapong2@gmail.com>
+" Description: A linter for the Kotlin programming language that uses kotlinc
+
+let g:ale_kotlin_kotlinc_options = get(g:, 'ale_kotlin_kotlinc_options', '')
+let g:ale_kotlin_kotlinc_enable_config = get(g:, 'ale_kotlin_kotlinc_enable_config', 0)
+let g:ale_kotlin_kotlinc_config_file = get(g:, 'ale_kotlin_kotlinc_config_file', '.ale_kotlinc_config')
+let g:ale_kotlin_kotlinc_classpath = get(g:, 'ale_kotlin_kotlinc_classpath', '')
+let g:ale_kotlin_kotlinc_sourcepath = get(g:, 'ale_kotlin_kotlinc_sourcepath', '')
+let g:ale_kotlin_kotlinc_use_module_file = get(g:, 'ale_kotlin_kotlinc_use_module_file', 0)
+let g:ale_kotlin_kotlinc_module_filename = get(g:, 'ale_kotlin_kotlinc_module_filename', 'module.xml')
+
+let s:classpath_sep = has('unix') ? ':' : ';'
+
+function! ale_linters#kotlin#kotlinc#GetImportPaths(buffer) abort
+    " exec maven only if classpath is not set
+    if ale#Var(a:buffer, 'kotlin_kotlinc_classpath') !=# ''
+        return ''
+    else
+        let l:pom_path = ale#path#FindNearestFile(a:buffer, 'pom.xml')
+
+        if !empty(l:pom_path) && executable('mvn')
+            return ale#path#CdString(fnamemodify(l:pom_path, ':h'))
+                        \ . 'mvn dependency:build-classpath'
+        endif
+
+        return ''
+    endif
+endfunction
+
+function! s:BuildClassPathOption(buffer, import_paths) abort
+    " Filter out lines like [INFO], etc.
+    let l:class_paths = filter(a:import_paths[:], 'v:val !~# ''[''')
+    call extend(
+    \   l:class_paths,
+    \   split(ale#Var(a:buffer, 'kotlin_kotlinc_classpath'), s:classpath_sep),
+    \)
+
+    return !empty(l:class_paths)
+    \   ? ' -cp ' . ale#Escape(join(l:class_paths, s:classpath_sep))
+    \   : ''
+endfunction
+
+function! ale_linters#kotlin#kotlinc#GetCommand(buffer, import_paths) abort
+    let l:kotlinc_opts = ale#Var(a:buffer, 'kotlin_kotlinc_options')
+    let l:command = 'kotlinc '
+
+    " If the config file is enabled and readable, source it
+    if ale#Var(a:buffer, 'kotlin_kotlinc_enable_config')
+        let l:conf = expand(ale#Var(a:buffer, 'kotlin_kotlinc_config_file'), 1)
+
+        if filereadable(l:conf)
+            execute 'source ' . fnameescape(l:conf)
+        endif
+    endif
+
+    " If use module and module file is readable use that and return
+    if ale#Var(a:buffer, 'kotlin_kotlinc_use_module_file')
+        let l:module_filename = ale#Escape(expand(ale#Var(a:buffer, 'kotlin_kotlinc_module_filename'), 1))
+
+        if filereadable(l:module_filename)
+            let l:kotlinc_opts .= ' -module ' . l:module_filename
+            let l:command .= 'kotlinc ' . l:kotlinc_opts
+
+            return l:command
+        endif
+    endif
+
+    " We only get here if not using module or the module file not readable
+    if ale#Var(a:buffer, 'kotlin_kotlinc_classpath') !=# ''
+        let l:kotlinc_opts .= ' -cp ' . ale#Var(a:buffer, 'kotlin_kotlinc_classpath')
+    else
+        " get classpath from maven
+        let l:kotlinc_opts .= s:BuildClassPathOption(a:buffer, a:import_paths)
+    endif
+
+    let l:fname = ''
+    if ale#Var(a:buffer, 'kotlin_kotlinc_sourcepath') !=# ''
+        let l:fname .= expand(ale#Var(a:buffer, 'kotlin_kotlinc_sourcepath'), 1) . ' '
+    else
+        " Find the src directory for files in this project.
+        let l:src_dir = ale#path#FindNearestDirectory(a:buffer, 'src/main/java')
+        let l:fname .= expand(l:src_dir, 1) . ' '
+    endif
+    let l:fname .= ale#Escape(expand('#' . a:buffer . ':p'))
+    let l:command .= l:kotlinc_opts . ' ' . l:fname
+
+    return l:command
+endfunction
+
+function! ale_linters#kotlin#kotlinc#Handle(buffer, lines) abort
+    let l:code_pattern = '^\(.*\):\([0-9]\+\):\([0-9]\+\):\s\+\(error\|warning\):\s\+\(.*\)'
+    let l:general_pattern = '^\(warning\|error\|info\):\s*\(.*\)'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:code_pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        let l:file = l:match[1]
+        let l:line = l:match[2] + 0
+        let l:column = l:match[3] + 0
+        let l:type = l:match[4]
+        let l:text = l:match[5]
+
+        let l:buf_abspath = fnamemodify(l:file, ':p')
+        let l:curbuf_abspath = expand('#' . a:buffer . ':p')
+
+        " Skip if file is not loaded
+        if l:buf_abspath !=# l:curbuf_abspath
+            continue
+        endif
+        let l:type_marker_str = l:type ==# 'warning' ? 'W' : 'E'
+
+        call add(l:output, {
+        \   'lnum': l:line,
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type_marker_str,
+        \})
+    endfor
+
+    " Non-code related messages
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:general_pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        let l:type = l:match[1]
+        let l:text = l:match[2]
+
+        let l:type_marker_str = l:type ==# 'warning' || l:type ==# 'info' ? 'W' : 'E'
+
+        call add(l:output, {
+        \   'lnum': 1,
+        \   'text': l:text,
+        \   'type': l:type_marker_str,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('kotlin', {
+\   'name': 'kotlinc',
+\   'executable': 'kotlinc',
+\   'command_chain': [
+\       {'callback': 'ale_linters#kotlin#kotlinc#GetImportPaths', 'output_stream': 'stdout'},
+\       {'callback': 'ale_linters#kotlin#kotlinc#GetCommand', 'output_stream': 'stderr'},
+\   ],
+\   'callback': 'ale_linters#kotlin#kotlinc#Handle',
+\   'lint_file': 1,
+\})

ale_linters/kotlin/ktlint.vim

@@ -0,0 +1,54 @@
+" Author: Francis Agyapong <francisagyapong2@gmail.com>
+" Description: Lint kotlin files using ktlint
+
+call ale#Set('kotlin_ktlint_executable', 'ktlint')
+call ale#Set('kotlin_ktlint_rulesets', [])
+call ale#Set('kotlin_ktlint_format', 0)
+
+
+function! ale_linters#kotlin#ktlint#GetCommand(buffer) abort
+    let l:executable = ale#Var(a:buffer, 'kotlin_ktlint_executable')
+    let l:file_path = expand('#' . a:buffer . ':p')
+    let l:options = ''
+
+    " Formmatted content written to original file, not sure how to handle
+    " if ale#Var(a:buffer, 'kotlin_ktlint_format')
+    "     let l:options = l:options . ' --format'
+    " endif
+
+    for l:ruleset in ale#Var(a:buffer, 'kotlin_ktlint_rulesets')
+        let l:options = l:options . ' --ruleset ' . l:ruleset
+    endfor
+
+    return l:executable . ' ' . l:options . ' ' . l:file_path
+endfunction
+
+function! ale_linters#kotlin#ktlint#Handle(buffer, lines) abort
+    let l:message_pattern = '^\(.*\):\([0-9]\+\):\([0-9]\+\):\s\+\(.*\)'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:message_pattern)
+        let l:line = l:match[2] + 0
+        let l:column = l:match[3] + 0
+        let l:text = l:match[4]
+
+        let l:type = l:text =~? 'not a valid kotlin file' ? 'E' : 'W'
+
+        call add(l:output, {
+        \   'lnum': l:line,
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('kotlin', {
+\   'name': 'ktlint',
+\   'executable': 'ktlint',
+\   'command_callback': 'ale_linters#kotlin#ktlint#GetCommand',
+\   'callback': 'ale_linters#kotlin#ktlint#Handle',
+\   'lint_file': 1
+\})

ale_linters/lua/luacheck.vim

@@ -4,6 +4,19 @@
 let g:ale_lua_luacheck_executable =
 \   get(g:, 'ale_lua_luacheck_executable', 'luacheck')
 
+let g:ale_lua_luacheck_options =
+\   get(g:, 'ale_lua_luacheck_options', '')
+
+function! ale_linters#lua#luacheck#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'lua_luacheck_executable')
+endfunction
+
+function! ale_linters#lua#luacheck#GetCommand(buffer) abort
+    return ale#Escape(ale_linters#lua#luacheck#GetExecutable(a:buffer))
+    \   . ' ' . ale#Var(a:buffer, 'lua_luacheck_options')
+    \   . ' --formatter plain --codes --filename %s -'
+endfunction
+
 function! ale_linters#lua#luacheck#Handle(buffer, lines) abort
     " Matches patterns line the following:
     "
@@ -12,22 +25,12 @@ function! ale_linters#lua#luacheck#Handle(buffer, lines) abort
     let l:pattern = '^.*:\(\d\+\):\(\d\+\): (\([WE]\)\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
-
-        " vcol is Needed to indicate that the column is a character.
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         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
 
@@ -36,7 +39,7 @@ endfunction
 
 call ale#linter#Define('lua', {
 \   'name': 'luacheck',
-\   'executable': g:ale_lua_luacheck_executable,
-\   'command': g:ale_lua_luacheck_executable . ' --formatter plain --codes --filename %s -',
+\   'executable_callback': 'ale_linters#lua#luacheck#GetExecutable',
+\   'command_callback': 'ale_linters#lua#luacheck#GetCommand',
 \   'callback': 'ale_linters#lua#luacheck#Handle',
 \})

ale_linters/markdown/mdl.vim

@@ -6,21 +6,11 @@ function! ale_linters#markdown#mdl#Handle(buffer, lines) abort
     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
-
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         call add(l:output, {
-        \   'bufnr': a:buffer,
         \   'lnum': l:match[1] + 0,
-        \   'vcol': 0,
-        \   'col': 0,
         \   'text': l:match[2],
         \   'type': 'W',
-        \   'nr': -1,
         \})
     endfor
 

ale_linters/markdown/proselint.vim

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

ale_linters/markdown/vale.vim

@@ -0,0 +1,9 @@
+" Author: chew-z https://github.com/chew-z
+" Description: vale for Markdown files
+
+call ale#linter#Define('markdown', {
+\   'name': 'vale',
+\   'executable': 'vale',
+\   'command': 'vale --output=line %t',
+\   'callback': 'ale#handlers#unix#HandleAsWarning',
+\})

ale_linters/matlab/mlint.vim

@@ -4,6 +4,16 @@
 let g:ale_matlab_mlint_executable =
 \   get(g:, 'ale_matlab_mlint_executable', 'mlint')
 
+function! ale_linters#matlab#mlint#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, '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:
     "
@@ -12,13 +22,7 @@ function! ale_linters#matlab#mlint#Handle(buffer, lines) abort
     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
-
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         let l:lnum = l:match[1] + 0
         let l:col = l:match[2] + 0
         let l:code = l:match[3]
@@ -30,15 +34,12 @@ function! ale_linters#matlab#mlint#Handle(buffer, lines) abort
             continue
         endif
 
-        " vcol is needed to indicate that the column is a character.
         call add(l:output, {
         \   'bufnr': a:buffer,
         \   'lnum': l:lnum,
-        \   'vcol': 0,
         \   'col': l:col,
         \   'text': l:text,
         \   'type': 'W',
-        \   'nr': -1,
         \})
     endfor
 
@@ -47,9 +48,8 @@ endfunction
 
 call ale#linter#Define('matlab', {
 \   'name': 'mlint',
-\   'executable': 'mlint',
-\   'command': g:ale#util#stdin_wrapper .
-\       ' .m ' . g:ale_matlab_mlint_executable . ' -id',
+\   '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,58 @@
+" 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:match in ale#util#GetMatches(a:lines, l:pattern)
+        " 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, {
+        \   'lnum': l:line,
+        \   'col': l:column,
+        \   'text': l:text,
+        \   'type': l:type,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+
+function! ale_linters#nim#nimcheck#GetCommand(buffer) abort
+    return 'nim check --verbosity:0 --colors:off --listFullPaths %s'
+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',
+\    'lint_file': 1,
+\})

ale_linters/nix/nix.vim

@@ -0,0 +1,26 @@
+" 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:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   '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#unix#HandleAsWarning',
+\})

ale_linters/objc/clang.vim

@@ -0,0 +1,23 @@
+" Author: Bang Lee <https://github.com/Qusic>
+" Description: clang linter for objc files
+
+" Set this option to change the Clang options for warnings for ObjC.
+if !exists('g:ale_objc_clang_options')
+    let g:ale_objc_clang_options = '-std=c11 -Wall'
+endif
+
+function! ale_linters#objc#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 objective-c -fsyntax-only '
+    \   . '-iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ' ' . ale#Var(a:buffer, 'objc_clang_options') . ' -'
+endfunction
+
+call ale#linter#Define('objc', {
+\   'name': 'clang',
+\   'output_stream': 'stderr',
+\   'executable': 'clang',
+\   'command_callback': 'ale_linters#objc#clang#GetCommand',
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\})

ale_linters/objcpp/clang.vim

@@ -0,0 +1,23 @@
+" Author: Bang Lee <https://github.com/Qusic>
+" Description: clang linter for objcpp files
+
+" Set this option to change the Clang options for warnings for ObjCPP.
+if !exists('g:ale_objcpp_clang_options')
+    let g:ale_objcpp_clang_options = '-std=c++14 -Wall'
+endif
+
+function! ale_linters#objcpp#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 objective-c++ -fsyntax-only '
+    \   . '-iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ' ' . ale#Var(a:buffer, 'objcpp_clang_options') . ' -'
+endfunction
+
+call ale#linter#Define('objcpp', {
+\   'name': 'clang',
+\   'output_stream': 'stderr',
+\   'executable': 'clang++',
+\   'command_callback': 'ale_linters#objcpp#clang#GetCommand',
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\})

ale_linters/ocaml/merlin.vim

@@ -6,8 +6,7 @@ if !exists('g:merlin')
 endif
 
 function! ale_linters#ocaml#merlin#Handle(buffer, lines) abort
-  let l:errors = merlin#ErrorLocList()
-  return l:errors
+    return merlin#ErrorLocList()
 endfunction
 
 call ale#linter#Define('ocaml', {
@@ -16,4 +15,3 @@ call ale#linter#Define('ocaml', {
 \   'command': 'true',
 \   'callback': 'ale_linters#ocaml#merlin#Handle',
 \})
-

ale_linters/perl/perl.vim

@@ -1,32 +1,49 @@
 " Author: Vincent Lequertier <https://github.com/SkySymbol>
 " Description: This file adds support for checking perl syntax
 
+let g:ale_perl_perl_executable =
+\   get(g:, 'ale_perl_perl_executable', 'perl')
+
+let g:ale_perl_perl_options =
+\   get(g:, 'ale_perl_perl_options', '-c -Mwarnings -Ilib')
+
+function! ale_linters#perl#perl#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'perl_perl_executable')
+endfunction
+
+function! ale_linters#perl#perl#GetCommand(buffer) abort
+    return ale_linters#perl#perl#GetExecutable(a:buffer)
+    \   . ' ' . ale#Var(a:buffer, 'perl_perl_options')
+    \   . ' %t'
+endfunction
+
+let s:begin_failed_skip_pattern = '\v' . join([
+\   '^Compilation failed in require',
+\   '^Can''t locate',
+\], '|')
+
 function! ale_linters#perl#perl#Handle(buffer, lines) abort
     let l:pattern = '\(.\+\) at \(.\+\) line \(\d\+\)'
     let l:output = []
+    let l:basename = expand('#' . a:buffer . ':t')
 
-    for l:line in a:lines
-        let l:match = matchlist(l:line, l:pattern)
-
-        if len(l:match) == 0
-            continue
-        endif
-
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         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.
+        if ale#path#IsBufferPath(a:buffer, l:match[2])
+        \ && (
+        \   l:text !=# 'BEGIN failed--compilation aborted'
+        \   || empty(l:output)
+        \   || match(l:output[-1].text, s:begin_failed_skip_pattern) < 0
+        \ )
             call add(l:output, {
-        \   'bufnr': a:buffer,
             \   'lnum': l:line,
-        \   'vcol': 0,
-        \   'col': l:column,
             \   'text': l:text,
             \   'type': l:type,
-        \   'nr': -1,
             \})
+        endif
     endfor
 
     return l:output
@@ -34,8 +51,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,31 +1,29 @@
 " Author: Vincent Lequertier <https://github.com/SkySymbol>
 " Description: This file adds support for checking perl with perl critic
 
-function! ale_linters#perl#perlcritic#Handle(buffer, lines) abort
-    let l:pattern = '\(.\+\) at \(.\+\) line \(\d\+\)'
-    let l:output = []
+if !exists('g:ale_perl_perlcritic_showrules')
+    let g:ale_perl_perlcritic_showrules = 0
+endif
 
-    for l:line in a:lines
-        let l:match = matchlist(l:line, l:pattern)
-
-        if len(l:match) == 0
-            continue
+function! ale_linters#perl#perlcritic#GetCommand(buffer) abort
+    let l:critic_verbosity = '%l:%c %m\n'
+    if g:ale_perl_perlcritic_showrules
+        let l:critic_verbosity = '%l:%c %m [%p]\n'
     endif
 
-        let l:line = l:match[3]
-        let l:column = 1
-        let l:text = l:match[1]
-        let l:type = 'E'
+    return "perlcritic --verbose '". l:critic_verbosity . "' --nocolor"
+endfunction
 
-        " vcol is Needed to indicate that the column is a character.
+
+function! ale_linters#perl#perlcritic#Handle(buffer, lines) abort
+    let l:pattern = '\(\d\+\):\(\d\+\) \(.\+\)'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         call add(l:output, {
-        \   'bufnr': a:buffer,
-        \   'lnum': l:line,
-        \   'vcol': 0,
-        \   'col': l:column,
-        \   'text': l:text,
-        \   'type': l:type,
-        \   'nr': -1,
+        \   'lnum': l:match[1],
+        \   'col': l:match[2],
+        \   'text': l:match[3],
         \})
     endfor
 
@@ -36,6 +34,6 @@ call ale#linter#Define('perl', {
 \   'name': 'perlcritic',
 \   'executable': 'perlcritic',
 \   'output_stream': 'stdout',
-\   'command': 'perlcritic --verbose 3 --nocolor',
+\   'command_callback': 'ale_linters#perl#perlcritic#GetCommand',
 \   'callback': 'ale_linters#perl#perlcritic#Handle',
 \})

ale_linters/php/hack.vim

@@ -5,24 +5,15 @@ 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
-
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         if a:buffer != bufnr(l:match[1])
             continue
         endif
 
         call add(l:output, {
-        \   'bufnr': a:buffer,
         \   'lnum': l:match[2] + 0,
-        \   'vcol': 0,
         \   'col': l:match[3] + 0,
         \   'text': l:match[5],
-        \   'type': 'E',
         \})
     endfor
 

ale_linters/php/php.vim

@@ -1,30 +1,26 @@
-" 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
 
 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\+\)'
+    " Parse error:  syntax error, unexpected ';', expecting ']' in - on line 15
+    let l:pattern = '\v^%(Fatal|Parse) error:\s+(.+unexpected ''(.+)%(expecting.+)@<!''.*|.+) in - on line (\d+)'
     let l:output = []
 
-    for l:line in a:lines
-        let l:match = matchlist(l:line, l:pattern)
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:col = empty(l:match[2]) ? 0 : stridx(getline(l:match[3]), l:match[2]) + 1
+        let l:obj = {
+        \   'lnum': l:match[3] + 0,
+        \   'col': l:col,
+        \   'text': l:match[1],
+        \}
 
-        if len(l:match) == 0
-            continue
+        if l:col != 0
+            let l:obj.end_col = l:col + strlen(l:match[2]) - 1
         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,
-        \   'text': l:match[1],
-        \   'type': 'E',
-        \   'nr': -1,
-        \})
+        call add(l:output, l:obj)
     endfor
 
     return l:output
@@ -33,7 +29,7 @@ endfunction
 call ale#linter#Define('php', {
 \   'name': 'php',
 \   'executable': 'php',
-\   'output_stream': 'both',
-\   'command': 'php -l -d display_errors=1 --',
+\   'output_stream': 'stdout',
+\   'command': 'php -l -d error_reporting=E_ALL -d display_errors=1 --',
 \   'callback': 'ale_linters#php#php#Handle',
 \})

ale_linters/php/phpcs.vim

@@ -1,15 +1,28 @@
-" Author: jwilliams108 <https://github.com/jwilliams108>
+" Author: jwilliams108 <https://github.com/jwilliams108>, Eric Stern <https://github.com/firehed>
 " Description: phpcs for PHP files
 
+let g:ale_php_phpcs_standard = get(g:, 'ale_php_phpcs_standard', '')
+
+call ale#Set('php_phpcs_executable', 'phpcs')
+call ale#Set('php_phpcs_use_global', 0)
+
+function! ale_linters#php#phpcs#GetExecutable(buffer) abort
+    return ale#node#FindExecutable(a:buffer, 'php_phpcs', [
+    \   'vendor/bin/phpcs',
+    \   'phpcs'
+    \])
+endfunction
+
 function! ale_linters#php#phpcs#GetCommand(buffer) abort
-    let l:command = 'phpcs -s --report=emacs --stdin-path=%s'
+    let l:executable = ale_linters#php#phpcs#GetExecutable(a:buffer)
 
-    " This option can be set to change the standard used by phpcs
-    if exists('g:ale_php_phpcs_standard')
-        let l:command .= ' --standard=' . g:ale_php_phpcs_standard
-    endif
+    let l:standard = ale#Var(a:buffer, 'php_phpcs_standard')
+    let l:standard_option = !empty(l:standard)
+    \   ? '--standard=' . l:standard
+    \   : ''
 
-    return l:command
+    return ale#Escape(l:executable)
+    \   . ' -s --report=emacs --stdin-path=%s ' . l:standard_option
 endfunction
 
 function! ale_linters#php#phpcs#Handle(buffer, lines) abort
@@ -19,25 +32,15 @@ function! ale_linters#php#phpcs#Handle(buffer, lines) abort
     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
-
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         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
 
@@ -46,7 +49,7 @@ endfunction
 
 call ale#linter#Define('php', {
 \   'name': 'phpcs',
-\   'executable': 'phpcs',
+\   'executable_callback': 'ale_linters#php#phpcs#GetExecutable',
 \   'command_callback': 'ale_linters#php#phpcs#GetCommand',
 \   'callback': 'ale_linters#php#phpcs#Handle',
 \})

ale_linters/php/phpmd.vim

@@ -0,0 +1,36 @@
+" 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#GetCommand(buffer) abort
+    return 'phpmd %s text '
+    \   . ale#Var(a:buffer, 'php_phpmd_ruleset')
+    \   . ' --ignore-violations-on-exit %t'
+endfunction
+
+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:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'lnum': l:match[1] + 0,
+        \   'text': l:match[2],
+        \   'type': 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('php', {
+\   'name': 'phpmd',
+\   'executable': 'phpmd',
+\   'command_callback': 'ale_linters#php#phpmd#GetCommand',
+\   '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#unix#HandleAsWarning',
+\})

ale_linters/pug/puglint.vim

@@ -5,6 +5,6 @@ call ale#linter#Define('pug', {
 \   'name': 'puglint',
 \   'executable': 'pug-lint',
 \   'output_stream': 'stderr',
-\   'command': g:ale#util#stdin_wrapper . ' .pug pug-lint -r inline',
-\   'callback': 'ale#handlers#HandleUnixFormatAsError',
+\   'command': 'pug-lint -r inline %t',
+\   'callback': 'ale#handlers#unix#HandleAsError',
 \})

ale_linters/puppet/puppet.vim

@@ -7,22 +7,11 @@ function! ale_linters#puppet#puppet#Handle(buffer, lines) abort
     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
-
-        " vcol is needed to indicate that the column is a character
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
         call add(l:output, {
-        \   'bufnr': a:buffer,
         \   'lnum': l:match[2] + 0,
-        \   'vcol': 0,
         \   'col': l:match[3] + 0,
         \   'text': l:match[1],
-        \   'type': 'E',
-        \   'nr': -1,
         \})
     endfor
 
@@ -33,6 +22,6 @@ call ale#linter#Define('puppet', {
 \   'name': 'puppet',
 \   'executable': 'puppet',
 \   'output_stream': 'stderr',
-\   'command': g:ale#util#stdin_wrapper . ' .pp puppet parser validate --color=false',
+\   'command': 'puppet parser validate --color=false %t',
 \   'callback': 'ale_linters#puppet#puppet#Handle',
 \})

ale_linters/puppet/puppetlint.vim

@@ -1,8 +1,26 @@
-" Author: Alexander Olofsson <alexander.olofsson@liu.se>
+" Author: Alexander Olofsson <alexander.olofsson@liu.se>, Robert Flechtner <flechtner@chemmedia.de>
+" Description: puppet-lint for puppet files
+
+let g:ale_puppet_puppetlint_executable =
+\   get(g:, 'ale_puppet_puppetlint_executable', 'puppet-lint')
+
+let g:ale_puppet_puppetlint_options =
+\   get(g:, 'ale_puppet_puppetlint_options', '--no-autoloader_layout-check')
+
+function! ale_linters#puppet#puppetlint#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'puppet_puppetlint_executable')
+endfunction
+
+function! ale_linters#puppet#puppetlint#GetCommand(buffer) abort
+    return ale_linters#puppet#puppetlint#GetExecutable(a:buffer)
+    \   . ' ' . ale#Var(a:buffer, 'puppet_puppetlint_options')
+    \   . ' --log-format "-:%{line}:%{column}: %{kind}: [%{check}] %{message}"'
+    \   . ' %t'
+endfunction
 
 call ale#linter#Define('puppet', {
 \   'name': 'puppetlint',
-\   'executable': 'puppet-lint',
-\   'command': g:ale#util#stdin_wrapper . ' .pp puppet-lint --no-autoloader_layout-check --log-format "-:%{line}:%{column}: %{kind}: [%{check}] %{message}"',
-\   'callback': 'ale#handlers#HandleGCCFormat',
+\   'executable_callback': 'ale_linters#puppet#puppetlint#GetExecutable',
+\   'command_callback': 'ale_linters#puppet#puppetlint#GetCommand',
+\   'callback': 'ale#handlers#gcc#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,
-\   'callback': 'ale#handlers#HandleUnixFormatAsError',
+\   'command': 'cython --warning-extra -o ' . g:ale#util#nul_file . ' %t',
+\   'callback': 'ale#handlers#unix#HandleAsError',
 \})

ale_linters/python/flake8.vim

@@ -4,15 +4,38 @@
 let g:ale_python_flake8_executable =
 \   get(g:, 'ale_python_flake8_executable', 'flake8')
 
-let g:ale_python_flake8_args =
-\   get(g:, 'ale_python_flake8_args', '')
+" Support an old setting as a fallback.
+let s:default_options = get(g:, 'ale_python_flake8_args', '')
+let g:ale_python_flake8_options =
+\   get(g:, 'ale_python_flake8_options', s:default_options)
+let g:ale_python_flake8_use_global = get(g:, 'ale_python_flake8_use_global', 0)
 
 " 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 = {}
 
+function! s:UsingModule(buffer) abort
+    return ale#Var(a:buffer, 'python_flake8_options') =~# ' *-m flake8'
+endfunction
+
 function! ale_linters#python#flake8#GetExecutable(buffer) abort
-    return g:ale_python_flake8_executable
+    if !s:UsingModule(a:buffer) && !ale#Var(a:buffer, 'python_flake8_use_global')
+        let l:virtualenv = ale#python#FindVirtualenv(a:buffer)
+
+        if !empty(l:virtualenv)
+            let l:ve_flake8 = l:virtualenv . '/bin/flake8'
+
+            if executable(l:ve_flake8)
+                return l:ve_flake8
+            endif
+        endif
+    endif
+
+    return ale#Var(a:buffer, 'python_flake8_executable')
+endfunction
+
+function! ale_linters#python#flake8#ClearVersionCache() abort
+    let s:version_cache = {}
 endfunction
 
 function! ale_linters#python#flake8#VersionCheck(buffer) abort
@@ -25,7 +48,10 @@ function! ale_linters#python#flake8#VersionCheck(buffer) abort
         return ''
     endif
 
-    return ale_linters#python#flake8#GetExecutable(a:buffer) . ' --version'
+    let l:executable = ale#Escape(ale_linters#python#flake8#GetExecutable(a:buffer))
+    let l:module_string = s:UsingModule(a:buffer) ? ' -m flake8' : ''
+
+    return l:executable . l:module_string . ' --version'
 endfunction
 
 " Get the flake8 version from the output, or the cache.
@@ -58,11 +84,81 @@ function! ale_linters#python#flake8#GetCommand(buffer, version_output) abort
     " 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'
+    \   ? ' --stdin-display-name %s'
     \   : ''
 
-    return ale_linters#python#flake8#GetExecutable(a:buffer)
-    \   . ' ' . g:ale_python_flake8_args . ' ' . l:display_name_args . ' -'
+    let l:options = ale#Var(a:buffer, 'python_flake8_options')
+
+    return ale#Escape(ale_linters#python#flake8#GetExecutable(a:buffer))
+    \   . (!empty(l:options) ? ' ' . l:options : '')
+    \   . l:display_name_args . ' -'
+endfunction
+
+let s:end_col_pattern_map = {
+\   'F405': '\(.\+\) may be undefined',
+\   'F821': 'undefined name ''\([^'']\+\)''',
+\   'F999': '^''\([^'']\+\)''',
+\   'F841': 'local variable ''\([^'']\+\)''',
+\}
+
+function! ale_linters#python#flake8#Handle(buffer, lines) abort
+    for l:line in a:lines[:10]
+        if match(l:line, '^Traceback') >= 0
+            return [{
+            \   'lnum': 1,
+            \   'text': 'An exception was thrown. See :ALEDetail',
+            \   'detail': join(a:lines, "\n"),
+            \}]
+        endif
+    endfor
+
+    " Matches patterns line the following:
+    "
+    " Matches patterns line the following:
+    "
+    " stdin:6:6: E111 indentation is not a multiple of four
+    let l:pattern = '\v^[a-zA-Z]?:?[^:]+:(\d+):?(\d+)?: ([[:alnum:]]+) (.*)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:code = l:match[3]
+
+        if (l:code ==# 'W291' || l:code ==# 'W293')
+        \ && !ale#Var(a:buffer, 'warn_about_trailing_whitespace')
+            " Skip warnings for trailing whitespace if the option is off.
+            continue
+        endif
+
+        let l:item = {
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:match[2] + 0,
+        \   'text': l:code . ': ' . l:match[4],
+        \   'type': 'W',
+        \}
+
+        if l:code[:0] ==# 'F' || l:code ==# 'E999'
+            let l:item.type = 'E'
+        elseif l:code[:0] ==# 'E'
+            let l:item.type = 'E'
+            let l:item.sub_type = 'style'
+        elseif l:code[:0] ==# 'W'
+            let l:item.sub_type = 'style'
+        endif
+
+        let l:end_col_pattern = get(s:end_col_pattern_map, l:code, '')
+
+        if !empty(l:end_col_pattern)
+            let l:end_col_match = matchlist(l:match[4], l:end_col_pattern)
+
+            if !empty(l:end_col_match)
+                let l:item.end_col = l:item.col + len(l:end_col_match[1]) - 1
+            endif
+        endif
+
+        call add(l:output, l:item)
+    endfor
+
+    return l:output
 endfunction
 
 call ale#linter#Define('python', {
@@ -70,7 +166,7 @@ call ale#linter#Define('python', {
 \   'executable_callback': 'ale_linters#python#flake8#GetExecutable',
 \   'command_chain': [
 \       {'callback': 'ale_linters#python#flake8#VersionCheck'},
-\       {'callback': 'ale_linters#python#flake8#GetCommand'},
+\       {'callback': 'ale_linters#python#flake8#GetCommand', 'output_stream': 'both'},
 \   ],
-\   'callback': 'ale#handlers#HandlePEP8Format',
+\   'callback': 'ale_linters#python#flake8#Handle',
 \})

ale_linters/python/mypy.vim

@@ -1,24 +1,30 @@
 " Author: Keith Smiley <k@keith.so>, w0rp <devw0rp@gmail.com>
 " Description: mypy support for optional python typechecking
 
+let g:ale_python_mypy_executable =
+\   get(g:, 'ale_python_mypy_executable', 'mypy')
 let g:ale_python_mypy_options = get(g:, 'ale_python_mypy_options', '')
+let g:ale_python_mypy_use_global = get(g:, 'ale_python_mypy_use_global', 0)
 
-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 l:automatic_stubs_command
-    \   . g:ale#util#stdin_wrapper
-    \   . ' .py mypy --show-column-numbers '
-    \   . g:ale_python_mypy_options
+function! ale_linters#python#mypy#GetExecutable(buffer) abort
+    return ale#python#FindExecutable(a:buffer, 'python_mypy', ['/bin/mypy'])
 endfunction
 
-let s:path_pattern = '[a-zA-Z]\?\\\?:\?[[:alnum:]/\.\-_]\+'
+function! ale_linters#python#mypy#GetCommand(buffer) abort
+    let l:project_root = ale#python#FindProjectRoot(a:buffer)
+    let l:cd_command = !empty(l:project_root)
+    \   ? ale#path#CdString(l:project_root)
+    \   : ''
+    let l:executable = ale_linters#python#mypy#GetExecutable(a:buffer)
 
-function! g:ale_linters#python#mypy#Handle(buffer, lines) abort
+    return l:cd_command
+    \   . ale#Escape(l:executable)
+    \   . ' --show-column-numbers '
+    \   . ale#Var(a:buffer, 'python_mypy_options')
+    \   . ' --shadow-file %s %t %s'
+endfunction
+
+function! 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'
@@ -26,39 +32,29 @@ function! g:ale_linters#python#mypy#Handle(buffer, lines) abort
     " 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:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+):?(\d+)?: (error|warning): (.+)$'
     let l:output = []
+    let l:buffer_filename = expand('#' . a:buffer . ':p')
 
-    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.
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        if l:buffer_filename[-len(l:match[1]):] !=# l:match[1]
             continue
         endif
 
         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] =~# 'error' ? 'E' : 'W',
-        \   'nr': -1,
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'type': l:match[4] =~# 'error' ? 'E' : 'W',
+        \   'text': l:match[5],
         \})
     endfor
 
     return l:output
 endfunction
 
-call g:ale#linter#Define('python', {
+call ale#linter#Define('python', {
 \   'name': 'mypy',
-\   'executable': 'mypy',
+\   'executable_callback': 'ale_linters#python#mypy#GetExecutable',
 \   'command_callback': 'ale_linters#python#mypy#GetCommand',
 \   'callback': 'ale_linters#python#mypy#Handle',
 \})

ale_linters/python/pylint.vim

@@ -7,20 +7,68 @@ let g:ale_python_pylint_executable =
 let g:ale_python_pylint_options =
 \   get(g:, 'ale_python_pylint_options', '')
 
+let g:ale_python_pylint_use_global = get(g:, 'ale_python_pylint_use_global', 0)
+
 function! ale_linters#python#pylint#GetExecutable(buffer) abort
-    return g:ale_python_pylint_executable
+    if !ale#Var(a:buffer, 'python_pylint_use_global')
+        let l:virtualenv = ale#python#FindVirtualenv(a:buffer)
+
+        if !empty(l:virtualenv)
+            let l:ve_pylint = l:virtualenv . '/bin/pylint'
+
+            if executable(l:ve_pylint)
+                return l:ve_pylint
+            endif
+        endif
+    endif
+
+    return ale#Var(a:buffer, 'python_pylint_executable')
 endfunction
 
 function! ale_linters#python#pylint#GetCommand(buffer) abort
-    return g:ale#util#stdin_wrapper . ' .py '
-    \   . ale_linters#python#pylint#GetExecutable(a:buffer)
-    \   . ' ' . g:ale_python_pylint_options
-    \   . ' --output-format text --msg-template="{path}:{line}:{column}: {msg_id} {msg}" --reports n'
+    return ale#Escape(ale_linters#python#pylint#GetExecutable(a:buffer))
+    \   . ' ' . ale#Var(a:buffer, 'python_pylint_options')
+    \   . ' --output-format text --msg-template="{path}:{line}:{column}: {msg_id} ({symbol}) {msg}" --reports n'
+    \   . ' %s'
+endfunction
+
+function! ale_linters#python#pylint#Handle(buffer, lines) abort
+    " Matches patterns like the following:
+    "
+    " test.py:4:4: W0101 (unreachable) Unreachable code
+    let l:pattern = '\v^[^:]+:(\d+):(\d+): ([[:alnum:]]+) \(([^(]*)\) (.*)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        "let l:failed = append(0, l:match)
+        let l:code = l:match[3]
+
+        if (l:code ==# 'C0303')
+        \ && !ale#Var(a:buffer, 'warn_about_trailing_whitespace')
+            " Skip warnings for trailing whitespace if the option is off.
+            continue
+        endif
+
+        if l:code ==# 'I0011'
+            " Skip 'Locally disabling' message
+             continue
+        endif
+
+        call add(l:output, {
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:match[2] + 1,
+        \   'text': l:code . ': ' . l:match[5] . ' (' . l:match[4] . ')',
+        \   'type': l:code[:0] ==# 'E' ? 'E' : 'W',
+        \})
+    endfor
+
+    return l:output
 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',
+\   'callback': 'ale_linters#python#pylint#Handle',
+\   'lint_file': 1,
 \})

ale_linters/reason/merlin.vim

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

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#unix#HandleAsWarning',
+\})

ale_linters/ruby/brakeman.vim

@@ -0,0 +1,72 @@
+" Author: Eddie Lebow https://github.com/elebow
+" Description: Brakeman, a static analyzer for Rails security
+
+let g:ale_ruby_brakeman_options =
+\   get(g:, 'ale_ruby_brakeman_options', '')
+
+function! ale_linters#ruby#brakeman#Handle(buffer, lines) abort
+    let l:result = json_decode(join(a:lines, ''))
+
+    let l:output = []
+
+    for l:warning in l:result.warnings
+        " Brakeman always outputs paths relative to the Rails app root
+        let l:rails_root = s:FindRailsRoot(a:buffer)
+        let l:warning_file = l:rails_root . '/' . l:warning.file
+
+        if !ale#path#IsBufferPath(a:buffer, l:warning_file)
+          continue
+        endif
+
+        let l:text = l:warning.warning_type . ' ' . l:warning.message . ' (' . l:warning.confidence . ')'
+        let l:line = l:warning.line != v:null ? l:warning.line : 1
+
+        call add(l:output, {
+        \    'lnum': l:line,
+        \    'type': 'W',
+        \    'text': l:text,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+function! ale_linters#ruby#brakeman#GetCommand(buffer) abort
+    let l:rails_root = s:FindRailsRoot(a:buffer)
+
+    if l:rails_root ==? ''
+        return ''
+    endif
+
+    return 'brakeman -f json -q '
+    \    . ale#Var(a:buffer, 'ruby_brakeman_options')
+    \    . ' -p ' . ale#Escape(l:rails_root)
+endfunction
+
+function! s:FindRailsRoot(buffer) abort
+    " Find the nearest dir contining "app", "db", and "config", and assume it is
+    " the root of a Rails app.
+    for l:name in ['app', 'config', 'db']
+        let l:dir = fnamemodify(
+        \   ale#path#FindNearestDirectory(a:buffer, l:name),
+        \   ':h:h'
+        \)
+
+        if l:dir !=# '.'
+        \&& isdirectory(l:dir . '/app')
+        \&& isdirectory(l:dir . '/config')
+        \&& isdirectory(l:dir . '/db')
+            return l:dir
+        endif
+    endfor
+
+    return ''
+endfunction
+
+call ale#linter#Define('ruby', {
+\    'name': 'brakeman',
+\    'executable': 'brakeman',
+\    'command_callback': 'ale_linters#ruby#brakeman#GetCommand',
+\    'callback': 'ale_linters#ruby#brakeman#Handle',
+\    'lint_file': 1,
+\})

ale_linters/ruby/reek.vim

@@ -0,0 +1,53 @@
+" Author: Eddie Lebow https://github.com/elebow
+" Description: Reek, a code smell detector for Ruby files
+
+let g:ale_ruby_reek_show_context =
+\   get(g:, 'ale_ruby_reek_show_context', 0)
+
+let g:ale_ruby_reek_show_wiki_link =
+\   get(g:, 'ale_ruby_reek_show_wiki_link', 0)
+
+function! ale_linters#ruby#reek#Handle(buffer, lines) abort
+    if len(a:lines) == 0
+        return []
+    endif
+
+    let l:errors = json_decode(a:lines[0])
+
+    let l:output = []
+
+    for l:error in l:errors
+        for l:location in l:error.lines
+            call add(l:output, {
+            \    'lnum': l:location,
+            \    'type': 'W',
+            \    'text': s:BuildText(a:buffer, l:error),
+            \})
+        endfor
+    endfor
+
+    return l:output
+endfunction
+
+function! s:BuildText(buffer, error) abort
+    let l:text = a:error.smell_type . ':'
+
+    if ale#Var(a:buffer, 'ruby_reek_show_context')
+        let l:text .= ' ' . a:error.context
+    endif
+
+    let l:text .= ' ' . a:error.message
+
+    if ale#Var(a:buffer, 'ruby_reek_show_wiki_link')
+        let l:text .= ' [' . a:error.wiki_link . ']'
+    endif
+
+    return l:text
+endfunction
+
+call ale#linter#Define('ruby', {
+\    'name': 'reek',
+\    'executable': 'reek',
+\    'command': 'reek -f json --no-progress --no-color',
+\    'callback': 'ale_linters#ruby#reek#Handle',
+\})