Ignore compiled files from newer versions

javac linter: fix handling of error messages containing ':' character

.appveyor.yml

@@ -0,0 +1,40 @@
+---
+# Disabling building for AppVeyor. We are just testing things.
+build: false
+clone_depth: 10
+# Use the directory C:\testplugin so test directories will mostly work.
+clone_folder: C:\testplugin
+
+# Cache the vim and vader directories between builds.
+cache:
+  - C:\vim -> .appveyor.yml
+  - C:\vader -> .appveyor.yml
+
+init:
+  # Stop git from changing newlines
+  - git config --global core.autocrlf input
+
+install:
+  # Download and unpack Vim
+  - ps: >-
+      if (!(Test-Path -Path C:\vim)){
+        Add-Type -A System.IO.Compression.FileSystem
+        Invoke-WebRequest ftp://ftp.vim.org/pub/vim/pc/vim80-586w32.zip `
+          -OutFile C:\vim.zip
+        [IO.Compression.ZipFile]::ExtractToDirectory('C:\vim.zip', 'C:\vim')
+        Invoke-WebRequest ftp://ftp.vim.org/pub/vim/pc/vim80-586rt.zip `
+          -OutFile C:\rt.zip
+        [IO.Compression.ZipFile]::ExtractToDirectory('C:\rt.zip', 'C:\vim')
+      }
+  # Clone Vader and check out the commit we want
+  - ps: >-
+      if (!(Test-Path -Path C:\vader)){
+        git clone https://github.com/junegunn/vader.vim C:\vader 2> $null
+        cd C:\vader
+        git checkout -qf c6243dd81c98350df4dec608fa972df98fa2a3af 2> $null
+      }
+
+test_script:
+  - cd C:\testplugin
+  - 'C:\vim\vim\vim80\vim.exe -u test\vimrc "+Vader!
+    test/*.vader test/*/*.vader test/*/*/*.vader test/*/*/*.vader"'

.editorconfig

@@ -0,0 +1,14 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# Top-most EditorConfig file
+root = true
+
+# Match and apply these rules for all file
+# types you open in your code editor
+[*]
+# Unix-style newlines
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true

.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,13 @@
 .* export-ignore
+/CODE_OF_CONDUCT.md export-ignore
 /CONTRIBUTING.md export-ignore
 /Dockerfile export-ignore
+/ISSUE_TEMPLATE export-ignore
+/ISSUE_TEMPLATE.md export-ignore
 /Makefile export-ignore
+/PULL_REQUEST_TEMPLATE.md export-ignore
 /README.md export-ignore
 /img export-ignore
+/run-tests export-ignore
+/run-tests.bat export-ignore
 /test export-ignore

.github/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.

.github/CONTRIBUTING.md

@@ -0,0 +1,25 @@
+## Guidelines
+
+Have fun, and work on whatever floats your boat. Take It Easy :tm:.
+
+For help with contributing to ALE, see `:help ale-development` in Vim, or view
+the help file online [here](/doc/ale-development.txt).
+
+## Creating Issues
+
+Before creating any issues, please look through the current list of issues and
+pull requests, and ensure that the issue hasn't already been reported. If an
+issue has already been reported, but you have some new insight, please add
+a comment to the existing issue.
+
+Please read the FAQ in the README before creating any issues. A feature
+you desire may already exist and be documented, or the FAQ might explain
+how to solve a problem you have already.
+
+Please try and describe any issues reported with as much detail as you can
+provide about your Vim version, the linter you were trying to run, your
+operating system, or any other information you think might be helpful.
+
+Please describe your issue in clear, grammatically correct, and easy to
+understand English. You are more likely to see an issue resolved if others
+can understand you.

.github/ISSUE_TEMPLATE/report-a-bug.md

@@ -0,0 +1,45 @@
+---
+name: Report a bug
+about: Report a bug with ALE.
+
+---
+
+<!--
+  This is the template for reporting ALE bugs. Make sure you try updating ALE
+  to a more recent version before reporting a bug. Look through existing bug
+  reports for similar issues before reporting a new one. Don't leave comments
+  about new bugs in the comment section for old issues.
+
+  Make sure to try disabling other plugins and trying to repeat your bug before
+  reporting it in ALE. Some times problems can arise when two plugins are used
+  together, but often your issues might be problems with other plugins.
+-->
+
+## Information
+
+**VIM version**
+
+<!-- Paste just the first two lines of :version here. -->
+
+Operating System: <!-- Describe your operating system version. -->
+
+## What went wrong
+
+<!-- Describe what went wrong here. Be specific. -->
+
+Something went wrong in specifically this place, and I also searched through both open and closed issues for the same problem before reporting a bug here.
+
+Are you having trouble configuring ALE? Try asking for help on [Stack Exchange](https://vi.stackexchange.com/) or perhaps on [Reddit](https://www.reddit.com/r/vim/) instead. The GitHub issue tracker should be used for reporting bugs or asking for new features.
+
+## Reproducing the bug
+
+<!-- Write a list of steps below. -->
+
+1. I did this.
+2. Then this happened.
+
+### :ALEInfo
+
+<!-- Paste the output of :ALEInfo here. Try :ALEInfoToClipboard -->
+<!-- Make sure to run :ALEInfo from the buffer where the bug occurred. -->
+<!-- Read the output. You might figure out what went wrong yourself. -->

.github/ISSUE_TEMPLATE/suggest-a-new-linter-or-fixer.md

@@ -0,0 +1,20 @@
+---
+name: Suggest a new linter or fixer
+about: Suggest a new tool ALE can officially integrate with.
+
+---
+
+<!--
+  Write "Add support for foobar" as the issue title, or similar.
+
+  Fill out the details below.
+-->
+
+**Name:** foobar
+**URL:** https://foo.bar.com
+
+<!--
+  Write a description of the tool, and add any other information you think might
+  be helpful. Consider creating a pull request to add support for the tool
+  yourself.
+-->

.github/ISSUE_TEMPLATE/suggest-an-improvement.md

@@ -0,0 +1,7 @@
+---
+name: Suggest an improvement
+about: Suggest some way to improve ALE, or add a new feature.
+
+---
+
+<!-- There's no fixed format for feature requests. Just add your thoughts. -->

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,13 @@
+<!--
+Before creating a pull request, do the following.
+
+* Read the Contributing guide linked above first.
+* Read the documentation that comes with ALE with `:help ale-dev`.
+
+Have fun!
+-->
+
+Where are the tests? Have you added tests? Have you updated the tests? Read the
+comment above and the documentation referenced in it first. Write tests!
+
+Seriously, read `:help ale-dev` and write tests.

.gitignore

@@ -1,4 +1,11 @@
-/init.vim
-/doc/tags
-.*
+!.editorconfig
 *.obj
+# Ignore all hidden files everywhere.
+# Use `git add -f` to add hidden files.
+.*
+__pycache__
+*.pyc
+/doc/tags
+/init.vim
+/test/ale-info-test-file
+tags

.travis.yml

@@ -2,6 +2,11 @@
 sudo: required
 services:
     - docker
-language: python
+language: generic
+env:
+    - OPTIONS=--vim-80-only
+    - OPTIONS=--vim-81-only
+    - OPTIONS=--neovim-only
+    - OPTIONS=--linters-only
 script: |
-    make test
+    ./run-tests -v $OPTIONS

CONTRIBUTING.md

@@ -1,61 +0,0 @@
-# Contributing to ALE
-
-1. [Guidelines](#guidelines)
-2. [Creating Pull Requests](#pull-requests)
-3. [Creating Pull Requests](#compiling)
-
-<a name="guidelines"></a>
-
-# 1. Guidelines
-
-Have fun, and work on whatever floats your boat. Take It Easy :tm:.
-
-<a name="pull-requests"></a>
-
-# 2. Creating Pull Requests
-
-For code you write, make sure to credit yourself at the top of files you add, and probably those you modify. You can write
-some comments at the top of your VIM files.
-
-```vim
-" Author: John Smith <john.smith@gmail.com>
-" Description: This file adds support for awesomelinter to the best language ever.
-```
-
-If you want to credit multiple authors, you can comma separate them.
-
-```vim
-" Author: John Smith <john.smith@gmail.com>, Jane Doe <https://jane-doe.info>
-```
-
-# 2.1. Adding a New Linter
-
-If you add a new linter, look for existing handlers first in the [handlers.vim](plugin/ale/handlers.vim) file. One of the handlers
-there may already be able to handle your lines of output. If you find that your new linter replicates an existing error handler,
-consider pulling it up into the [handlers.vim](plugin/ale/handlers.vim) file, and use the generic handler in both places.
-
-When you add a linter, make sure the language for the linter and the linter itself are present in the table in the
-[README.md](README.md) file and in the Vim [help file](doc/ale.txt). The programs and linters are sorted alphabetically in the
-table and list.
-
-# 2.2. 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). Follow the format of other options in each. Global options should appear in the README
-file, and in the relevant section in the help file, and options specific to a particular linter should go in the section
-for that linter.
-
-<a name="compiling"></a>
-
-# 3. Compiling the Windows stdin wrapper
-
-To compile the stdin wrapper program for Windows, when updating the D program, you will need to compile the program with
-[LDC](https://github.com/ldc-developers/ldc) in release mode. Download and install the Community edition of Visual Studio
-from [the Visual Studio website](https://www.visualstudio.com/downloads/) first before installing LDC. LDC typically comes in
-a ZIP you can just extract somewhere.
-
-Make sure to compile with the 32-bit architecture flag, otherwise the EXE will not run on 32-bit machines.
-
-```
-ldc2 -m32 -Oz -release stdin_wrapper.d -of=stdin-wrapper.exe
-```

Dockerfile

@@ -1,20 +1,20 @@
 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 v8.1.0204 -build \
+                -tag neovim:v0.2.0 -build \
+                -tag neovim:v0.3.0 -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 pip install vim-vint==0.3.15
 
 RUN git clone https://github.com/junegunn/vader.vim vader && \
     cd vader && git checkout c6243dd81c98350df4dec608fa972df98fa2a3af

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2016, w0rp <devw0rp@gmail.com>
+Copyright (c) 2016-2018, w0rp <devw0rp@gmail.com>
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

Makefile

@@ -1,33 +0,0 @@
-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; \
-	docker run -a stdout $(DOCKER_FLAGS) vint -s /testplugin | sed s:^/testplugin/:: || EXIT=$$?; \
-	echo; \
-	echo; \
-	exit $$EXIT;
-
-.DEFAULT_GOAL := test

README.md

@@ -1,11 +1,13 @@
-# Asynchronous Lint Engine [![Build Status](https://travis-ci.org/w0rp/ale.svg?branch=master)](https://travis-ci.org/w0rp/ale)
+# Asynchronous Lint Engine [![Travis CI Build Status](https://travis-ci.org/w0rp/ale.svg?branch=master)](https://travis-ci.org/w0rp/ale) [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/r0ef1xu8xjmik58d/branch/master?svg=true)](https://ci.appveyor.com/project/w0rp/ale) [![Join the chat at https://gitter.im/vim-ale/Lobby](https://badges.gitter.im/vim-ale/Lobby.svg)](https://gitter.im/vim-ale/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
 
 ![ALE Logo by Mark Grealish - https://www.bhalash.com/](img/logo.jpg?raw=true)
 
-ALE (Asynchronous Lint Engine) is a plugin for providing linting in NeoVim
-and Vim 8 while you edit your text files.
+ALE (Asynchronous Lint Engine) is a plugin for providing linting (checking
+syntax and semantics) in NeoVim 0.2.0+ and Vim 8 while you edit your text files,
+and acts as a Vim [Language Server Protocol](https://langserver.org/) client.
 
-![linting example](img/example.gif?raw=true)
+<img src="img/example.gif?raw=true" alt="A linting example with the darkspectrum color scheme in GVim." title="A linting example with the darkspectrum color scheme in GVim.">
 
 ALE makes use of NeoVim and Vim 8 job control functions and timers to
 run linters on the contents of text buffers and return errors as
@@ -15,57 +17,79 @@ back to a filesystem.
 
 In other words, this plugin allows you to lint while you type.
 
-## Supported Languages and Tools
+ALE offers support for fixing code with command line tools in a non-blocking
+manner with the `:ALEFix` feature, supporting tools in many languages, like
+`prettier`, `eslint`, `autopep8`, and more.
 
-This plugin supports the following languages and tools. All available
-tools will be run in combination, so they can be complementary.
+ALE acts as a "language client" to support a variety of Language Server Protocol
+features, including:
 
-<!--
-Keep the table rows sorted alphabetically by the language name,
-and the tools in the tools column sorted alphabetically by the tool
-name. That seems to be the fairest way to arrange this table.
--->
+* Diagnostics (via Language Server Protocol linters)
+* Go To Definition (`:ALEGoToDefinition`)
+* Completion (`let g:ale_completion_enabled = 1` before ALE is loaded)
+* Finding references (`:ALEFindReferences`)
+* Hover information (`:ALEHover`)
+* Symbol search (`:ALESymbolSearch`)
 
-| Language | Tools |
-| -------- | ----- |
-| Bash | [-n flag](https://www.gnu.org/software/bash/manual/bash.html#index-set), [shellcheck](https://www.shellcheck.net/) |
-| Bourne Shell | [-n flag](http://linux.die.net/man/1/sh), [shellcheck](https://www.shellcheck.net/) |
-| C | [gcc](https://gcc.gnu.org/) |
-| C++ (filetype cpp)| [gcc](https://gcc.gnu.org/) |
-| CoffeeScript | [coffee](http://coffeescript.org/), [coffeelint](https://www.npmjs.com/package/coffeelint) |
-| CSS | [csslint](http://csslint.net/) |
-| Cython (pyrex filetype) | [cython](http://cython.org/) |
-| D | [dmd](https://dlang.org/dmd-linux.html)^ |
-| Elixir | [credo](https://github.com/rrrene/credo) |
-| Fortran | [gcc](https://gcc.gnu.org/) |
-| Go | [gofmt -e](https://golang.org/cmd/gofmt/), [go vet](https://golang.org/cmd/vet/), [golint](https://godoc.org/github.com/golang/lint) |
-| Haskell | [ghc](https://www.haskell.org/ghc/), [hlint](https://hackage.haskell.org/package/hlint) |
-| HTML | [HTMLHint](http://htmlhint.com/), [tidy](http://www.html-tidy.org/) |
-| JavaScript | [eslint](http://eslint.org/), [jscs](http://jscs.info/), [jshint](http://jshint.com/) |
-| JSON | [jsonlint](http://zaa.ch/jsonlint/) |
-| Lua | [luacheck](https://github.com/mpeterv/luacheck) |
-| Perl | [perl -c](https://perl.org/), [perl-critic](https://metacpan.org/pod/Perl::Critic) |
-| PHP | [php -l](https://secure.php.net/), [phpcs](https://github.com/squizlabs/PHP_CodeSniffer) |
-| Pug | [pug-lint](https://github.com/pugjs/pug-lint) |
-| Python | [flake8](http://flake8.pycqa.org/en/latest/) |
-| Ruby | [rubocop](https://github.com/bbatsov/rubocop) |
-| SASS | [sass-lint](https://www.npmjs.com/package/sass-lint) |
-| SCSS | [sass-lint](https://www.npmjs.com/package/sass-lint), [scss-lint](https://github.com/brigade/scss-lint) |
-| Scala | [scalac](http://scala-lang.org) |
-| TypeScript | [tslint](https://github.com/palantir/tslint) |
-| Verilog | [iverilog](https://github.com/steveicarus/iverilog), [verilator](http://www.veripool.org/projects/verilator/wiki/Intro) |
-| Vim | [vint](https://github.com/Kuniwak/vint) |
-| YAML | [yamllint](https://yamllint.readthedocs.io/) |
+If you don't care about Language Server Protocol, ALE won't load any of the code
+for working with it unless needed. One of ALE's general missions is that you
+won't pay for the features that you don't use.
 
-*^ Supported only on Unix machines via a wrapper script.*
+If you enjoy this plugin, feel free to contribute or check out the author's
+other content at [w0rp.com](https://w0rp.com).
 
-If you would like to see support for more languages and tools, please
-[create an issue](https://github.com/w0rp/ale/issues)
-or [create a pull request](https://github.com/w0rp/ale/pulls).
-If your tool can read from stdin or you have code to suggest which is good,
-support can be happily added for more tools.
+## Table of Contents
 
-## Usage
+1. [Supported Languages and Tools](#supported-languages)
+2. [Usage](#usage)
+    1. [Linting](#usage-linting)
+    2. [Fixing](#usage-fixing)
+    3. [Completion](#usage-completion)
+    4. [Go To Definition](#usage-go-to-definition)
+    5. [Find References](#usage-find-references)
+    6. [Hovering](#usage-hover)
+    7. [Symbol Search](#usage-symbol-search)
+3. [Installation](#installation)
+    1. [Installation with Vim package management](#standard-installation)
+    2. [Installation with Pathogen](#installation-with-pathogen)
+    3. [Installation with Vundle](#installation-with-vundle)
+    4. [Installation with Vim-Plug](#installation-with-vim-plug)
+4. [Contributing](#contributing)
+5. [FAQ](#faq)
+    1. [How do I disable particular linters?](#faq-disable-linters)
+    2. [How can I keep the sign gutter open?](#faq-keep-signs)
+    3. [How can I change the signs ALE uses?](#faq-change-signs)
+    4. [How can I change or disable the highlights ALE uses?](#faq-change-highlights)
+    5. [How can I show errors or warnings in my statusline?](#faq-statusline)
+    6. [How can I show errors or warnings in my lightline?](#faq-lightline)
+    7. [How can I change the format for echo messages?](#faq-echo-format)
+    8. [How can I execute some code when ALE starts or stops linting?](#faq-autocmd)
+    9. [How can I navigate between errors quickly?](#faq-navigation)
+    10. [How can I run linters only when I save files?](#faq-lint-on-save)
+    11. [How can I use the quickfix list instead of the loclist?](#faq-quickfix)
+    12. [How can I check JSX files with both stylelint and eslint?](#faq-jsx-stylelint-eslint)
+    13. [How can I check Vue files with ESLint?](#faq-vue-eslint)
+    14. [Will this plugin eat all of my laptop battery power?](#faq-my-battery-is-sad)
+    15. [How can I configure my C or C++ project?](#faq-c-configuration)
+    16. [How can I configure ALE differently for different buffers?](#faq-buffer-configuration)
+    17. [How can I configure the height of the list in which ALE displays errors?](#faq-list-window-height)
+    18. [How can I see what ALE has configured for the current file?](#faq-get-info)
+
+<a name="supported-languages"></a>
+
+## 1. Supported Languages and Tools
+
+ALE supports a wide variety of languages and tools. See the
+[full list](supported-tools.md) in the
+[Supported Languages and Tools](supported-tools.md) page.
+
+<a name="usage"></a>
+
+## 2. Usage
+
+<a name="usage-linting"></a>
+
+### 2.i Linting
 
 Once this plugin is installed, while editing your files in supported
 languages and tools which have been correctly installed,
@@ -74,39 +98,263 @@ programs for checking the syntax and semantics of your programs. By default,
 linters will be re-run in the background to check your syntax when you open
 new buffers or as you make edits to your files.
 
-### Options
+The behaviour of linting can be configured with a variety of options,
+documented in [the Vim help file](doc/ale.txt). For more information on the
+options ALE offers, consult `:help ale-options` for global options and `:help
+ale-integration-options` for options specified to particular linters.
 
-A full list of options supported for configuring this plugin in your
-vimrc file for all given linters is as follows:
+<a name="usage-fixing"></a>
 
-| Option | Description | Default |
-| ------ | ----------- | ------- |
-| `g:ale_echo_cursor` | echo errors when the cursor is over them | `1` |
-| `g:ale_echo_msg_format` | string format to use for the echoed message | `'%s'` |
-| `g:ale_echo_msg_error_str` | string used for error severity in echoed message | `'Error'` |
-| `g:ale_echo_msg_warning_str` | string used for warning severity in echoed message | `'Warning'` |
-| `g:ale_lint_delay` | milliseconds to wait before linting | `200` |
-| `g:ale_linters` | a dictionary of linters to whitelist | _not set_ |
-| `g:ale_lint_on_enter` | lint when opening a file  | `1` |
-| `g:ale_lint_on_save` | lint when saving a file  | `0` |
-| `g:ale_lint_on_text_changed` | lint while typing  | `1` |
-| `g:ale_set_loclist` | set the loclist with errors | `1` |
-| `g:ale_set_signs` | set gutter signs with error markers | `has('signs')` |
-| `g:ale_sign_column_always` | always show the sign gutter | `0` |
-| `g:ale_sign_error` | the text to use for errors in the gutter | `'>>'` |
-| `g:ale_sign_offset` | an offset for sign ids | `1000000` |
-| `g:ale_sign_warning` | the text to use for warnings in the gutter | `'--'` |
-| `g:ale_statusline_format` | string format to use in statusline flag | `['%d error(s)', '%d warning(s)', 'OK']` |
-| `g:ale_warn_about_trailing_whitespace` | enable trailing whitespace warnings for some linters | `1` |
+### 2.ii Fixing
 
-### Selecting Particular Linters
+ALE can fix files with the `ALEFix` command. Functions need to be configured
+either in each buffer with a `b:ale_fixers`, or globally with `g:ale_fixers`.
 
-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
-`g:ale_linters` dictionary in your vimrc file mapping filetypes
-to lists of linters to run.
+The recommended way to configure fixers is to define a List in an ftplugin file.
 
 ```vim
+" In ~/.vim/ftplugin/javascript.vim, or somewhere similar.
+
+" Fix files with prettier, and then ESLint.
+let b:ale_fixers = ['prettier', 'eslint']
+" Equivalent to the above.
+let b:ale_fixers = {'javascript': ['prettier', 'eslint']}
+```
+
+You can also configure your fixers from vimrc using `g:ale_fixers`, before or
+after ALE has been loaded.
+
+A `*` in place of the filetype will apply a List of fixers to all files which
+do not match some filetype in the Dictionary.
+
+Note that using a plain List for `g:ale_fixers` is not supported.
+
+```vim
+" In ~/.vim/vimrc, or somewhere similar.
+let g:ale_fixers = {
+\   '*': ['remove_trailing_lines', 'trim_whitespace'],
+\   'javascript': ['eslint'],
+\}
+```
+
+If you want to automatically fix files when you save them, you need to turn
+a setting on in vimrc.
+
+```vim
+" Set this variable to 1 to fix files when you save them.
+let g:ale_fix_on_save = 1
+```
+
+The `:ALEFixSuggest` command will suggest some supported tools for fixing code.
+Both `g:ale_fixers` and `b:ale_fixers` can also accept functions, including
+lambda functions, as fixers, for fixing files with custom tools.
+
+See `:help ale-fix` for complete information on how to fix files with ALE.
+
+<a name="usage-completion"></a>
+
+### 2.iii Completion
+
+ALE offers some support for completion via hijacking of omnicompletion while you
+type. All of ALE's completion information must come from Language Server
+Protocol linters, or from `tsserver` for TypeScript.
+
+```vim
+" Enable completion where available.
+" This setting must be set before ALE is loaded.
+let g:ale_completion_enabled = 1
+```
+
+See `:help ale-completion` for more information.
+
+<a name="usage-go-to-definition"></a>
+
+### 2.iv Go To Definition
+
+ALE supports jumping to the definition of words under your cursor with the
+`:ALEGoToDefinition` command using any enabled Language Server Protocol linters
+and `tsserver`.
+
+See `:help ale-go-to-definition` for more information.
+
+<a name="usage-find-references"></a>
+
+### 2.v Find References
+
+ALE supports finding references for words under your cursor with the
+`:ALEFindReferences` command using any enabled Language Server Protocol linters
+and `tsserver`.
+
+See `:help ale-find-references` for more information.
+
+<a name="usage-hover"></a>
+
+### 2.vi Hovering
+
+ALE supports "hover" information for printing brief information about symbols at
+the cursor taken from Language Server Protocol linters and `tsserver` with the
+`ALEHover` command.
+
+The information can be displayed in a `balloon` tooltip in Vim or GVim by
+hovering your mouse over symbols. Mouse hovering is enabled by default in GVim,
+and needs to be configured for Vim 8.1+ in terminals.
+
+See `:help ale-hover` for more information.
+
+<a name="usage-symbol-search"></a>
+
+### 2.vii Symbol Search
+
+ALE supports searching for workspace symbols via Language Server Protocol
+linters with the `ALESymbolSearch` command.
+
+Search queries can be performed to find functions, types, and more which are
+similar to a given query string.
+
+See `:help ale-symbol-search` for more information.
+
+<a name="installation"></a>
+
+## 3. Installation
+
+To install this plugin, you should use one of the following methods.
+For Windows users, replace usage of the Unix `~/.vim` directory with
+`%USERPROFILE%\vimfiles`, or another directory if you have configured
+Vim differently. On Windows, your `~/.vimrc` file will be similarly
+stored in `%USERPROFILE%\_vimrc`.
+
+<a name="standard-installation"></a>
+
+### 3.i. Installation with Vim package management
+
+In Vim 8 and NeoVim, you can install plugins easily without needing to use
+any other tools. Simply clone the plugin into your `pack` directory.
+
+#### Vim 8 on Unix
+
+```bash
+mkdir -p ~/.vim/pack/git-plugins/start
+git clone https://github.com/w0rp/ale.git ~/.vim/pack/git-plugins/start/ale
+```
+
+#### NeoVim on Unix
+
+```bash
+mkdir -p ~/.local/share/nvim/site/pack/git-plugins/start
+git clone https://github.com/w0rp/ale.git ~/.local/share/nvim/site/pack/git-plugins/start/ale
+```
+
+#### Vim 8 on Windows
+
+```bash
+# Run these commands in the "Git for Windows" Bash terminal
+mkdir -p ~/vimfiles/pack/git-plugins/start
+git clone https://github.com/w0rp/ale.git ~/vimfiles/pack/git-plugins/start/ale
+```
+
+#### Generating Vim help files
+
+You can add the following line to your vimrc files to generate documentation
+tags automatically, if you don't have something similar already, so you can use
+the `:help` command to consult ALE's online documentation:
+
+```vim
+" Put these lines at the very end of your vimrc file.
+
+" Load all plugins now.
+" Plugins need to be added to runtimepath before helptags can be generated.
+packloadall
+" Load all of the helptags now, after plugins have been loaded.
+" All messages and errors will be ignored.
+silent! helptags ALL
+```
+
+<a name="installation-with-pathogen"></a>
+
+### 3.ii. Installation with Pathogen
+
+To install this module with [Pathogen](https://github.com/tpope/vim-pathogen),
+you should clone this repository to your bundle directory, and ensure
+you have the line `execute pathogen#infect()` in your `~/.vimrc` file.
+You can run the following commands in your terminal to do so:
+
+```bash
+cd ~/.vim/bundle
+git clone https://github.com/w0rp/ale.git
+```
+
+<a name="installation-with-vundle"></a>
+
+### 3.iii. Installation with Vundle
+
+You can install this plugin using [Vundle](https://github.com/VundleVim/Vundle.vim)
+by using the path on GitHub for this repository.
+
+```vim
+Plugin 'w0rp/ale'
+```
+
+See the Vundle documentation for more information.
+
+<a name="installation-with-vim-plug"></a>
+
+### 3.iiii. Installation with Vim-Plug
+
+You can install this plugin using [Vim-Plug](https://github.com/junegunn/vim-plug)
+by adding the GitHub path for this repository to your `~/.vimrc`
+and running `:PlugInstall`.
+
+```vim
+Plug 'w0rp/ale'
+```
+
+<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>
+
+## 5. FAQ
+
+<a name="faq-disable-linters"></a>
+
+### 5.i. How do I disable particular linters?
+
+By default, all available tools for all supported languages will be run. If you
+want to only select a subset of the tools, you can define `b:ale_linters` for a
+single buffer, or `g:ale_linters` globally.
+
+The recommended way to configure linters is to define a List in an ftplugin
+file.
+
+```vim
+" In ~/.vim/ftplugin/javascript.vim, or somewhere similar.
+
+" Enable ESLint only for JavaScript.
+let b:ale_linters = ['eslint']
+
+" Equivalent to the above.
+let b:ale_linters = {'javascript': ['eslint']}
+```
+
+You can also declare which linters you want to run in your vimrc file, before or
+after ALE has been loaded.
+
+```vim
+" In ~/.vim/vimrc, or somewhere similar.
 let g:ale_linters = {
 \   'javascript': ['eslint'],
 \}
@@ -117,19 +365,32 @@ be run for those languages, just as when the dictionary is not defined.
 Running many linters should not typically obstruct editing in Vim,
 as they will all be executed in separate processes simultaneously.
 
+If you don't want ALE to run anything other than what you've explicitly asked
+for, you can set `g:ale_linters_explicit` to `1`.
+
+```vim
+" Only run linters named in ale_linters settings.
+let g:ale_linters_explicit = 1
+```
+
 This plugin will look for linters in the [`ale_linters`](ale_linters) directory.
 Each directory within corresponds to a particular filetype in Vim, and each file
 in each directory corresponds to the name of a particular linter.
 
-### Always showing gutter
+<a name="faq-keep-signs"></a>
 
-You can keep the sign gutter open at all times by setting the `g:ale_sign_column_always` to 1
+### 5.ii. How can I keep the sign gutter open?
+
+You can keep the sign gutter open at all times by setting the
+`g:ale_sign_column_always` to 1
 
 ```vim
 let g:ale_sign_column_always = 1
 ```
 
-### Customize signs
+<a name="faq-change-signs"></a>
+
+### 5.iii. How can I change the signs ALE uses?
 
 Use these options to specify what text should be used for signs:
 
@@ -138,40 +399,111 @@ let g:ale_sign_error = '>>'
 let g:ale_sign_warning = '--'
 ```
 
-### Statusline
-
-You can use `ALEGetStatusLine()` to integrate ALE into vim statusline.
-To enable it, you should have in your `statusline` settings
+ALE sets some background colors automatically for warnings and errors
+in the sign gutter, with the names `ALEErrorSign` and `ALEWarningSign`.
+These colors can be customised, or even removed completely:
 
 ```vim
-%{ALEGetStatusLine()}
+highlight clear ALEErrorSign
+highlight clear ALEWarningSign
 ```
 
-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:
+<a name="faq-change-highlights"></a>
 
-- The 1st element is for errors
-- The 2nd element is for warnings
-- The 3rd element is for when no errors are detected
+### 5.iv. How can I change or disable the highlights ALE uses?
 
-e.g
+ALE's highlights problems with highlight groups which link to `SpellBad`,
+`SpellCap`, `error`, and `todo` groups by default. The characters that are
+highlighted depend on the linters being used, and the information provided to
+ALE.
+
+Highlighting can be disabled completely by setting `g:ale_set_highlights` to
+`0`.
 
 ```vim
-let g:ale_statusline_format = ['⨉ %d', '⚠ %d', '⬥ ok']
+" Set this in your vimrc file to disabling highlighting
+let g:ale_set_highlights = 0
 ```
 
-![Statusline with issues](img/issues.png)
-![Statusline with no issues](img/no_issues.png)
+You can control all of the highlights ALE uses, say if you are using a different
+color scheme which produces ugly highlights. For example:
 
+```vim
+highlight ALEWarning ctermbg=DarkMagenta
+```
 
-### Customize echoed message
+See `:help ale-highlights` for more information.
+
+<a name="faq-statusline"></a>
+
+### 5.v. How can I show errors or warnings in my statusline?
+
+[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
+" Set this. Airline will handle the rest.
+let g:airline#extensions#ale#enabled = 1
+```
+
+If you don't want to use vim-airline, you can implement your own statusline
+function without adding any other plugins. ALE provides some functions to
+assist in this endeavour, including:
+
+* `ale#statusline#Count`: Which returns the number of problems found by ALE
+  for a specified buffer.
+* `ale#statusline#FirstProblem`: Which returns a dictionary containing the
+  full loclist details of the first problem of a specified type found by ALE
+  in a buffer. (e.g. The first style warning in the current buffer.)
+  This can be useful for displaying more detailed information such as the
+  line number of the first problem in a file.
+
+Say you want to display all errors as one figure, and all non-errors as another
+figure. You can do the following:
+
+```vim
+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()}
+```
+
+See `:help ale#statusline#Count()` or `:help ale#statusline#FirstProblem()`
+for more information.
+
+<a name="faq-lightline"></a>
+
+### 5.vi. How can I show errors or warnings in my lightline?
+
+[lightline](https://github.com/itchyny/lightline.vim) does not have built-in
+support for ALE, nevertheless there is a plugin that adds this functionality: [maximbaz/lightline-ale](https://github.com/maximbaz/lightline-ale).
+
+For more information, check out the sources of that plugin, `:help ale#statusline#Count()` and [lightline documentation](https://github.com/itchyny/lightline.vim#advanced-configuration).
+
+<a name="faq-echo-format"></a>
+
+### 5.vii. How can I change the format for echo messages?
 
 There are 3 global options that allow customizing the echoed message.
 
 - `g:ale_echo_msg_format` where:
-  * `%s` is the error message itself
-  * `%linter%` is the linter name
-  * `%severity` is the severity type
+    * `%s` is the error message itself
+    * `%...code...%` is an optional error code, and most characters can be
+      written between the `%` characters.
+    * `%linter%` is the linter name
+    * `%severity%` is the severity type
 - `g:ale_echo_msg_error_str` is the string used for error severity.
 - `g:ale_echo_msg_warning_str` is the string used for warning severity.
 
@@ -187,58 +519,274 @@ Will give you:
 
 ![Echoed message](img/echo.png)
 
-## Installation
+See `:help g:ale_echo_msg_format` for more information.
 
-To install this plugin, you should use one of the following methods.
-For Windows users, replace usage of the Unix `~/.vim` directory with
-`%USERPROFILE%\_vim`, or another directory if you have configured
-Vim differently. On Windows, your `~/.vimrc` file will be similarly
-stored in `%USERPROFILE%\_vimrc`.
+<a name="faq-autocmd"></a>
 
-### Installation with Pathogen
+### 5.viii. How can I execute some code when ALE starts or stops linting?
 
-To install this module with [Pathogen](https://github.com/tpope/vim-pathogen),
-you should clone this repository to your bundle directory, and ensure
-you have the line `execute pathogen#infect()` in your `~/.vimrc` file.
-You can run the following commands in your terminal to do so:
-
-```bash
-cd ~/.vim/bundle
-git clone https://github.com/w0rp/ale.git
-```
-
-### Installation with Vundle
-
-You can install this plugin using [Vundle](https://github.com/VundleVim/Vundle.vim)
-by using the path on GitHub for this repository.
+ALE runs its own [autocmd](http://vimdoc.sourceforge.net/htmldoc/autocmd.html)
+events when a lint or fix cycle are started and stopped. There is also an event
+that runs when a linter job has been successfully started. These events can be
+used to call arbitrary functions during these respective parts of the ALE's
+operation.
 
 ```vim
-Plugin 'w0rp/ale'
+augroup YourGroup
+    autocmd!
+    autocmd User ALELintPre    call YourFunction()
+    autocmd User ALELintPost   call YourFunction()
+
+    autocmd User ALEJobStarted call YourFunction()
+
+    autocmd User ALEFixPre     call YourFunction()
+    autocmd User ALEFixPost    call YourFunction()
+augroup END
 ```
 
-See the Vundle documentation for more information.
+<a name="faq-navigation"></a>
 
-### Manual Installation
+### 5.ix. How can I navigate between errors quickly?
 
-For installation without a package manager, you can clone this git repository
-into a bundle directory as with pathogen, and add the repository to your
-runtime path yourself. First clone the repository.
-
-```bash
-cd ~/.vim/bundle
-git clone https://github.com/w0rp/ale.git
-```
-
-Then, modify your `~/.vimrc` file to add this plugin to your runtime path.
+ALE offers some commands with `<Plug>` keybinds for moving between warnings and
+errors quickly. You can map the keys Ctrl+j and Ctrl+k to moving between errors
+for example:
 
 ```vim
-set nocompatible
-filetype off
-
-let &runtimepath.=',~/.vim/bundle/ale'
-
-filetype plugin on
+nmap <silent> <C-k> <Plug>(ale_previous_wrap)
+nmap <silent> <C-j> <Plug>(ale_next_wrap)
 ```
 
-Because the author of this plugin is a weird nerd, this is his preferred
-installation method.
+For more information, consult the online documentation with
+`:help ale-navigation-commands`.
+
+<a name="faq-lint-on-save"></a>
+
+### 5.x. 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. 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_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>
+
+### 5.xi. How can I use the quickfix list instead of the loclist?
+
+The quickfix list can be enabled by turning the `g:ale_set_quickfix`
+option on. If you wish to also disable the loclist, you can disable
+the `g:ale_set_loclist` option.
+
+```vim
+" Write this in your vimrc file
+let g:ale_set_loclist = 0
+let g:ale_set_quickfix = 1
+```
+
+If you wish to show Vim windows for the loclist or quickfix items
+when a file contains warnings or errors, `g:ale_open_list` can be
+set to `1`. `g:ale_keep_list_window_open` can be set to `1`
+if you wish to keep the window open even after errors disappear.
+
+```vim
+let g:ale_open_list = 1
+" Set this if you want to.
+" This can be useful if you are combining ALE with
+" some other plugin which sets quickfix errors, etc.
+let g:ale_keep_list_window_open = 1
+```
+
+You can also set `let g:ale_list_vertical = 1` to open the windows vertically
+instead of the default horizontally.
+
+<a name="faq-jsx-stylelint-eslint"></a>
+
+### 5.xii. 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 a jsx.vim ftplugin file.
+
+```vim
+" In ~/.vim/ftplugin/jsx.vim, or somewhere similar.
+let b:ale_linter_aliases = ['css', 'javascript']
+let b:ale_linters = ['stylelint', 'eslint']
+```
+
+Or if you want, you can configure the linters from your vimrc file.
+
+```vim
+" In ~/.vim/vimrc, or somewhere similar.
+let g:ale_linter_aliases = {'jsx': ['css', 'javascript']}
+let g:ale_linters = {'jsx': ['stylelint', 'eslint']}
+```
+
+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-vue-eslint"></a>
+
+### 5.xiii. How can I check Vue files with ESLint?
+
+To check Vue files with ESLint, your ESLint project configuration file must be
+configured to use the [Vue plugin](https://github.com/vuejs/eslint-plugin-vue).
+After that, you need to configure ALE so it will run the JavaScript ESLint
+linter on your files. The settings you need are similar to the settings needed
+for checking JSX code with both stylelint and ESLint, in the previous section.
+
+```vim
+" In ~/.vim/ftplugin/vue.vim, or somewhere similar.
+
+" Run both javascript and vue linters for vue files.
+let b:ale_linter_aliases = ['javascript', 'vue']
+" Select the eslint and vls linters.
+let b:ale_linters = ['eslint', 'vls']
+```
+
+Run `:ALEInfo` to see which linters are available after telling ALE to run
+JavaScript linters on Vue files. Not all linters support checking Vue files.
+
+If you don't want to configure your linters in ftplugin files for some reason,
+you can configure them from your vimrc file instead.
+
+```vim
+" In ~/.vim/vimrc, or somewhere similar.
+let g:ale_linter_aliases = {'vue': ['vue', 'javascript']}
+let g:ale_linters = {'vue': ['eslint', 'vls']}
+```
+
+<a name="faq-my-battery-is-sad"></a>
+
+### 5.xiv. 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`.
+
+<a name="faq-c-configuration"></a>
+
+### 5.xv. How can I configure my C or C++ project?
+
+The structure of C and C++ projects varies wildly from project to project, with
+many different build tools being used for building them, and many different
+formats for project configuration files. ALE can run compilers easily, but
+ALE cannot easily detect which compiler flags to use.
+
+Some tools and build configurations can generate
+[compile_commands.json](https://clang.llvm.org/docs/JSONCompilationDatabase.html)
+files. The `cppcheck`, `clangcheck`, `clangtidy` and `cquery` linters can read
+these files for automatically determining the appropriate compiler flags to
+use.
+
+For linting with compilers like `gcc` and `clang`, and with other tools, you
+will need to tell ALE which compiler flags to use yourself. You can use
+different options for different projects with the `g:ale_pattern_options`
+setting.  Consult the documentation for that setting for more information.
+`b:ale_linters` can be used to select which tools you want to run, say if you
+want to use only `gcc` for one project, and only `clang` for another.
+
+You may also configure buffer-local settings for linters with project-specific
+vimrc files. [local_vimrc](https://github.com/LucHermitte/local_vimrc) can be
+used for executing local vimrc files which can be shared in your project.
+
+<a name="faq-buffer-configuration"></a>
+
+### 5.xvi. How can I configure ALE differently for different buffers?
+
+ALE offers various ways to configure which linters or fixers are run, and
+other settings. For the majority of ALE's settings, they can either be
+configured globally with a `g:` variable prefix, or for a specific buffer
+with a `b:` variable prefix. For example, you can configure a Python ftplugin
+file like so.
+
+```vim
+" In ~/.vim/ftplugin/python.vim
+
+" Check Python files with flake8 and pylint.
+let b:ale_linters = ['flake8', 'pylint']
+" Fix Python files with autopep8 and yapf.
+let b:ale_fixers = ['autopep8', 'yapf']
+" Disable warnings about trailing whitespace for Python files.
+let b:ale_warn_about_trailing_whitespace = 0
+```
+
+For configuring files based on regular expression patterns matched against the
+absolute path to a file, you can use `g:ale_pattern_options`.
+
+```vim
+" Do not lint or fix minified files.
+let g:ale_pattern_options = {
+\ '\.min\.js$': {'ale_linters': [], 'ale_fixers': []},
+\ '\.min\.css$': {'ale_linters': [], 'ale_fixers': []},
+\}
+" If you configure g:ale_pattern_options outside of vimrc, you need this.
+let g:ale_pattern_options_enabled = 1
+```
+
+Buffer-local variables for settings always override the global settings.
+
+<a name="faq-list-window-height"></a>
+
+### 5.xvii. How can I configure the height of the list in which ALE displays errors?
+
+To set a default height for the error list, use the `g:ale_list_window_size` variable.
+
+```vim
+" Show 5 lines of errors (default: 10)
+let g:ale_list_window_size = 5
+```
+
+<a name="faq-get-info"></a>
+
+### 5.xviii. How can I see what ALE has configured for the current file?
+
+Run the following to see what is currently configured:
+
+```vim
+:ALEInfo
+```

ale_linters/ada/gcc.vim

@@ -0,0 +1,54 @@
+" Author: Martino Pilia <martino.pilia@gmail.com>
+" Description: Lint Ada files with GCC
+
+call ale#Set('ada_gcc_executable', 'gcc')
+
+" -gnatwa: activate most optional warnings
+" -gnatq: try semantic analysis even if syntax errors have been found
+call ale#Set('ada_gcc_options', '-gnatwa -gnatq')
+
+function! ale_linters#ada#gcc#GetCommand(buffer) abort
+    " Build a suitable output file name. The output file is specified because
+    " the .ali file may be created even if no code generation is attempted.
+    " The output file name must match the source file name (except for the
+    " extension), so here we cannot use the null file as output.
+    let l:tmp_dir = fnamemodify(ale#command#CreateDirectory(a:buffer), ':p')
+    let l:out_file = l:tmp_dir . fnamemodify(bufname(a:buffer), ':t:r') . '.o'
+
+    " -gnatc: Check syntax and semantics only (no code generation attempted)
+    return '%e -x ada -c -gnatc'
+    \   . ' -o ' . ale#Escape(l:out_file)
+    \   . ' -I ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ale#Pad(ale#Var(a:buffer, 'ada_gcc_options'))
+    \   . ' %t'
+endfunction
+
+" For the message format please refer to:
+"   https://gcc.gnu.org/onlinedocs/gnat_ugn/Output-and-Error-Message-Control.html
+"   https://gcc.gnu.org/onlinedocs/gnat_ugn/Warning-Message-Control.html
+function! ale_linters#ada#gcc#Handle(buffer, lines) abort
+    " Error format: <filename>:<lnum>:<col>: <text>
+    " Warning format: <filename>:<lnum>:<col>: warning: <text>
+    let l:re = '\v(.+):([0-9]+):([0-9]+):\s+(warning:)?\s*(.+)\s*'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:re)
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': str2nr(l:match[2]),
+        \   'col': str2nr(l:match[3]),
+        \   'type': l:match[4] is# 'warning:' ? 'W' : 'E',
+        \   'text': l:match[5],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('ada', {
+\   'name': 'gcc',
+\   'output_stream': 'stderr',
+\   'executable': {b -> ale#Var(b, 'ada_gcc_executable')},
+\   'command': function('ale_linters#ada#gcc#GetCommand'),
+\   'callback': 'ale_linters#ada#gcc#Handle',
+\})

ale_linters/ansible/ansible_lint.vim

@@ -0,0 +1,56 @@
+" Author: Bjorn Neergaard <bjorn@neersighted.com>
+" Description: ansible-lint for ansible-yaml files
+
+call ale#Set('ansible_ansible_lint_executable', 'ansible-lint')
+
+function! ale_linters#ansible#ansible_lint#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'ansible_ansible_lint_executable')
+endfunction
+
+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[4]
+
+        if l:code is# 'EANSIBLE0002'
+        \&& !ale#Var(a:buffer, 'warn_about_trailing_whitespace')
+            " Skip warnings for trailing whitespace if the option is off.
+            continue
+        endif
+
+        if ale#path#IsBufferPath(a:buffer, l:match[1])
+            call add(l:output, {
+            \   'lnum': l:match[2] + 0,
+            \   'col': l:match[3] + 0,
+            \   'text': l:match[5],
+            \   'code': l:code,
+            \   'type': l:code[:0] is# 'E' ? 'E' : 'W',
+            \})
+        endif
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('ansible', {
+\   'name': 'ansible_lint',
+\   'aliases': ['ansible', 'ansible-lint'],
+\   'executable': function('ale_linters#ansible#ansible_lint#GetExecutable'),
+\   'command': '%e -p %t',
+\   'callback': 'ale_linters#ansible#ansible_lint#Handle',
+\})

ale_linters/apiblueprint/drafter.vim

@@ -0,0 +1,38 @@
+" Author: nametake https://nametake.github.io
+" Description: apiblueprint parser
+
+function! ale_linters#apiblueprint#drafter#HandleErrors(buffer, lines) abort
+    " Matches patterns line the following:
+    "
+    " warning: (3)  unable to parse response signature, expected 'response [<HTTP status code>] [(<media type>)]'; line 4, column 3k - line 4, column 22
+    " warning: (10)  message-body asset is expected to be a pre-formatted code block, separate it by a newline and indent every of its line by 12 spaces or 3 tabs; line 30, column 5 - line 30, column 9; line 31, column 9 - line 31, column 14; line 32, column 9 - line 32, column 14
+    let l:pattern = '\(^.*\): (\d\+)  \(.\{-\}\); line \(\d\+\), column \(\d\+\) - line \d\+, column \d\+\(.*; line \d\+, column \d\+ - line \(\d\+\), column \(\d\+\)\)\{-\}$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines[2:], l:pattern)
+        let l:item = {
+        \   'type': l:match[1] is# 'warning' ? 'W' : 'E',
+        \   'text': l:match[2],
+        \   'lnum': l:match[3] + 0,
+        \   'col': l:match[4] + 0,
+        \}
+
+        if l:match[5] isnot# ''
+            let l:item.end_lnum = l:match[6] + 0
+            let l:item.end_col = l:match[7] + 0
+        endif
+
+        call add(l:output, l:item)
+    endfor
+
+    return l:output
+endfunction
+
+
+call ale#linter#Define('apiblueprint', {
+\   'name': 'drafter',
+\   'output_stream': 'stderr',
+\   'executable': 'drafter',
+\   'command': 'drafter --use-line-num --validate',
+\   'callback': 'ale_linters#apiblueprint#drafter#HandleErrors',
+\})

ale_linters/asciidoc/alex.vim

@@ -0,0 +1,4 @@
+" Author: Johannes Wienke <languitar@semipol.de>
+" Description: alex for asciidoc files
+
+call ale#handlers#alex#DefineLinter('asciidoc', '--text')

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/asciidoc/redpen.vim

@@ -0,0 +1,9 @@
+" Author: rhysd https://rhysd.github.io
+" Description: Redpen, a proofreading tool (http://redpen.cc)
+
+call ale#linter#Define('asciidoc', {
+\   'name': 'redpen',
+\   'executable': 'redpen',
+\   'command': 'redpen -f asciidoc -r json %t',
+\   'callback': 'ale#handlers#redpen#HandleRedpenOutput',
+\})

ale_linters/asciidoc/textlint.vim

@@ -0,0 +1,9 @@
+" Author: TANIGUCHI Masaya <ta2gch@gmail.com>
+" Description: textlint for AsciiDoc files
+
+call ale#linter#Define('asciidoc', {
+\   'name': 'textlint',
+\   'executable': function('ale#handlers#textlint#GetExecutable'),
+\   'command': function('ale#handlers#textlint#GetCommand'),
+\   'callback': 'ale#handlers#textlint#HandleTextlintOutput',
+\})

ale_linters/asciidoc/vale.vim

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

ale_linters/asciidoc/writegood.vim

@@ -0,0 +1,4 @@
+" Author: Sumner Evans <sumner.evans98@gmail.com>
+" Description: write-good for AsciiDoc files
+
+call ale#handlers#writegood#DefineLinter('asciidoc')

ale_linters/asm/gcc.vim

@@ -0,0 +1,34 @@
+" Author: Lucas Kolstad <lkolstad@uw.edu>
+" Description: gcc linter for asm files
+
+call ale#Set('asm_gcc_executable', 'gcc')
+call ale#Set('asm_gcc_options', '-Wall')
+
+function! ale_linters#asm#gcc#GetCommand(buffer) abort
+    return '%e -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': {b -> ale#Var(b, 'asm_gcc_executable')},
+\    'command': function('ale_linters#asm#gcc#GetCommand'),
+\    'callback': 'ale_linters#asm#gcc#Handle',
+\})

ale_linters/awk/gawk.vim

@@ -0,0 +1,22 @@
+" Author: kmarc <korondi.mark@gmail.com>
+" Description: This file adds support for using GNU awk with sripts.
+
+call ale#Set('awk_gawk_executable', 'gawk')
+call ale#Set('awk_gawk_options', '')
+
+function! ale_linters#awk#gawk#GetCommand(buffer) abort
+    " note the --source 'BEGIN ...' is to prevent
+    " gawk from attempting to execute the body of the script
+    " it is linting.
+    return '%e --source ' . ale#Escape('BEGIN { exit } END { exit 1 }')
+    \   .  ale#Pad(ale#Var(a:buffer, 'awk_gawk_options'))
+    \   . ' -f %t --lint /dev/null'
+endfunction
+
+call ale#linter#Define('awk', {
+\   'name': 'gawk',
+\   'executable': {b -> ale#Var(b, 'awk_gawk_executable')},
+\   'command': function('ale_linters#awk#gawk#GetCommand'),
+\   'callback': 'ale#handlers#gawk#HandleGawkFormat',
+\   'output_stream': 'both'
+\})

ale_linters/bib/bibclean.vim

@@ -0,0 +1,75 @@
+" Author: Horacio Sanson - https://github.com/hsanson
+" Description: Support for bibclean linter for BibTeX files.
+
+call ale#Set('bib_bibclean_executable', 'bibclean')
+
+function! ale_linters#bib#bibclean#GetCommand(buffer) abort
+    let l:executable = ale#Var(a:buffer, 'bib_bibclean_executable')
+
+    return ale#Escape(l:executable) . ' -file-position '
+endfunction
+
+function! ale_linters#bib#bibclean#get_type(str) abort
+    if a:str is# '??'
+        return 'E'
+    else
+        return 'W'
+    endif
+endfunction
+
+function! ale_linters#bib#bibclean#match_msg(line) abort
+    return matchlist(a:line, '^\(.*\) "stdin", line \(.*\): \(.*\)$')
+endfunction
+
+function! ale_linters#bib#bibclean#match_entry(line) abort
+    return matchlist(a:line, 'Entry   input byte=.* line=\(.*\) column=\(.*\) output .*$')
+endfunction
+
+function! ale_linters#bib#bibclean#match_value(line) abort
+    return matchlist(a:line, 'Value   input byte=.* line=\(.*\) column=\(.*\) output .*$')
+endfunction
+
+function! ale_linters#bib#bibclean#Handle(buffer, lines) abort
+    let l:output = []
+
+    let l:type = 'E'
+    let l:msg  = ''
+
+    for l:line in a:lines
+        if empty(l:msg)
+            let l:mlist = ale_linters#bib#bibclean#match_msg(l:line)
+
+            if !empty(l:mlist)
+                let l:msg = l:mlist[3]
+                let l:type = ale_linters#bib#bibclean#get_type(l:mlist[1])
+            endif
+        else
+            if l:type is# 'E'
+                let l:mlist = ale_linters#bib#bibclean#match_entry(l:line)
+            else
+                let l:mlist = ale_linters#bib#bibclean#match_value(l:line)
+            endif
+
+            if !empty(l:mlist)
+                call add(l:output, {
+                \ 'lnum': l:mlist[1],
+                \ 'col': l:mlist[2],
+                \ 'text': l:msg,
+                \ 'type': l:type
+                \})
+
+                let l:msg = ''
+            endif
+        endif
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('bib', {
+\   'name': 'bibclean',
+\   'executable': {b -> ale#Var(b, 'bib_bibclean_executable')},
+\   'command': function('ale_linters#bib#bibclean#GetCommand'),
+\   'output_stream': 'stderr',
+\   'callback': 'ale_linters#bib#bibclean#Handle',
+\})

ale_linters/c/ccls.vim

@@ -0,0 +1,14 @@
+" Author: Ye Jingchen <ye.jingchen@gmail.com>, Ben Falconer <ben@falconers.me.uk>, jtalowell <jtalowell@protonmail.com>
+" Description: A language server for C
+
+call ale#Set('c_ccls_executable', 'ccls')
+call ale#Set('c_ccls_init_options', {})
+
+call ale#linter#Define('c', {
+\   'name': 'ccls',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'c_ccls_executable')},
+\   'command': '%e',
+\   'project_root': function('ale#handlers#ccls#GetProjectRoot'),
+\   'initialization_options': {b -> ale#Var(b, 'c_ccls_init_options')},
+\})

ale_linters/c/clang.vim

@@ -0,0 +1,24 @@
+" Author: Masahiro H https://github.com/mshr-h
+" Description: clang linter for c files
+
+call ale#Set('c_clang_executable', 'clang')
+call ale#Set('c_clang_options', '-std=c11 -Wall')
+
+function! ale_linters#c#clang#GetCommand(buffer, output) abort
+    let l:cflags = ale#c#GetCFlags(a:buffer, a:output)
+
+    " -iquote with the directory the file is in makes #include work for
+    "  headers in the same directory.
+    return '%e -S -x c -fsyntax-only'
+    \   . ' -iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ale#Pad(l:cflags)
+    \   . ale#Pad(ale#Var(a:buffer, 'c_clang_options')) . ' -'
+endfunction
+
+call ale#linter#Define('c', {
+\   'name': 'clang',
+\   'output_stream': 'stderr',
+\   'executable': {b -> ale#Var(b, 'c_clang_executable')},
+\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#c#clang#GetCommand'))},
+\   'callback': 'ale#handlers#gcc#HandleGCCFormatWithIncludes',
+\})

ale_linters/c/clangd.vim

@@ -0,0 +1,23 @@
+" Author: Andrey Melentyev <andrey.melentyev@protonmail.com>
+" Description: Clangd language server
+
+call ale#Set('c_clangd_executable', 'clangd')
+call ale#Set('c_clangd_options', '')
+
+function! ale_linters#c#clangd#GetProjectRoot(buffer) abort
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
+endfunction
+
+function! ale_linters#c#clangd#GetCommand(buffer) abort
+    return '%e' . ale#Pad(ale#Var(a:buffer, 'c_clangd_options'))
+endfunction
+
+call ale#linter#Define('c', {
+\   'name': 'clangd',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'c_clangd_executable')},
+\   'command': function('ale_linters#c#clangd#GetCommand'),
+\   'project_root': function('ale_linters#c#clangd#GetProjectRoot'),
+\})

ale_linters/c/clangtidy.vim

@@ -0,0 +1,42 @@
+" Author: vdeurzen <tim@kompiler.org>, w0rp <devw0rp@gmail.com>,
+" gagbo <gagbobada@gmail.com>, Andrej Radovic <r.andrej@gmail.com>
+" Description: clang-tidy linter for c files
+
+call ale#Set('c_clangtidy_executable', 'clang-tidy')
+" Set this option to check the checks clang-tidy will apply.
+" The number of checks that can be applied to C files is limited in contrast to
+" C++
+"
+" Consult the check list in clang-tidy's documentation:
+" http://clang.llvm.org/extra/clang-tidy/checks/list.html
+
+call ale#Set('c_clangtidy_checks', [])
+" Set this option to manually set some options for clang-tidy.
+" This will disable compile_commands.json detection.
+call ale#Set('c_clangtidy_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#c#clangtidy#GetCommand(buffer) abort
+    let l:checks = join(ale#Var(a:buffer, 'c_clangtidy_checks'), ',')
+    let l:build_dir = ale#c#GetBuildDirectory(a:buffer)
+
+    " Get the extra options if we couldn't find a build directory.
+    let l:options = empty(l:build_dir)
+    \   ? ale#Var(a:buffer, 'c_clangtidy_options')
+    \   : ''
+
+    return '%e'
+    \   . (!empty(l:checks) ? ' -checks=' . ale#Escape(l:checks) : '')
+    \   . ' %s'
+    \   . (!empty(l:build_dir) ? ' -p ' . ale#Escape(l:build_dir) : '')
+    \   . (!empty(l:options) ? ' -- ' . l:options : '')
+endfunction
+
+call ale#linter#Define('c', {
+\   'name': 'clangtidy',
+\   'output_stream': 'stdout',
+\   'executable': {b -> ale#Var(b, 'c_clangtidy_executable')},
+\   'command': function('ale_linters#c#clangtidy#GetCommand'),
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})

ale_linters/c/cppcheck.vim

@@ -0,0 +1,34 @@
+" Author: Bart Libert <bart.libert@gmail.com>
+" Description: cppcheck linter for c files
+
+call ale#Set('c_cppcheck_executable', 'cppcheck')
+call ale#Set('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
+    \   . '%e -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': {b -> ale#Var(b, 'c_cppcheck_executable')},
+\   'command': function('ale_linters#c#cppcheck#GetCommand'),
+\   'callback': 'ale#handlers#cppcheck#HandleCppCheckFormat',
+\})

ale_linters/c/cquery.vim

@@ -0,0 +1,28 @@
+" Author: Ben Falconer <ben@falconers.me.uk>, jtalowell <jtalowell@protonmail.com>
+" Description: A language server for C
+
+call ale#Set('c_cquery_executable', 'cquery')
+call ale#Set('c_cquery_cache_directory', expand('~/.cache/cquery'))
+
+function! ale_linters#c#cquery#GetProjectRoot(buffer) abort
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    if empty(l:project_root)
+        let l:project_root = ale#path#FindNearestFile(a:buffer, '.cquery')
+    endif
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
+endfunction
+
+function! ale_linters#c#cquery#GetInitializationOptions(buffer) abort
+    return {'cacheDirectory': ale#Var(a:buffer, 'c_cquery_cache_directory')}
+endfunction
+
+call ale#linter#Define('c', {
+\   'name': 'cquery',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'c_cquery_executable')},
+\   'command': '%e',
+\   'project_root': function('ale_linters#c#cquery#GetProjectRoot'),
+\   'initialization_options': function('ale_linters#c#cquery#GetInitializationOptions'),
+\})

ale_linters/c/flawfinder.vim

@@ -0,0 +1,25 @@
+" Author: Christian Gibbons <cgibbons@gmu.edu>
+" Description: flawfinder linter for c files
+
+call ale#Set('c_flawfinder_executable', 'flawfinder')
+call ale#Set('c_flawfinder_options', '')
+call ale#Set('c_flawfinder_minlevel', 1)
+call ale#Set('c_flawfinder_error_severity', 6)
+
+function! ale_linters#c#flawfinder#GetCommand(buffer) abort
+    " Set the minimum vulnerability level for flawfinder to bother with
+    let l:minlevel = ' --minlevel=' . ale#Var(a:buffer, 'c_flawfinder_minlevel')
+
+    return '%e -CDQS'
+    \  . ale#Pad(ale#Var(a:buffer, 'c_flawfinder_options'))
+    \  . l:minlevel
+    \  . ' %t'
+endfunction
+
+call ale#linter#Define('c', {
+\  'name': 'flawfinder',
+\  'output_stream': 'stdout',
+\  'executable': {b -> ale#Var(b, 'c_flawfinder_executable')},
+\  'command': function('ale_linters#c#flawfinder#GetCommand'),
+\  'callback': 'ale#handlers#flawfinder#HandleFlawfinderFormat',
+\})

ale_linters/c/gcc.vim

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

ale_linters/chef/foodcritic.vim

@@ -0,0 +1,41 @@
+" Author: Edward Larkey <edwlarkey@mac.com>
+" Author: Jose Junior <jose.junior@gmail.com>
+" Author: w0rp <devw0rp@gmail.com>
+" Description: This file adds the foodcritic linter for Chef files.
+
+call ale#Set('chef_foodcritic_executable', 'foodcritic')
+call ale#Set('chef_foodcritic_options', '')
+
+function! ale_linters#chef#foodcritic#GetCommand(buffer) abort
+    let l:options = ale#Var(a:buffer, 'chef_foodcritic_options')
+
+    return '%e' . ale#Pad(escape(l:options, '~')) . ' %s'
+endfunction
+
+function! ale_linters#chef#foodcritic#Handle(buffer, lines) abort
+    " Matches patterns line the following:
+    "
+    " FC002: Avoid string interpolation where not required: httpd.rb:13
+    let l:pattern = '\v([^:]+): (.+): ([a-zA-Z]?:?[^:]+):(\d+)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'code': l:match[1],
+        \   'text': l:match[2],
+        \   'filename': l:match[3],
+        \   'lnum': l:match[4] + 0,
+        \   'type': 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('chef', {
+\   'name': 'foodcritic',
+\   'executable': {b -> ale#Var(b, 'chef_foodcritic_executable')},
+\   'command': function('ale_linters#chef#foodcritic#GetCommand'),
+\   'callback': 'ale_linters#chef#foodcritic#Handle',
+\   'lint_file': 1,
+\})

ale_linters/clojure/joker.vim

@@ -0,0 +1,34 @@
+" Author: Nic West <nicwest@mailbox.org>
+" Description: linter for clojure using joker https://github.com/candid82/joker
+
+function! ale_linters#clojure#joker#HandleJokerFormat(buffer, lines) abort
+    " output format
+    " <filename>:<line>:<column>: <issue type>: <message>
+    let l:pattern = '\v^[a-zA-Z]?:?[^:]+:(\d+):(\d+):? ((Read error|Parse error|Parse warning|Exception): ?(.+))$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:type = 'E'
+
+        if l:match[4] is? 'Parse warning'
+            let l:type = 'W'
+        endif
+
+        call add(l:output, {
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:match[2] + 0,
+        \   'text': l:match[3],
+        \   'type': l:type,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('clojure', {
+\   'name': 'joker',
+\   'output_stream': 'stderr',
+\   'executable': 'joker',
+\   'command': 'joker --working-dir %s --lint %t',
+\   'callback': 'ale_linters#clojure#joker#HandleJokerFormat',
+\})

ale_linters/cloudformation/cfn_python_lint.vim

@@ -0,0 +1,35 @@
+" Author: Yasuhiro Kiyota <yasuhiroki.duck@gmail.com>
+" Description: Support cfn-python-lint for AWS Cloudformation template file
+
+function! ale_linters#cloudformation#cfn_python_lint#Handle(buffer, lines) abort
+    " Matches patterns line the following:
+    "
+    " sample.template.yaml:96:7:96:15:E3012:Property Resources/Sample/Properties/FromPort should be of type Integer
+    let l:pattern = '\v^(.*):(\d+):(\d+):(\d+):(\d+):([[:alnum:]]+):(.*)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:code = l:match[6]
+
+        if ale#path#IsBufferPath(a:buffer, l:match[1])
+            call add(l:output, {
+            \   'lnum': l:match[2],
+            \   'col': l:match[3],
+            \   'end_lnum': l:match[4],
+            \   'end_col': l:match[5],
+            \   'code': l:code,
+            \   'type': l:code[:0] is# 'E' ? 'E' : 'W',
+            \   'text': l:match[7]
+            \})
+        endif
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('cloudformation', {
+\   'name': 'cloudformation',
+\   'executable': 'cfn-lint',
+\   'command': 'cfn-lint --template %t --format parseable',
+\   'callback': 'ale_linters#cloudformation#cfn_python_lint#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': function('ale_linters#cmake#cmakelint#Executable'),
+\   'command': function('ale_linters#cmake#cmakelint#Command'),
+\   'callback': 'ale#handlers#unix#HandleAsWarning',
+\})

ale_linters/coffee/coffee.vim

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

ale_linters/coffee/coffeelint.vim

@@ -1,43 +1,34 @@
 " Author: Prashanth Chandra https://github.com/prashcr
 " Description: coffeelint linter for coffeescript files
 
-if exists('g:loaded_ale_linters_coffee_coffeelint')
-    finish
-endif
+function! ale_linters#coffee#coffeelint#GetExecutable(buffer) abort
+    return ale#path#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/coffeelint',
+    \   'coffeelint'
+    \)
+endfunction
 
-let g:loaded_ale_linters_coffee_coffeelint = 1
+function! ale_linters#coffee#coffeelint#GetCommand(buffer) abort
+    return ale_linters#coffee#coffeelint#GetExecutable(a:buffer)
+    \   . ' --stdin --reporter csv'
+endfunction
 
-function! ale_linters#coffee#coffeelint#Handle(buffer, lines)
+function! ale_linters#coffee#coffeelint#Handle(buffer, lines) abort
     " Matches patterns like the following:
     "
     " path,lineNumber,lineNumberEnd,level,message
     " stdin,14,,error,Throwing strings is forbidden
     "
     " Note that we currently ignore lineNumberEnd for multiline errors
-    let l:pattern = 'stdin,\(\d\+\),\(\d*\),\(.\+\),\(.\+\)'
+    let l:pattern = 'stdin,\(\d\+\),\(\d*\),\(.\{-1,}\),\(.\+\)'
     let l:output = []
 
-    for l:line in a:lines
-        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] is# 'error' ? 'E' : 'W',
+        \   'text': l:match[4],
         \})
     endfor
 
@@ -46,7 +37,7 @@ endfunction
 
 call ale#linter#Define('coffee', {
 \   'name': 'coffeelint',
-\   'executable': 'coffeelint',
-\   'command': 'coffeelint --stdin --reporter csv',
+\   'executable': function('ale_linters#coffee#coffeelint#GetExecutable'),
+\   'command': function('ale_linters#coffee#coffeelint#GetCommand'),
 \   'callback': 'ale_linters#coffee#coffeelint#Handle',
 \})

ale_linters/cpp/ccls.vim

@@ -0,0 +1,14 @@
+" Author: Ye Jingchen <ye.jingchen@gmail.com>, Ben Falconer <ben@falconers.me.uk>, jtalowell <jtalowell@protonmail.com>
+" Description: A language server for C++
+
+call ale#Set('cpp_ccls_executable', 'ccls')
+call ale#Set('cpp_ccls_init_options', {})
+
+call ale#linter#Define('cpp', {
+\   'name': 'ccls',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'cpp_ccls_executable')},
+\   'command': '%e',
+\   'project_root': function('ale#handlers#ccls#GetProjectRoot'),
+\   'initialization_options': {b -> ale#Var(b, 'cpp_ccls_init_options')},
+\})

ale_linters/cpp/clang.vim

@@ -0,0 +1,24 @@
+" Author: Tomota Nakamura <https://github.com/tomotanakamura>
+" Description: clang linter for cpp files
+
+call ale#Set('cpp_clang_executable', 'clang++')
+call ale#Set('cpp_clang_options', '-std=c++14 -Wall')
+
+function! ale_linters#cpp#clang#GetCommand(buffer, output) abort
+    let l:cflags = ale#c#GetCFlags(a:buffer, a:output)
+
+    " -iquote with the directory the file is in makes #include work for
+    "  headers in the same directory.
+    return '%e -S -x c++ -fsyntax-only'
+    \   . ' -iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ale#Pad(l:cflags)
+    \   . ale#Pad(ale#Var(a:buffer, 'cpp_clang_options')) . ' -'
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'clang',
+\   'output_stream': 'stderr',
+\   'executable': {b -> ale#Var(b, 'cpp_clang_executable')},
+\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#cpp#clang#GetCommand'))},
+\   'callback': 'ale#handlers#gcc#HandleGCCFormatWithIncludes',
+\})

ale_linters/cpp/clangcheck.vim

@@ -0,0 +1,34 @@
+" Author: gagbo <gagbobada@gmail.com>
+" Description: clang-check linter for cpp files
+
+call ale#Set('cpp_clangcheck_executable', 'clang-check')
+call ale#Set('cpp_clangcheck_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#cpp#clangcheck#GetCommand(buffer) abort
+    let l:user_options = ale#Var(a:buffer, 'cpp_clangcheck_options')
+
+    " Try to find compilation database to link automatically
+    let l:build_dir = ale#Var(a:buffer, 'c_build_dir')
+
+    if empty(l:build_dir)
+        let l:build_dir = ale#path#Dirname(ale#c#FindCompileCommands(a:buffer))
+    endif
+
+    " The extra arguments in the command are used to prevent .plist files from
+    " being generated. These are only added if no build directory can be
+    " detected.
+    return '%e -analyze %s'
+    \   . (empty(l:build_dir) ? ' -extra-arg -Xclang -extra-arg -analyzer-output=text' : '')
+    \   . ale#Pad(l:user_options)
+    \   . (!empty(l:build_dir) ? ' -p ' . ale#Escape(l:build_dir) : '')
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'clangcheck',
+\   'output_stream': 'stderr',
+\   'executable': {b -> ale#Var(b, 'cpp_clangcheck_executable')},
+\   'command': function('ale_linters#cpp#clangcheck#GetCommand'),
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})

ale_linters/cpp/clangd.vim

@@ -0,0 +1,23 @@
+" Author: Andrey Melentyev <andrey.melentyev@protonmail.com>
+" Description: Clangd language server
+
+call ale#Set('cpp_clangd_executable', 'clangd')
+call ale#Set('cpp_clangd_options', '')
+
+function! ale_linters#cpp#clangd#GetProjectRoot(buffer) abort
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
+endfunction
+
+function! ale_linters#cpp#clangd#GetCommand(buffer) abort
+    return '%e' . ale#Pad(ale#Var(a:buffer, 'cpp_clangd_options'))
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'clangd',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'cpp_clangd_executable')},
+\   'command': function('ale_linters#cpp#clangd#GetCommand'),
+\   'project_root': function('ale_linters#cpp#clangd#GetProjectRoot'),
+\})

ale_linters/cpp/clangtidy.vim

@@ -0,0 +1,36 @@
+" Author: vdeurzen <tim@kompiler.org>, w0rp <devw0rp@gmail.com>,
+" gagbo <gagbobada@gmail.com>
+" Description: clang-tidy linter for cpp files
+
+call ale#Set('cpp_clangtidy_executable', 'clang-tidy')
+" Set this option to check the checks clang-tidy will apply.
+call ale#Set('cpp_clangtidy_checks', [])
+" Set this option to manually set some options for clang-tidy.
+" This will disable compile_commands.json detection.
+call ale#Set('cpp_clangtidy_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#cpp#clangtidy#GetCommand(buffer) abort
+    let l:checks = join(ale#Var(a:buffer, 'cpp_clangtidy_checks'), ',')
+    let l:build_dir = ale#c#GetBuildDirectory(a:buffer)
+
+    " Get the extra options if we couldn't find a build directory.
+    let l:options = empty(l:build_dir)
+    \   ? ale#Var(a:buffer, 'cpp_clangtidy_options')
+    \   : ''
+
+    return '%e'
+    \   . (!empty(l:checks) ? ' -checks=' . ale#Escape(l:checks) : '')
+    \   . ' %s'
+    \   . (!empty(l:build_dir) ? ' -p ' . ale#Escape(l:build_dir) : '')
+    \   . (!empty(l:options) ? ' -- ' . l:options : '')
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'clangtidy',
+\   'output_stream': 'stdout',
+\   'executable': {b -> ale#Var(b, 'cpp_clangtidy_executable')},
+\   'command': function('ale_linters#cpp#clangtidy#GetCommand'),
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})

ale_linters/cpp/clazy.vim

@@ -0,0 +1,32 @@
+" Description: clazy linter for cpp files (clang-based and Qt-oriented)
+
+call ale#Set('cpp_clazy_executable', 'clazy-standalone')
+" Set this option to check the checks clazy will apply.
+call ale#Set('cpp_clazy_checks', ['level1'])
+" Set this option to manually set some options for clazy.
+" This will disable compile_commands.json detection.
+call ale#Set('cpp_clazy_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#cpp#clazy#GetCommand(buffer) abort
+    let l:checks = join(ale#Var(a:buffer, 'cpp_clazy_checks'), ',')
+    let l:build_dir = ale#c#GetBuildDirectory(a:buffer)
+
+    " Get the extra options if we couldn't find a build directory.
+    let l:options = ale#Var(a:buffer, 'cpp_clazy_options')
+
+    return '%e'
+    \   . (!empty(l:checks) ? ' -checks=' . ale#Escape(l:checks) : '')
+    \   . (!empty(l:build_dir) ? ' -p ' . ale#Escape(l:build_dir) : '')
+    \   . (!empty(l:options) ? ' ' . l:options : '')
+    \   . ' %s'
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'clazy',
+\   'output_stream': 'stderr',
+\   'executable': {b -> ale#Var(b, 'cpp_clazy_executable')},
+\   'command': function('ale_linters#cpp#clazy#GetCommand'),
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})

ale_linters/cpp/cppcheck.vim

@@ -0,0 +1,34 @@
+" Author: Bart Libert <bart.libert@gmail.com>
+" Description: cppcheck linter for cpp files
+
+call ale#Set('cpp_cppcheck_executable', 'cppcheck')
+call ale#Set('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
+    \   . '%e -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': {b -> ale#Var(b, 'cpp_cppcheck_executable')},
+\   'command': function('ale_linters#cpp#cppcheck#GetCommand'),
+\   'callback': 'ale#handlers#cppcheck#HandleCppCheckFormat',
+\})

ale_linters/cpp/cpplint.vim

@@ -0,0 +1,20 @@
+" Author: Dawid Kurek https://github.com/dawikur
+" Description: cpplint for cpp files
+
+call ale#Set('cpp_cpplint_executable', 'cpplint')
+call ale#Set('cpp_cpplint_options', '')
+
+function! ale_linters#cpp#cpplint#GetCommand(buffer) abort
+    let l:options = ale#Var(a:buffer, 'cpp_cpplint_options')
+
+    return '%e' . ale#Pad(l:options) . ' %s'
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'cpplint',
+\   'output_stream': 'stderr',
+\   'executable': {b -> ale#Var(b, 'cpp_cpplint_executable')},
+\   'command': function('ale_linters#cpp#cpplint#GetCommand'),
+\   'callback': 'ale#handlers#cpplint#HandleCppLintFormat',
+\   'lint_file': 1,
+\})

ale_linters/cpp/cquery.vim

@@ -0,0 +1,28 @@
+" Author: Ben Falconer <ben@falconers.me.uk>
+" Description: A language server for C++
+
+call ale#Set('cpp_cquery_executable', 'cquery')
+call ale#Set('cpp_cquery_cache_directory', expand('~/.cache/cquery'))
+
+function! ale_linters#cpp#cquery#GetProjectRoot(buffer) abort
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    if empty(l:project_root)
+        let l:project_root = ale#path#FindNearestFile(a:buffer, '.cquery')
+    endif
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
+endfunction
+
+function! ale_linters#cpp#cquery#GetInitializationOptions(buffer) abort
+    return {'cacheDirectory': ale#Var(a:buffer, 'cpp_cquery_cache_directory')}
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'cquery',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'cpp_cquery_executable')},
+\   'command': '%e',
+\   'project_root': function('ale_linters#cpp#cquery#GetProjectRoot'),
+\   'initialization_options': function('ale_linters#cpp#cquery#GetInitializationOptions'),
+\})

ale_linters/cpp/flawfinder.vim

@@ -0,0 +1,25 @@
+" Author: Christian Gibbons <cgibbons@gmu.edu>
+" Description: flawfinder linter for c++ files
+
+call ale#Set('cpp_flawfinder_executable', 'flawfinder')
+call ale#Set('cpp_flawfinder_options', '')
+call ale#Set('cpp_flawfinder_minlevel', 1)
+call ale#Set('c_flawfinder_error_severity', 6)
+
+function! ale_linters#cpp#flawfinder#GetCommand(buffer) abort
+    " Set the minimum vulnerability level for flawfinder to bother with
+    let l:minlevel = ' --minlevel=' . ale#Var(a:buffer, 'cpp_flawfinder_minlevel')
+
+    return '%e -CDQS'
+    \  . ale#Var(a:buffer, 'cpp_flawfinder_options')
+    \  . l:minlevel
+    \  . ' %t'
+endfunction
+
+call ale#linter#Define('cpp', {
+\  'name': 'flawfinder',
+\  'output_stream': 'stdout',
+\  'executable': {b -> ale#Var(b, 'cpp_flawfinder_executable')},
+\  'command': function('ale_linters#cpp#flawfinder#GetCommand'),
+\  'callback': 'ale#handlers#flawfinder#HandleFlawfinderFormat',
+\})

ale_linters/cpp/gcc.vim

@@ -1,23 +1,25 @@
 " Author: geam <mdelage@student.42.fr>
 " Description: gcc linter for cpp files
+"
+call ale#Set('cpp_gcc_executable', 'gcc')
+call ale#Set('cpp_gcc_options', '-std=c++14 -Wall')
 
-if exists('g:loaded_ale_linters_cpp_gcc')
-    finish
-endif
+function! ale_linters#cpp#gcc#GetCommand(buffer, output) abort
+    let l:cflags = ale#c#GetCFlags(a:buffer, a:output)
 
-let g:loaded_ale_linters_cpp_gcc = 1
-
-" Set this option to change the GCC options for warnings for C.
-if !exists('g:ale_cpp_gcc_options')
-    let g:ale_cpp_gcc_options = '-Wall'
-endif
+    " -iquote with the directory the file is in makes #include work for
+    "  headers in the same directory.
+    return '%e -S -x c++ -fsyntax-only'
+    \   . ' -iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ale#Pad(l:cflags)
+    \   . ale#Pad(ale#Var(a:buffer, 'cpp_gcc_options')) . ' -'
+endfunction
 
 call ale#linter#Define('cpp', {
 \   'name': 'gcc',
+\   'aliases': ['g++'],
 \   'output_stream': 'stderr',
-\   'executable': 'gcc',
-\   'command': 'gcc -S -x c++ -fsyntax-only '
-\       . g:ale_cpp_gcc_options
-\       . ' -',
-\   'callback': 'ale#handlers#HandleGCCFormat',
+\   'executable': {b -> ale#Var(b, 'cpp_gcc_executable')},
+\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#cpp#gcc#GetCommand'))},
+\   'callback': 'ale#handlers#gcc#HandleGCCFormatWithIncludes',
 \})

ale_linters/crystal/ameba.vim

@@ -0,0 +1,57 @@
+" Author: Harrison Bachrach - https://github.com/HarrisonB
+" Description: Ameba, a linter for crystal files
+
+call ale#Set('crystal_ameba_executable', 'bin/ameba')
+
+function! ale_linters#crystal#ameba#GetCommand(buffer) abort
+    let l:executable = ale#Var(a:buffer, 'crystal_ameba_executable')
+
+    return ale#Escape(l:executable)
+    \   . ' --format json '
+    \   .  ale#Escape(expand('#' . a:buffer . ':p'))
+endfunction
+
+" Handle output from ameba
+function! ale_linters#crystal#ameba#HandleAmebaOutput(buffer, lines) abort
+    if len(a:lines) == 0
+        return []
+    endif
+
+    let l:errors = ale#util#FuzzyJSONDecode(a:lines[0], {})
+
+    if !has_key(l:errors, 'summary')
+    \|| l:errors['summary']['issues_count'] == 0
+    \|| empty(l:errors['sources'])
+        return []
+    endif
+
+    let l:output = []
+
+    for l:error in l:errors['sources'][0]['issues']
+        let l:start_col = str2nr(l:error['location']['column'])
+        let l:end_col = str2nr(l:error['end_location']['column'])
+
+        if !l:end_col
+            let l:end_col = l:start_col + 1
+        endif
+
+        call add(l:output, {
+        \   'lnum': str2nr(l:error['location']['line']),
+        \   'col': l:start_col,
+        \   'end_col': l:end_col,
+        \   'code': l:error['rule_name'],
+        \   'text': l:error['message'],
+        \   'type': 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('crystal', {
+\   'name': 'ameba',
+\   'executable': {b -> ale#Var(b, 'crystal_ameba_executable')},
+\   'command': function('ale_linters#crystal#ameba#GetCommand'),
+\   'callback': 'ale_linters#crystal#ameba#HandleAmebaOutput',
+\   'lint_file': 1,
+\})

ale_linters/crystal/crystal.vim

@@ -0,0 +1,31 @@
+" 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 = []
+
+    for l:error in ale#util#FuzzyJSONDecode(a:lines, [])
+        call add(l:output, {
+        \   'lnum': l:error.line + 0,
+        \   'col': l:error.column + 0,
+        \   'text': l:error.message,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+function! ale_linters#crystal#crystal#GetCommand(buffer) abort
+    return 'crystal build -f json --no-codegen --no-color -o '
+    \   . ale#Escape(g:ale#util#nul_file)
+    \   . ' %s'
+endfunction
+
+call ale#linter#Define('crystal', {
+\   'name': 'crystal',
+\   'executable': 'crystal',
+\   'output_stream': 'both',
+\   'lint_file': 1,
+\   'command': function('ale_linters#crystal#crystal#GetCommand'),
+\   'callback': 'ale_linters#crystal#crystal#Handle',
+\})

ale_linters/cs/mcs.vim

@@ -0,0 +1,37 @@
+let g:ale_cs_mcs_options = get(g:, 'ale_cs_mcs_options', '')
+
+function! ale_linters#cs#mcs#GetCommand(buffer) abort
+    let l:options = ale#Var(a:buffer, 'cs_mcs_options')
+
+    return 'mcs -unsafe --parse'
+    \   . (!empty(l:options) ? ' ' . l:options : '')
+    \   . ' %t'
+endfunction
+
+function! ale_linters#cs#mcs#Handle(buffer, lines) abort
+    " Look for lines like the following.
+    "
+    " Tests.cs(12,29): error CSXXXX: ; expected
+    let l:pattern = '^\v(.+\.cs)\((\d+),(\d+)\)\: ([^ ]+) ([^ ]+): (.+)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'type': l:match[4] is# 'error' ? 'E' : 'W',
+        \   'code': l:match[5],
+        \   'text': l:match[6],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('cs',{
+\   'name': 'mcs',
+\   'output_stream': 'stderr',
+\   'executable': 'mcs',
+\   'command': function('ale_linters#cs#mcs#GetCommand'),
+\   'callback': 'ale_linters#cs#mcs#Handle',
+\})

ale_linters/cs/mcsc.vim

@@ -0,0 +1,81 @@
+call ale#Set('cs_mcsc_options', '')
+call ale#Set('cs_mcsc_source', '')
+call ale#Set('cs_mcsc_assembly_path', [])
+call ale#Set('cs_mcsc_assemblies', [])
+
+function! s:GetWorkingDirectory(buffer) abort
+    let l:working_directory = ale#Var(a:buffer, 'cs_mcsc_source')
+
+    if !empty(l:working_directory)
+        return l:working_directory
+    endif
+
+    return expand('#' . a:buffer . ':p:h')
+endfunction
+
+function! ale_linters#cs#mcsc#GetCommand(buffer) abort
+    " Pass assembly paths via the -lib: parameter.
+    let l:path_list = ale#Var(a:buffer, 'cs_mcsc_assembly_path')
+
+    let l:lib_option = !empty(l:path_list)
+    \   ? '-lib:' . join(map(copy(l:path_list), 'ale#Escape(v:val)'), ',')
+    \   : ''
+
+    " Pass paths to DLL files via the -r: parameter.
+    let l:assembly_list = ale#Var(a:buffer, 'cs_mcsc_assemblies')
+
+    let l:r_option = !empty(l:assembly_list)
+    \   ? '-r:' . join(map(copy(l:assembly_list), 'ale#Escape(v:val)'), ',')
+    \   : ''
+
+    " register temporary module target file with ale
+    " register temporary module target file with ALE.
+    let l:out = ale#command#CreateFile(a:buffer)
+
+    " The code is compiled as a module and the output is redirected to a
+    " temporary file.
+    return ale#path#CdString(s:GetWorkingDirectory(a:buffer))
+    \    . 'mcs -unsafe'
+    \    . ale#Pad(ale#Var(a:buffer, 'cs_mcsc_options'))
+    \    . ale#Pad(l:lib_option)
+    \    . ale#Pad(l:r_option)
+    \    . ' -out:' . l:out
+    \    . ' -t:module'
+    \    . ' -recurse:' . ale#Escape('*.cs')
+endfunction
+
+function! ale_linters#cs#mcsc#Handle(buffer, lines) abort
+    " Look for lines like the following.
+    "
+    " Tests.cs(12,29): error CSXXXX: ; expected
+    "
+    " NOTE: pattern also captures file name as linter compiles all
+    " files within the source tree rooted at the specified source
+    " path and not just the file loaded in the buffer
+    let l:pattern = '^\v(.+\.cs)\((\d+),(\d+)\)\: ([^ ]+) ([^ ]+): (.+)$'
+    let l:output = []
+
+    let l:dir = s:GetWorkingDirectory(a:buffer)
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'type': l:match[4] is# 'error' ? 'E' : 'W',
+        \   'code': l:match[5],
+        \   'text': l:match[6],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('cs',{
+\   'name': 'mcsc',
+\   'output_stream': 'stderr',
+\   'executable': 'mcs',
+\   'command': function('ale_linters#cs#mcsc#GetCommand'),
+\   'callback': 'ale_linters#cs#mcsc#Handle',
+\   'lint_file': 1
+\})

ale_linters/css/csslint.vim

@@ -1,15 +1,18 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: This file adds support for checking CSS code with csslint.
 
-if exists('g:loaded_ale_linters_css_csslint')
-    finish
-endif
+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)
+    \   : ''
 
-let g:loaded_ale_linters_css_csslint = 1
+    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': function('ale_linters#css#csslint#GetCommand'),
+\   'callback': 'ale#handlers#css#HandleCSSLintFormat',
 \})

ale_linters/css/stylelint.vim

@@ -0,0 +1,19 @@
+" Author: diartyz <diartyz@gmail.com>
+
+call ale#Set('css_stylelint_executable', 'stylelint')
+call ale#Set('css_stylelint_options', '')
+call ale#Set('css_stylelint_use_global', get(g:, 'ale_use_global_executables', 0))
+
+function! ale_linters#css#stylelint#GetCommand(buffer) abort
+    return '%e ' . ale#Pad(ale#Var(a:buffer, 'css_stylelint_options'))
+    \   . ' --stdin-filename %s'
+endfunction
+
+call ale#linter#Define('css', {
+\   'name': 'stylelint',
+\   'executable': {b -> ale#node#FindExecutable(b, 'css_stylelint', [
+\       'node_modules/.bin/stylelint',
+\   ])},
+\   'command': function('ale_linters#css#stylelint#GetCommand'),
+\   'callback': 'ale#handlers#css#HandleStyleLintFormat',
+\})

ale_linters/cucumber/cucumber.vim

@@ -0,0 +1,46 @@
+" Author: Eddie Lebow https://github.com/elebow
+" Description: Cucumber, a BDD test tool
+
+function! ale_linters#cucumber#cucumber#GetCommand(buffer) abort
+    let l:features_dir = ale#path#FindNearestDirectory(a:buffer, 'features')
+
+    if !empty(l:features_dir)
+        let l:features_arg = '-r ' . ale#Escape(l:features_dir)
+    else
+        let l:features_arg = ''
+    endif
+
+    return 'cucumber --dry-run --quiet --strict --format=json '
+    \   . l:features_arg . ' %t'
+endfunction
+
+function! ale_linters#cucumber#cucumber#Handle(buffer, lines) abort
+    try
+        let l:json = ale#util#FuzzyJSONDecode(a:lines, {})[0]
+    catch
+        return []
+    endtry
+
+    let l:output = []
+
+    for l:element in get(l:json, 'elements', [])
+        for l:step in l:element['steps']
+            if l:step['result']['status'] is# 'undefined'
+                call add(l:output, {
+                \   'lnum': l:step['line'],
+                \   'code': 'E',
+                \   'text': 'Undefined step'
+                \})
+            endif
+        endfor
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('cucumber', {
+\   'name': 'cucumber',
+\   'executable': 'cucumber',
+\   'command': function('ale_linters#cucumber#cucumber#GetCommand'),
+\   'callback': 'ale_linters#cucumber#cucumber#Handle'
+\})

ale_linters/cuda/nvcc.vim

@@ -0,0 +1,49 @@
+" Author: blahgeek <i@blahgeek.com>
+" Description: NVCC linter for cuda files
+
+call ale#Set('cuda_nvcc_executable', 'nvcc')
+call ale#Set('cuda_nvcc_options', '-std=c++11')
+
+function! ale_linters#cuda#nvcc#GetCommand(buffer) abort
+    " Unused: use ale#util#nul_file
+    " let l:output_file = ale#util#Tempname() . '.ii'
+    " call ale#command#ManageFile(a:buffer, l:output_file)
+    return '%e -cuda'
+    \   . ale#Pad(ale#c#IncludeOptions(ale#c#FindLocalHeaderPaths(a:buffer)))
+    \   . ale#Pad(ale#Var(a:buffer, 'cuda_nvcc_options'))
+    \   . ' %s -o ' . g:ale#util#nul_file
+endfunction
+
+function! ale_linters#cuda#nvcc#HandleNVCCFormat(buffer, lines) abort
+    " Look for lines like the following.
+    "
+    " test.cu(8): error: argument of type "void *" is incompatible with parameter of type "int *"
+    let l:pattern = '\v^([^:\(\)]+):?\(?(\d+)\)?:(\d+)?:?\s*\w*\s*(error|warning): (.+)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:item = {
+        \   'lnum': str2nr(l:match[2]),
+        \   'type': l:match[4] =~# 'error' ? 'E' : 'W',
+        \   'text': l:match[5],
+        \   'filename': fnamemodify(l:match[1], ':p'),
+        \}
+
+        if !empty(l:match[3])
+            let l:item.col = str2nr(l:match[3])
+        endif
+
+        call add(l:output, l:item)
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('cuda', {
+\   'name': 'nvcc',
+\   'output_stream': 'stderr',
+\   'executable': {b -> ale#Var(b, 'cuda_nvcc_executable')},
+\   'command': function('ale_linters#cuda#nvcc#GetCommand'),
+\   'callback': 'ale_linters#cuda#nvcc#HandleNVCCFormat',
+\   'lint_file': 1,
+\})

ale_linters/cypher/cypher_lint.vim

@@ -0,0 +1,26 @@
+" Author: Francisco Lopes <francisco@oblita.com>
+" Description: Linting for Neo4j's Cypher
+
+function! ale_linters#cypher#cypher_lint#Handle(buffer, lines) abort
+    let l:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+):(\d+): (.*)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'text': l:match[4],
+        \   'type': 'E',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('cypher', {
+\   'name': 'cypher_lint',
+\   'executable': 'cypher-lint',
+\   'command': 'cypher-lint',
+\   'output_stream': 'stderr',
+\   'callback': 'ale_linters#cypher#cypher_lint#Handle',
+\})

ale_linters/d/dls.vim

@@ -0,0 +1,22 @@
+" Author: aurieh <me@aurieh.me>
+" Description: A Language Server implementation for D
+
+call ale#Set('d_dls_executable', 'dls')
+
+function! ale_linters#d#dls#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'd_dls_executable')
+endfunction
+
+function! ale_linters#d#dls#FindProjectRoot(buffer) abort
+    " Note: this will return . if dub config is empty
+    " dls can run outside DUB projects just fine
+    return fnamemodify(ale#d#FindDUBConfig(a:buffer), ':h')
+endfunction
+
+call ale#linter#Define('d', {
+\   'name': 'dls',
+\   'lsp': 'stdio',
+\   'executable': function('ale_linters#d#dls#GetExecutable'),
+\   'command': function('ale_linters#d#dls#GetExecutable'),
+\   'project_root': function('ale_linters#d#dls#FindProjectRoot'),
+\})

ale_linters/d/dmd.vim

@@ -1,60 +1,64 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: "dmd for D files"
 
-if exists('g:loaded_ale_linters_d_dmd')
-    finish
-endif
+function! ale_linters#d#dmd#GetDUBCommand(buffer) abort
+    " If we can't run dub, then skip this command.
+    if !executable('dub')
+        " Returning an empty string skips to the DMD command.
+        return ''
+    endif
 
-let g:loaded_ale_linters_d_dmd = 1
+    let l:dub_file = ale#d#FindDUBConfig(a:buffer)
 
-" A function for finding the dmd-wrapper script in the Vim runtime paths
-function! s:FindWrapperScript()
-    for l:parent in split(&runtimepath, ',')
-        " Expand the path to deal with ~ issues.
-        let l:path = expand(l:parent . '/' . 'dmd-wrapper')
+    if empty(l:dub_file)
+        return ''
+    endif
 
-        if filereadable(l:path)
-            return l:path
+    " 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 ' . ale#Escape(fnamemodify(l:dub_file, ':h'))
+    \   . ' && dub describe --import-paths'
+endfunction
+
+function! ale_linters#d#dmd#RunDUBCommand(buffer) abort
+    let l:command = ale_linters#d#dmd#GetDUBCommand(a:buffer)
+
+    if empty(l:command)
+        " If we can't run DUB, just run DMD.
+        return ale_linters#d#dmd#DMDCommand(a:buffer, [], {})
+    endif
+
+    return ale#command#Run(a:buffer, l:command, function('ale_linters#d#dmd#DMDCommand'))
+endfunction
+
+function! ale_linters#d#dmd#DMDCommand(buffer, dub_output, meta) abort
+    let l:import_list = []
+
+    " Build a list of import paths generated from DUB, if available.
+    for l:line in a:dub_output
+        if !empty(l:line)
+            " The arguments must be '-Ifilename', not '-I filename'
+            call add(l:import_list, '-I' . ale#Escape(l:line))
         endif
     endfor
+
+    return 'dmd '. join(l:import_list) . ' -o- -wi -vcolumns -c %t'
 endfunction
 
-function! ale_linters#d#dmd#GetCommand(buffer)
-    let l:wrapper_script = s:FindWrapperScript()
-
-    let l:command = l:wrapper_script . ' -o- -vcolumns -c'
-
-    return l:command
-endfunction
-
-function! ale_linters#d#dmd#Handle(buffer, lines)
+function! ale_linters#d#dmd#Handle(buffer, lines) abort
     " Matches patterns lines like the following:
-    "
+    " /tmp/tmp.qclsa7qLP7/file.d(1): Error: function declaration without return type. (Note that constructors are always named 'this')
     " /tmp/tmp.G1L5xIizvB.d(8,8): Error: module weak_reference is in file 'dstruct/weak_reference.d' which cannot be read
-    let l:pattern = '^[^(]\+(\([0-9]\+\),\([0-9]\+\)): \([^:]\+\): \(.\+\)'
+    let l:pattern = '^[^(]\+(\([0-9]\+\)\,\?\([0-9]*\)): \([^:]\+\): \(.\+\)'
     let l:output = []
 
-    for l:line in a:lines
-        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] is# 'Warning' ? 'W' : 'E',
+        \   'text': l:match[4],
         \})
     endfor
 
@@ -63,8 +67,8 @@ endfunction
 
 call ale#linter#Define('d', {
 \   'name': 'dmd',
-\   'output_stream': 'stderr',
 \   'executable': 'dmd',
-\   'command_callback': 'ale_linters#d#dmd#GetCommand',
+\   'command': function('ale_linters#d#dmd#RunDUBCommand'),
 \   'callback': 'ale_linters#d#dmd#Handle',
+\   'output_stream': 'stderr',
 \})

ale_linters/dafny/dafny.vim

@@ -0,0 +1,26 @@
+" Author: Taylor Blau <me@ttaylorr.com>
+
+function! ale_linters#dafny#dafny#Handle(buffer, lines) abort
+    let l:pattern = '\v(.*)\((\d+),(\d+)\): (.*): (.*)'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \    'bufnr': a:buffer,
+        \    'col': l:match[3] + 0,
+        \    'lnum': l:match[2] + 0,
+        \    'text': l:match[5],
+        \    'type': l:match[4] =~# '^Error' ? 'E' : 'W'
+        \ })
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('dafny', {
+\    'name': 'dafny',
+\    'executable': 'dafny',
+\    'command': 'dafny %s /compile:0',
+\    'callback': 'ale_linters#dafny#dafny#Handle',
+\    'lint_file': 1,
+\ })

ale_linters/dart/dartanalyzer.vim

@@ -0,0 +1,36 @@
+" Author: w0rp <devw0rp@gmail.com>
+" Description: Check Dart files with dartanalyzer
+
+call ale#Set('dart_dartanalyzer_executable', 'dartanalyzer')
+
+function! ale_linters#dart#dartanalyzer#GetCommand(buffer) abort
+    let l:path = ale#path#FindNearestFile(a:buffer, '.packages')
+
+    return '%e'
+    \   . (!empty(l:path) ? ' --packages ' . ale#Escape(l:path) : '')
+    \   . ' %s'
+endfunction
+
+function! ale_linters#dart#dartanalyzer#Handle(buffer, lines) abort
+    let l:pattern = '\v^  ([a-z]+) . (.+) at (.+):(\d+):(\d+) . (.+)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'type': l:match[1] is# 'error' ? 'E' : 'W',
+        \   'text': l:match[6] . ': ' . l:match[2],
+        \   'lnum': str2nr(l:match[4]),
+        \   'col': str2nr(l:match[5]),
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('dart', {
+\   'name': 'dartanalyzer',
+\   'executable': {b -> ale#Var(b, 'dart_dartanalyzer_executable')},
+\   'command': function('ale_linters#dart#dartanalyzer#GetCommand'),
+\   'callback': 'ale_linters#dart#dartanalyzer#Handle',
+\   'lint_file': 1,
+\})

ale_linters/dart/language_server.vim

@@ -0,0 +1,20 @@
+" Author: aurieh <me@aurieh.me>
+" Description: A language server for dart
+
+call ale#Set('dart_language_server_executable', 'dart_language_server')
+
+function! ale_linters#dart#language_server#GetProjectRoot(buffer) abort
+    " Note: pub only looks for pubspec.yaml, there's no point in adding
+    " support for pubspec.yml
+    let l:pubspec = ale#path#FindNearestFile(a:buffer, 'pubspec.yaml')
+
+    return !empty(l:pubspec) ? fnamemodify(l:pubspec, ':h:h') : ''
+endfunction
+
+call ale#linter#Define('dart', {
+\   'name': 'language_server',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'dart_language_server_executable')},
+\   'command': '%e',
+\   'project_root': function('ale_linters#dart#language_server#GetProjectRoot'),
+\})

ale_linters/dockerfile/dockerfile_lint.vim

@@ -0,0 +1,61 @@
+" Author: Alexander Olofsson <alexander.olofsson@liu.se>
+
+call ale#Set('dockerfile_dockerfile_lint_executable', 'dockerfile_lint')
+call ale#Set('dockerfile_dockerfile_lint_options', '')
+
+function! ale_linters#dockerfile#dockerfile_lint#GetType(type) abort
+    if a:type is? 'error'
+        return 'E'
+    elseif a:type is? 'warn'
+        return 'W'
+    endif
+
+    return 'I'
+endfunction
+
+function! ale_linters#dockerfile#dockerfile_lint#Handle(buffer, lines) abort
+    try
+        let l:data = json_decode(join(a:lines, ''))
+    catch
+        return []
+    endtry
+
+    if empty(l:data)
+        " Should never happen, but it's better to be on the safe side
+        return []
+    endif
+
+    let l:messages = []
+
+    for l:type in ['error', 'warn', 'info']
+        for l:object in l:data[l:type]['data']
+            let l:line = get(l:object, 'line', -1)
+            let l:message = l:object['message']
+
+            if get(l:object, 'description', 'None') isnot# 'None'
+                let l:message = l:message . '. ' . l:object['description']
+            endif
+
+            call add(l:messages, {
+            \   'lnum': l:line,
+            \   'text': l:message,
+            \   'type': ale_linters#dockerfile#dockerfile_lint#GetType(l:type),
+            \})
+        endfor
+    endfor
+
+    return l:messages
+endfunction
+
+function! ale_linters#dockerfile#dockerfile_lint#GetCommand(buffer) abort
+    return '%e' . ale#Pad(ale#Var(a:buffer, 'dockerfile_dockerfile_lint_options'))
+    \   . ' -p -j -f'
+    \   . ' %t'
+endfunction
+
+call ale#linter#Define('dockerfile', {
+\   'name': 'dockerfile_lint',
+\   'executable': {b -> ale#Var(b, 'dockerfile_dockerfile_lint_executable')},
+\   'command': function('ale_linters#dockerfile#dockerfile_lint#GetCommand'),
+\   'callback': 'ale_linters#dockerfile#dockerfile_lint#Handle',
+\})

ale_linters/dockerfile/hadolint.vim

@@ -0,0 +1,99 @@
+" Author: hauleth - https://github.com/hauleth
+
+" always, yes, never
+call ale#Set('dockerfile_hadolint_use_docker', 'never')
+call ale#Set('dockerfile_hadolint_docker_image', 'hadolint/hadolint')
+
+function! ale_linters#dockerfile#hadolint#Handle(buffer, lines) abort
+    " Matches patterns line the following:
+    "
+    " /dev/stdin:19 DL3001 Pipe chain should start with a raw value.
+    " /dev/stdin:19:3 unexpected thing
+    let l:pattern = '\v^/dev/stdin:(\d+):?(\d+)? ((DL|SC)(\d+) )?(.+)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:lnum = 0
+        let l:colnum = 0
+
+        if l:match[1] isnot# ''
+            let l:lnum = l:match[1] + 0
+        endif
+
+        if l:match[2] isnot# ''
+            let l:colnum = l:match[2] + 0
+        endif
+
+        let l:type = 'W'
+        let l:text = l:match[6]
+        let l:detail = l:match[6]
+        let l:domain = 'https://github.com/hadolint/hadolint/wiki/'
+
+        if l:match[4] is# 'SC'
+            let l:domain = 'https://github.com/koalaman/shellcheck/wiki/'
+        endif
+
+        if l:match[5] isnot# ''
+            let l:code = l:match[4] . l:match[5]
+            let l:link = ' ( ' . l:domain . l:code . ' )'
+            let l:detail = l:code . l:link . "\n\n" . l:detail
+        else
+            let l:type = 'E'
+        endif
+
+        call add(l:output, {
+        \   'lnum': l:lnum,
+        \   'col': l:colnum,
+        \   'type': l:type,
+        \   'text': l:text,
+        \   'detail': l:detail
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+" This is a little different than the typical 'executable' callback.  We want
+" to afford the user the chance to say always use docker, never use docker,
+" and use docker if the hadolint executable is not present on the system.
+"
+" In the case of neither docker nor hadolint executables being present, it
+" really doesn't matter which we return -- either will have the effect of
+" 'nope, can't use this linter!'.
+
+function! ale_linters#dockerfile#hadolint#GetExecutable(buffer) abort
+    let l:use_docker = ale#Var(a:buffer, 'dockerfile_hadolint_use_docker')
+
+    " check for mandatory directives
+    if l:use_docker is# 'never'
+        return 'hadolint'
+    elseif l:use_docker is# 'always'
+        return 'docker'
+    endif
+
+    " if we reach here, we want to use 'hadolint' if present...
+    if executable('hadolint')
+        return 'hadolint'
+    endif
+
+    "... and 'docker' as a fallback.
+    return 'docker'
+endfunction
+
+function! ale_linters#dockerfile#hadolint#GetCommand(buffer) abort
+    let l:command = ale_linters#dockerfile#hadolint#GetExecutable(a:buffer)
+
+    if l:command is# 'docker'
+        return 'docker run --rm -i ' . ale#Var(a:buffer, 'dockerfile_hadolint_docker_image')
+    endif
+
+    return 'hadolint -'
+endfunction
+
+
+call ale#linter#Define('dockerfile', {
+\   'name': 'hadolint',
+\   'executable': function('ale_linters#dockerfile#hadolint#GetExecutable'),
+\   'command': function('ale_linters#dockerfile#hadolint#GetCommand'),
+\   'callback': 'ale_linters#dockerfile#hadolint#Handle',
+\})

ale_linters/elixir/credo.vim

@@ -1,51 +1,63 @@
-" Author: hauleth - https://github.com/haulethe
+" Author: hauleth - https://github.com/hauleth
 
-if exists('g:loaded_ale_linters_elixir_credo')
-  finish
-endif
+function! ale_linters#elixir#credo#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 = []
 
-let g:loaded_ale_linters_elixir_credo = 1
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:type = l:match[3]
+        let l:text = l:match[4]
 
-function! ale_linters#elixir#credo#Handle(buffer, lines)
-  " Matches patterns line the following:
-  "
-  " stdin:19: F: Pipe chain should start with a raw value.
-  let l:pattern = '\v^stdin:(\d+):?(\d+)?: (.): (.+)$'
-  let l:output = []
+        " Refactoring opportunities
+        if l:type is# 'F'
+            let l:type = 'W'
+        " Consistency
+        elseif l:type is# 'C'
+            let l:type = 'W'
+        " Software Design
+        elseif l:type is# 'D'
+            let l:type = 'I'
+        " Code Readability
+        elseif l:type is# 'R'
+            let l:type = 'I'
+        endif
 
-  for l:line in a:lines
-    let l:match = matchlist(l:line, l:pattern)
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:match[2] + 0,
+        \   'type': l:type,
+        \   'text': l:text,
+        \})
+    endfor
 
-    if len(l:match) == 0
-        continue
+    return l:output
+endfunction
+
+function! ale_linters#elixir#credo#GetMode() abort
+    if get(g:, 'ale_elixir_credo_strict', 0)
+        return '--strict'
+    else
+        return 'suggest'
     endif
+endfunction
 
-    let l:type = l:match[3]
-    let l:text = l:match[4]
+function! ale_linters#elixir#credo#GetCommand(buffer) abort
+    let l:project_root = ale#handlers#elixir#FindMixProjectRoot(a:buffer)
+    let l:mode = ale_linters#elixir#credo#GetMode()
 
-    if l:type ==# 'C'
-      let l:type = 'E'
-    elseif l:type ==# 'R'
-      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
-
-  return l:output
+    return ale#path#CdString(l:project_root)
+    \ . 'mix help credo && '
+    \ . 'mix credo ' . ale_linters#elixir#credo#GetMode()
+    \ . ' --format=flycheck --read-from-stdin %s'
 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': function('ale_linters#elixir#credo#GetCommand'),
+\   'callback': 'ale_linters#elixir#credo#Handle',
+\})

ale_linters/elixir/dialyxir.vim

@@ -0,0 +1,41 @@
+" Author: Fran C. - https://github.com/franciscoj
+" Description: Add dialyzer support for elixir through dialyxir
+" https://github.com/jeremyjh/dialyxir
+
+function! ale_linters#elixir#dialyxir#Handle(buffer, lines) abort
+    " Matches patterns line the following:
+    "
+    " lib/filename.ex:19: Function fname/1 has no local return
+    let l:pattern = '\v(.+):(\d+): (.+)$'
+    let l:output = []
+    let l:type = 'W'
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        if bufname(a:buffer) == l:match[1]
+            call add(l:output, {
+            \   'bufnr': a:buffer,
+            \   'lnum': l:match[2] + 0,
+            \   'col': 0,
+            \   'type': l:type,
+            \   'text': l:match[3],
+            \})
+        endif
+    endfor
+
+    return l:output
+endfunction
+
+function! ale_linters#elixir#dialyxir#GetCommand(buffer) abort
+    let l:project_root = ale#handlers#elixir#FindMixProjectRoot(a:buffer)
+
+    return ale#path#CdString(l:project_root)
+    \ . ' mix help dialyzer && mix dialyzer'
+endfunction
+
+call ale#linter#Define('elixir', {
+\   'name': 'dialyxir',
+\   'executable': 'mix',
+\   'command': function('ale_linters#elixir#dialyxir#GetCommand'),
+\   'callback': 'ale_linters#elixir#dialyxir#Handle',
+\})
+

ale_linters/elixir/dogma.vim

@@ -0,0 +1,45 @@
+" 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 is# 'C'
+            let l:type = 'E'
+        elseif l:type is# '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
+
+function! ale_linters#elixir#dogma#GetCommand(buffer) abort
+    let l:project_root = ale#handlers#elixir#FindMixProjectRoot(a:buffer)
+
+    return ale#path#CdString(l:project_root)
+    \ . ' mix help dogma && mix dogma %s --format=flycheck'
+endfunction
+
+call ale#linter#Define('elixir', {
+\   'name': 'dogma',
+\   'executable': 'mix',
+\   'command': function('ale_linters#elixir#dogma#GetCommand'),
+\   'lint_file': 1,
+\   'callback': 'ale_linters#elixir#dogma#Handle',
+\})

ale_linters/elixir/elixir_ls.vim

@@ -0,0 +1,21 @@
+" Author: Jon Parise <jon@indelible.org>
+" Description: ElixirLS integration (https://github.com/JakeBecker/elixir-ls)
+
+call ale#Set('elixir_elixir_ls_release', 'elixir-ls')
+call ale#Set('elixir_elixir_ls_config', {})
+
+function! ale_linters#elixir#elixir_ls#GetExecutable(buffer) abort
+    let l:dir = ale#path#Simplify(ale#Var(a:buffer, 'elixir_elixir_ls_release'))
+    let l:cmd = has('win32') ? '\language_server.bat' : '/language_server.sh'
+
+    return l:dir . l:cmd
+endfunction
+
+call ale#linter#Define('elixir', {
+\   'name': 'elixir-ls',
+\   'lsp': 'stdio',
+\   'executable': function('ale_linters#elixir#elixir_ls#GetExecutable'),
+\   'command': function('ale_linters#elixir#elixir_ls#GetExecutable'),
+\   'project_root': function('ale#handlers#elixir#FindMixUmbrellaRoot'),
+\   'lsp_config': {b -> ale#Var(b, 'elixir_elixir_ls_config')},
+\})

ale_linters/elixir/mix.vim

@@ -0,0 +1,52 @@
+" Author: evnu - https://github.com/evnu
+" Author: colbydehart - https://github.com/colbydehart
+" Description: Mix compile checking for Elixir files
+
+function! ale_linters#elixir#mix#Handle(buffer, lines) abort
+    " Matches patterns like the following:
+    "
+    " Error format
+    " ** (CompileError) apps/sim/lib/sim/server.ex:87: undefined function update_in/4
+    "
+    " TODO: Warning format
+    " warning: variable "foobar" does not exist and is being expanded to "foobar()", please use parentheses to remove the ambiguity or change the variable name
+    let l:pattern = '\v\(([^\)]+Error)\) ([^:]+):([^:]+): (.+)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:type = 'E'
+        let l:text = l:match[4]
+
+        call add(l:output, {
+        \   'bufnr': a:buffer,
+        \   'lnum': l:match[3] + 0,
+        \   'col': 0,
+        \   'type': l:type,
+        \   'text': l:text,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+function! ale_linters#elixir#mix#GetCommand(buffer) abort
+    let l:project_root = ale#handlers#elixir#FindMixProjectRoot(a:buffer)
+
+    let l:temp_dir = ale#command#CreateDirectory(a:buffer)
+
+    let l:mix_build_path = has('win32')
+    \   ? 'set MIX_BUILD_PATH=' . ale#Escape(l:temp_dir) . ' &&'
+    \   : 'MIX_BUILD_PATH=' . ale#Escape(l:temp_dir)
+
+    return ale#path#CdString(l:project_root)
+    \ . l:mix_build_path
+    \ . ' mix compile %s'
+endfunction
+
+call ale#linter#Define('elixir', {
+\   'name': 'mix',
+\   'executable': 'mix',
+\   'command': function('ale_linters#elixir#mix#GetCommand'),
+\   'callback': 'ale_linters#elixir#mix#Handle',
+\   'lint_file': 1,
+\})

ale_linters/elm/elm_lsp.vim

@@ -0,0 +1,22 @@
+" Author: antew - https://github.com/antew
+" Description: LSP integration for elm, currently supports diagnostics (linting)
+
+call ale#Set('elm_lsp_executable', 'elm-lsp')
+call ale#Set('elm_lsp_use_global', get(g:, 'ale_use_global_executables', 0))
+
+function! elm_lsp#GetRootDir(buffer) abort
+    let l:elm_json = ale#path#FindNearestFile(a:buffer, 'elm.json')
+
+    return !empty(l:elm_json) ? fnamemodify(l:elm_json, ':p:h') : ''
+endfunction
+
+call ale#linter#Define('elm', {
+\   'name': 'elm_lsp',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#node#FindExecutable(b, 'elm_lsp', [
+\       'node_modules/.bin/elm-lsp',
+\   ])},
+\   'command': '%e --stdio',
+\   'project_root': function('elm_lsp#GetRootDir'),
+\   'language': 'elm'
+\})

ale_linters/elm/make.vim

@@ -0,0 +1,240 @@
+" Author: buffalocoder - https://github.com/buffalocoder, soywod - https://github.com/soywod, hecrj - https://github.com/hecrj
+" Description: Elm linting in Ale. Closely follows the Syntastic checker in https://github.com/ElmCast/elm-vim.
+
+call ale#Set('elm_make_executable', 'elm')
+call ale#Set('elm_make_use_global', get(g:, 'ale_use_global_executables', 0))
+
+function! ale_linters#elm#make#Handle(buffer, lines) abort
+    let l:output = []
+    let l:unparsed_lines = []
+
+    for l:line in a:lines
+        if l:line[0] is# '{'
+            " Elm 0.19
+            call ale_linters#elm#make#HandleElm019Line(l:line, l:output)
+        elseif l:line[0] is# '['
+            " Elm 0.18
+            call ale_linters#elm#make#HandleElm018Line(l:line, l:output)
+        elseif l:line isnot# '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
+
+function! ale_linters#elm#make#HandleElm019Line(line, output) abort
+    let l:report = json_decode(a:line)
+
+    if l:report.type is? 'error'
+        " General problem
+        let l:details = ale_linters#elm#make#ParseMessage(l:report.message)
+
+        if empty(l:report.path)
+            let l:report.path = 'Elm'
+        endif
+
+        if ale_linters#elm#make#FileIsBuffer(l:report.path)
+            call add(a:output, {
+            \    'lnum': 1,
+            \    'type': 'E',
+            \    'text': l:details,
+            \})
+        else
+            call add(a:output, {
+            \    'lnum': 1,
+            \    'type': 'E',
+            \    'text': l:report.path .' - '. l:details,
+            \    'detail': l:report.path ." ----------\n\n". l:details,
+            \})
+        endif
+    else
+        " Compilation errors
+        for l:error in l:report.errors
+            let l:file_is_buffer = ale_linters#elm#make#FileIsBuffer(l:error.path)
+
+            for l:problem in l:error.problems
+                let l:details = ale_linters#elm#make#ParseMessage(l:problem.message)
+
+                if l:file_is_buffer
+                    " Buffer module has problems
+                    call add(a:output, {
+                    \    'lnum': l:problem.region.start.line,
+                    \    'col': l:problem.region.start.column,
+                    \    'end_lnum': l:problem.region.end.line,
+                    \    'end_col': l:problem.region.end.column,
+                    \    'type': 'E',
+                    \    'text': l:details,
+                    \})
+                else
+                    " Imported module has problems
+                    let l:location = l:error.path .':'. l:problem.region.start.line
+                    call add(a:output, {
+                    \    'lnum': 1,
+                    \    'type': 'E',
+                    \    'text': l:location .' - '. l:details,
+                    \    'detail': l:location ." ----------\n\n". l:details,
+                    \})
+                endif
+            endfor
+        endfor
+    endif
+endfunction
+
+function! ale_linters#elm#make#HandleElm018Line(line, output) abort
+    let l:errors = json_decode(a:line)
+
+    for l:error in l:errors
+        let l:file_is_buffer = ale_linters#elm#make#FileIsBuffer(l:error.file)
+
+        if l:file_is_buffer
+            " Current buffer has problems
+            call add(a:output, {
+            \    'lnum': l:error.region.start.line,
+            \    'col': l:error.region.start.column,
+            \    'end_lnum': l:error.region.end.line,
+            \    'end_col': l:error.region.end.column,
+            \    'type': (l:error.type is? 'error') ? 'E' : 'W',
+            \    'text': l:error.overview,
+            \    'detail': l:error.overview . "\n\n" . l:error.details
+            \})
+        elseif l:error.type is? 'error'
+            " Imported module has errors
+            let l:location = l:error.file .':'. l:error.region.start.line
+
+            call add(a:output, {
+            \    'lnum': 1,
+            \    'type': 'E',
+            \    'text': l:location .' - '. l:error.overview,
+            \    'detail': l:location ." ----------\n\n". l:error.overview . "\n\n" . l:error.details
+            \})
+        endif
+    endfor
+endfunction
+
+function! ale_linters#elm#make#FileIsBuffer(path) abort
+    return ale#path#IsTempName(a:path)
+endfunction
+
+function! ale_linters#elm#make#ParseMessage(message) abort
+    return join(map(copy(a:message), 'ale_linters#elm#make#ParseMessageItem(v:val)'), '')
+endfunction
+
+function! ale_linters#elm#make#ParseMessageItem(item) abort
+    if type(a:item) is v:t_string
+        return a:item
+    else
+        return a:item.string
+    endif
+endfunction
+
+function! ale_linters#elm#make#GetPackageFile(buffer) abort
+    let l:elm_json = ale#path#FindNearestFile(a:buffer, 'elm.json')
+
+    if empty(l:elm_json)
+        " Fallback to Elm 0.18
+        let l:elm_json = ale#path#FindNearestFile(a:buffer, 'elm-package.json')
+    endif
+
+    return l:elm_json
+endfunction
+
+function! ale_linters#elm#make#IsVersionGte19(buffer) abort
+    let l:elm_json = ale_linters#elm#make#GetPackageFile(a:buffer)
+
+    if l:elm_json =~# '-package'
+        return 0
+    else
+        return 1
+    endif
+endfunction
+
+function! ale_linters#elm#make#GetRootDir(buffer) abort
+    let l:elm_json = ale_linters#elm#make#GetPackageFile(a:buffer)
+
+    if empty(l:elm_json)
+        return ''
+    else
+        return fnamemodify(l:elm_json, ':p:h')
+    endif
+endfunction
+
+function! ale_linters#elm#make#IsTest(buffer) abort
+    let l:root_dir = ale_linters#elm#make#GetRootDir(a:buffer)
+
+    if empty(l:root_dir)
+        return 0
+    endif
+
+    let l:tests_dir = join([l:root_dir, 'tests', ''], has('win32') ? '\' : '/')
+
+    let l:buffer_path = fnamemodify(bufname(a:buffer), ':p')
+
+    if stridx(l:buffer_path, l:tests_dir) == 0
+        return 1
+    else
+        return 0
+    endif
+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:executable = ale_linters#elm#make#GetExecutable(a:buffer)
+    let l:root_dir = ale_linters#elm#make#GetRootDir(a:buffer)
+    let l:is_v19 = ale_linters#elm#make#IsVersionGte19(a:buffer)
+    let l:is_using_elm_test = l:executable =~# 'elm-test$'
+
+    if empty(l:root_dir)
+        let l:dir_set_cmd = ''
+    else
+        let l:dir_set_cmd = 'cd ' . ale#Escape(l:root_dir) . ' && '
+    endif
+
+    " elm-test needs to know the path of elm-make if elm isn't installed globally.
+    " https://github.com/rtfeldman/node-test-runner/blob/57728f10668f2d2ab3179e7e3208bcfa9a1f19aa/README.md#--compiler
+    if l:is_v19 && l:is_using_elm_test
+        let l:elm_make_executable = ale#node#FindExecutable(a:buffer, 'elm_make', ['node_modules/.bin/elm'])
+        let l:elm_test_compiler_flag = ' --compiler ' . l:elm_make_executable . ' '
+    else
+        let l:elm_test_compiler_flag = ' '
+    endif
+
+    " The elm 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-compiler/blob/19d5a769b30ec0b2fc4475985abb4cd94cd1d6c3/builder/src/Generate/Output.hs#L253
+    return l:dir_set_cmd . '%e make --report=json --output=/dev/null' . l:elm_test_compiler_flag . '%t'
+endfunction
+
+function! ale_linters#elm#make#GetExecutable(buffer) abort
+    let l:is_test = ale_linters#elm#make#IsTest(a:buffer)
+    let l:is_v19 = ale_linters#elm#make#IsVersionGte19(a:buffer)
+
+    if l:is_test && l:is_v19
+        return ale#node#FindExecutable(
+        \   a:buffer,
+        \   'elm_make',
+        \   ['node_modules/.bin/elm-test', 'node_modules/.bin/elm']
+        \)
+    else
+        return ale#node#FindExecutable(a:buffer, 'elm_make', ['node_modules/.bin/elm'])
+    endif
+endfunction
+
+call ale#linter#Define('elm', {
+\   'name': 'make',
+\   'executable': function('ale_linters#elm#make#GetExecutable'),
+\   'output_stream': 'both',
+\   'command': function('ale_linters#elm#make#GetCommand'),
+\   'callback': 'ale_linters#elm#make#Handle'
+\})

ale_linters/erlang/erlc.vim

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

ale_linters/erlang/syntaxerl.vim

@@ -0,0 +1,42 @@
+" Author: Dmitri Vereshchagin <dmitri.vereshchagin@gmail.com>
+" Description: SyntaxErl linter for Erlang files
+
+call ale#Set('erlang_syntaxerl_executable', 'syntaxerl')
+
+function! ale_linters#erlang#syntaxerl#RunHelpCommand(buffer) abort
+    let l:executable = ale#Var(a:buffer, 'erlang_syntaxerl_executable')
+
+    return ale#command#Run(
+    \   a:buffer,
+    \   ale#Escape(l:executable) . ' -h',
+    \   function('ale_linters#erlang#syntaxerl#GetCommand'),
+    \)
+endfunction
+
+function! ale_linters#erlang#syntaxerl#GetCommand(buffer, output, meta) abort
+    let l:use_b_option = match(a:output, '\C\V-b, --base\>') > -1
+
+    return '%e' . (l:use_b_option ? ' -b %s %t' : ' %t')
+endfunction
+
+function! ale_linters#erlang#syntaxerl#Handle(buffer, lines) abort
+    let l:pattern = '\v\C:(\d+):( warning:)? (.+)'
+    let l:loclist = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:loclist, {
+        \   'lnum': l:match[1] + 0,
+        \   'text': l:match[3],
+        \   'type': empty(l:match[2]) ? 'E' : 'W',
+        \})
+    endfor
+
+    return l:loclist
+endfunction
+
+call ale#linter#Define('erlang', {
+\   'name': 'syntaxerl',
+\   'executable': {b -> ale#Var(b, 'erlang_syntaxerl_executable')},
+\   'command': {b -> ale_linters#erlang#syntaxerl#RunHelpCommand(b)},
+\   'callback': 'ale_linters#erlang#syntaxerl#Handle',
+\})

ale_linters/eruby/erb.vim

@@ -0,0 +1,25 @@
+" Author: Matthias Guenther - https://wikimatze.de, Eddie Lebow https://github.com/elebow
+" Description: ERB from the Ruby standard library, for eruby/erb files
+
+function! ale_linters#eruby#erb#GetCommand(buffer) abort
+    let l:rails_root = ale#ruby#FindRailsRoot(a:buffer)
+
+    if empty(l:rails_root)
+        return 'erb -P -T - -x %t | ruby -c'
+    endif
+
+    " Rails-flavored eRuby does not comply with the standard as understood by
+    " ERB, so we'll have to do some substitution. This does not reduce the
+    " effectiveness of the linter—the translated code is still evaluated.
+    return 'ruby -r erb -e ' . ale#Escape('puts ERB.new($stdin.read.gsub(%{<%=},%{<%}), nil, %{-}).src') . '< %t | ruby -c'
+endfunction
+
+call ale#linter#Define('eruby', {
+\   'name': 'erb',
+\   'aliases': ['erubylint'],
+\   'executable': 'erb',
+\   'output_stream': 'stderr',
+\   'command': function('ale_linters#eruby#erb#GetCommand'),
+\   'callback': 'ale#handlers#ruby#HandleSyntaxErrors',
+\})
+

ale_linters/eruby/erubi.vim

@@ -0,0 +1,32 @@
+" Author: Eddie Lebow https://github.com/elebow
+" Description: eruby checker using `erubi`
+
+function! ale_linters#eruby#erubi#GetCommand(buffer, output, meta) abort
+    let l:rails_root = ale#ruby#FindRailsRoot(a:buffer)
+
+    if !empty(a:output)
+        " The empty command in CheckErubi returns nothing if erubi runs and
+        " emits an error if erubi is not present
+        return ''
+    endif
+
+    if empty(l:rails_root)
+        return 'ruby -r erubi/capture_end -e ' . ale#Escape('puts Erubi::CaptureEndEngine.new($stdin.read).src') . '< %t | ruby -c'
+    endif
+
+    " Rails-flavored eRuby does not comply with the standard as understood by
+    " Erubi, so we'll have to do some substitution. This does not reduce the
+    " effectiveness of the linter---the translated code is still evaluated.
+    return 'ruby -r erubi/capture_end -e ' . ale#Escape('puts Erubi::CaptureEndEngine.new($stdin.read.gsub(%{<%=},%{<%}), nil, %{-}).src') . '< %t | ruby -c'
+endfunction
+
+call ale#linter#Define('eruby', {
+\   'name': 'erubi',
+\   'executable': 'ruby',
+\   'command': {buffer -> ale#command#Run(
+\       buffer,
+\       'ruby -r erubi/capture_end -e ' . ale#Escape('""'),
+\       function('ale_linters#eruby#erubi#GetCommand'),
+\   )},
+\   'callback': 'ale#handlers#ruby#HandleSyntaxErrors',
+\})

ale_linters/eruby/erubis.vim

@@ -0,0 +1,23 @@
+" Author: Jake Zimmerman <jake@zimmerman.io>, Eddie Lebow https://github.com/elebow
+" Description: eruby checker using `erubis`, instead of `erb`
+
+function! ale_linters#eruby#erubis#GetCommand(buffer) abort
+    let l:rails_root = ale#ruby#FindRailsRoot(a:buffer)
+
+    if empty(l:rails_root)
+        return 'erubis -x %t | ruby -c'
+    endif
+
+    " Rails-flavored eRuby does not comply with the standard as understood by
+    " Erubis, so we'll have to do some substitution. This does not reduce the
+    " effectiveness of the linter - the translated code is still evaluated.
+    return 'ruby -r erubis -e ' . ale#Escape('puts Erubis::Eruby.new($stdin.read.gsub(%{<%=},%{<%})).src') . '< %t | ruby -c'
+endfunction
+
+call ale#linter#Define('eruby', {
+\   'name': 'erubis',
+\   'executable': 'erubis',
+\   'output_stream': 'stderr',
+\   'command': function('ale_linters#eruby#erubis#GetCommand'),
+\   'callback': 'ale#handlers#ruby#HandleSyntaxErrors',
+\})

ale_linters/eruby/ruumba.vim

@@ -0,0 +1,62 @@
+" Author: aclemons - https://github.com/aclemons
+" based on the ale rubocop linter
+" Description: Ruumba, RuboCop linting for ERB templates.
+
+call ale#Set('eruby_ruumba_executable', 'ruumba')
+call ale#Set('eruby_ruumba_options', '')
+
+function! ale_linters#eruby#ruumba#GetCommand(buffer) abort
+    let l:executable = ale#Var(a:buffer, 'eruby_ruumba_executable')
+
+    return ale#handlers#ruby#EscapeExecutable(l:executable, 'ruumba')
+    \   . ' --format json --force-exclusion '
+    \   . ale#Var(a:buffer, 'eruby_ruumba_options')
+    \   . ' --stdin ' . ale#Escape(expand('#' . a:buffer . ':p'))
+endfunction
+
+function! ale_linters#eruby#ruumba#Handle(buffer, lines) abort
+    try
+        let l:errors = json_decode(a:lines[0])
+    catch
+        return []
+    endtry
+
+    if !has_key(l:errors, 'summary')
+    \|| l:errors['summary']['offense_count'] == 0
+    \|| empty(l:errors['files'])
+        return []
+    endif
+
+    let l:output = []
+
+    for l:error in l:errors['files'][0]['offenses']
+        let l:start_col = l:error['location']['column'] + 0
+        call add(l:output, {
+        \   'lnum': l:error['location']['line'] + 0,
+        \   'col': l:start_col,
+        \   'end_col': l:start_col + l:error['location']['length'] - 1,
+        \   'code': l:error['cop_name'],
+        \   'text': l:error['message'],
+        \   'type': ale_linters#eruby#ruumba#GetType(l:error['severity']),
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+function! ale_linters#eruby#ruumba#GetType(severity) abort
+    if a:severity is? 'convention'
+    \|| a:severity is? 'warning'
+    \|| a:severity is? 'refactor'
+        return 'W'
+    endif
+
+    return 'E'
+endfunction
+
+call ale#linter#Define('eruby', {
+\   'name': 'ruumba',
+\   'executable': {b -> ale#Var(b, 'eruby_ruumba_executable')},
+\   'command': function('ale_linters#eruby#ruumba#GetCommand'),
+\   'callback': 'ale_linters#eruby#ruumba#Handle',
+\})

ale_linters/fish/fish.vim

@@ -0,0 +1,67 @@
+" Author: Niraj Thapaliya - https://github.com/nthapaliya
+" Description: Lints fish files using fish -n
+
+function! ale_linters#fish#fish#Handle(buffer, lines) abort
+    " Matches patterns such as:
+    "
+    " home/.config/fish/functions/foo.fish (line 1): Missing end to balance this function definition
+    " function foo
+    " ^
+    "
+    " OR, patterns such as:
+    "
+    " Unsupported use of '||'. In fish, please use 'COMMAND; or COMMAND'.
+    " /tmp/vLz620o/258/test.fish (line 2): if set -q SSH_CLIENT || set -q SSH_TTY
+    "                                                            ^
+    "
+    " fish -n can return errors in either format.
+    let l:pattern = '^\(.* (line \(\d\+\)): \)\(.*\)$'
+    let l:column_pattern = '^ *\^'
+    let l:output = []
+    let l:column_offset = 0
+    let l:last_line_with_message = ''
+
+    for l:line in a:lines
+        " Look for error lines first.
+        let l:match = matchlist(l:line, l:pattern)
+
+        if !empty(l:match)
+            if !empty(l:last_line_with_message)
+                let l:text = l:last_line_with_message
+            else
+                let l:text = l:match[3]
+            endif
+
+            let l:column_offset = len(l:match[1])
+
+            let l:last_line_with_message = ''
+            call add(l:output, {
+            \  'col': 0,
+            \  'lnum': str2nr(l:match[2]),
+            \  'text': l:text,
+            \})
+        else
+            " Look for column markers like '   ^' second.
+            " The column index will be set according to how long the line is.
+            let l:column_match = matchstr(l:line, l:column_pattern)
+
+            if !empty(l:column_match) && !empty(l:output)
+                let l:output[-1].col = len(l:column_match) - l:column_offset
+                let l:last_line_with_message = ''
+            else
+                let l:last_line_with_message = l:line
+                let l:column_offset = 0
+            endif
+        endif
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('fish', {
+\   'name': 'fish',
+\   'output_stream': 'stderr',
+\   'executable': 'fish',
+\   'command': 'fish -n %t',
+\   'callback': 'ale_linters#fish#fish#Handle',
+\})

ale_linters/fortran/gcc.vim

@@ -1,24 +1,19 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: gcc for Fortran files
 
-if exists('g:loaded_ale_linters_fortran_gcc')
-    finish
-endif
-
-let g:loaded_ale_linters_fortran_gcc = 1
-
+" This option can be set to 0 to use -ffixed-form
+call ale#Set('fortran_gcc_use_free_form', 1)
+call ale#Set('fortran_gcc_executable', 'gcc')
 " Set this option to change the GCC options for warnings for Fortran.
-if !exists('g:ale_fortran_gcc_options')
-    let g:ale_fortran_gcc_options = '-Wall'
-endif
+call ale#Set('fortran_gcc_options', '-Wall')
 
-function! ale_linters#fortran#gcc#Handle(buffer, lines)
+function! ale_linters#fortran#gcc#Handle(buffer, lines) abort
     " We have to match a starting line and a later ending line together,
     " like so.
     "
     " :21.34:
     " Error: Expected comma in I/O list at (1)
-    let l:line_marker_pattern = '^:\(\d\+\)\.\(\d\+\):$'
+    let l:line_marker_pattern = ':\(\d\+\)[.:]\=\(\d\+\)\=:\=$'
     let l:message_pattern = '^\(Error\|Warning\): \(.\+\)$'
     let l:looking_for_message = 0
     let l:last_loclist_obj = {}
@@ -41,15 +36,13 @@ function! ale_linters#fortran#gcc#Handle(buffer, lines)
 
             " Now we have the text, we can set it and add the error.
             let l:last_loclist_obj.text = l:match[2]
-            let l:last_loclist_obj.type = l:match[1] ==# 'Warning' ? 'W' : 'E'
+            let l:last_loclist_obj.type = l:match[1] is# 'Warning' ? 'W' : 'E'
             call add(l:output, l:last_loclist_obj)
         else
             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.
@@ -60,12 +53,20 @@ function! ale_linters#fortran#gcc#Handle(buffer, lines)
     return l:output
 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 '%e -S -x f95 -fsyntax-only ' . l:layout_option
+    \   . ale#Pad(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': {b -> ale#Var(b, 'fortran_gcc_executable')},
+\   'command': function('ale_linters#fortran#gcc#GetCommand'),
 \   'callback': 'ale_linters#fortran#gcc#Handle',
 \})

ale_linters/fortran/language_server.vim

@@ -0,0 +1,19 @@
+" Author: unpairedbracket ben.spiers22@gmail.com
+" Description: A language server for fortran
+
+call ale#Set('fortran_language_server_executable', 'fortls')
+call ale#Set('fortran_language_server_use_global', get(g:, 'ale_use_global_executables', 0))
+
+function! ale_linters#fortran#language_server#GetProjectRoot(buffer) abort
+    let l:fortls_file = ale#path#FindNearestFile(a:buffer, '.fortls')
+
+    return !empty(l:fortls_file) ? fnamemodify(l:fortls_file, ':h') : ''
+endfunction
+
+call ale#linter#Define('fortran', {
+\   'name': 'language_server',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'fortran_language_server_executable')},
+\   'command': '%e',
+\   'project_root': function('ale_linters#fortran#language_server#GetProjectRoot'),
+\})

ale_linters/fountain/proselint.vim

@@ -0,0 +1,9 @@
+" Author: Jansen Mitchell https://github.com/JansenMitchell
+" Description: proselint for Fountain files
+
+call ale#linter#Define('fountain', {
+\    'name': 'proselint',
+\    'executable': 'proselint',
+\    'command': 'proselint %t',
+\    'callback': 'ale#handlers#unix#HandleAsWarning',
+\})

ale_linters/fuse/fusionlint.vim

@@ -0,0 +1,33 @@
+" Author: RyanSquared <vandor2012@gmail.com>
+" Description: `fusion-lint` linter for FusionScript files
+
+call ale#Set('fuse_fusionlint_executable', 'fusion-lint')
+call ale#Set('fuse_fusionlint_options', '')
+
+function! ale_linters#fuse#fusionlint#GetCommand(buffer) abort
+    return '%e' . ale#Pad(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': {b -> ale#Var(b, 'fuse_fusionlint_executable')},
+\   'command': function('ale_linters#fuse#fusionlint#GetCommand'),
+\   'callback': 'ale_linters#fuse#fusionlint#Handle',
+\})

ale_linters/gitcommit/gitlint.vim

@@ -0,0 +1,51 @@
+" Author: Nick Yamane <nick.diego@gmail.com>
+" Description: gitlint for git commit message files
+
+call ale#Set('gitcommit_gitlint_executable', 'gitlint')
+call ale#Set('gitcommit_gitlint_options', '')
+call ale#Set('gitcommit_gitlint_use_global', get(g:, 'ale_use_global_executables', 0))
+
+function! ale_linters#gitcommit#gitlint#GetExecutable(buffer) abort
+    return ale#python#FindExecutable(a:buffer, 'gitcommit_gitlint', ['gitlint'])
+endfunction
+
+function! ale_linters#gitcommit#gitlint#GetCommand(buffer) abort
+    let l:options = ale#Var(a:buffer, 'gitcommit_gitlint_options')
+
+    return '%e' . ale#Pad(l:options) . ' lint'
+endfunction
+
+function! ale_linters#gitcommit#gitlint#Handle(buffer, lines) abort
+    " Matches patterns line the following:
+    let l:pattern = '\v^(\d+): (\w+) (.*)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:code = l:match[2]
+
+        if !ale#Var(a:buffer, 'warn_about_trailing_whitespace')
+            if l:code is# 'T2' || l:code is# 'B2'
+                continue
+            endif
+        endif
+
+        let l:item = {
+        \   'lnum': l:match[1] + 0,
+        \   'text': l:match[3],
+        \   'code': l:code,
+        \   'type': 'E',
+        \}
+
+        call add(l:output, l:item)
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('gitcommit', {
+\   'name': 'gitlint',
+\   'output_stream': 'stderr',
+\   'executable': function('ale_linters#gitcommit#gitlint#GetExecutable'),
+\   'command': function('ale_linters#gitcommit#gitlint#GetCommand'),
+\   'callback': 'ale_linters#gitcommit#gitlint#Handle',
+\})

ale_linters/glsl/glslang.vim

@@ -0,0 +1,40 @@
+" Author: Sven-Hendrik Haase <svenstaro@gmail.com>
+" Description: glslang-based linter for glsl files
+"
+" TODO: Once https://github.com/KhronosGroup/glslang/pull/1047 is accepted,
+" we can use stdin.
+
+call ale#Set('glsl_glslang_executable', 'glslangValidator')
+call ale#Set('glsl_glslang_options', '')
+
+function! ale_linters#glsl#glslang#GetCommand(buffer) abort
+    return '%e'
+    \   . ale#Pad(ale#Var(a:buffer, 'glsl_glslang_options'))
+    \   . ' -C %t'
+endfunction
+
+function! ale_linters#glsl#glslang#Handle(buffer, lines) abort
+    " Matches patterns like the following:
+    "
+    " ERROR: 0:5: 'foo' : undeclared identifier
+    let l:pattern = '^\(.\+\): \(\d\+\):\(\d\+\): \(.\+\)'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'lnum': str2nr(l:match[3]),
+        \   'col': str2nr(l:match[2]),
+        \   'text': l:match[4],
+        \   'type': l:match[1] is# 'ERROR' ? 'E' : 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('glsl', {
+\   'name': 'glslang',
+\   'executable': {b -> ale#Var(b, 'glsl_glslang_executable')},
+\   'command': function('ale_linters#glsl#glslang#GetCommand'),
+\   'callback': 'ale_linters#glsl#glslang#Handle',
+\})

ale_linters/glsl/glslls.vim

@@ -0,0 +1,30 @@
+" Author: Sven-Hendrik Haase <svenstaro@gmail.com>
+" Description: A language server for glsl
+
+call ale#Set('glsl_glslls_executable', 'glslls')
+call ale#Set('glsl_glslls_logfile', '')
+
+function! ale_linters#glsl#glslls#GetCommand(buffer) abort
+    let l:logfile = ale#Var(a:buffer, 'glsl_glslls_logfile')
+    let l:logfile_args = ''
+
+    if l:logfile isnot# ''
+        let l:logfile_args = ' --verbose -l ' . l:logfile
+    endif
+
+    return '%e' . l:logfile_args . ' --stdin'
+endfunction
+
+function! ale_linters#glsl#glslls#GetProjectRoot(buffer) abort
+    let l:project_root = ale#c#FindProjectRoot(a:buffer)
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h:h') : ''
+endfunction
+
+call ale#linter#Define('glsl', {
+\   'name': 'glslls',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'glsl_glslls_executable')},
+\   'command': function('ale_linters#glsl#glslls#GetCommand'),
+\   'project_root': function('ale_linters#glsl#glslls#GetProjectRoot'),
+\})

ale_linters/go/bingo.vim

@@ -0,0 +1,29 @@
+" Author: Jerko Steiner <https://github.com/jeremija>
+" Description: https://github.com/saibing/bingo
+
+call ale#Set('go_bingo_executable', 'bingo')
+call ale#Set('go_bingo_options', '--mode stdio')
+
+function! ale_linters#go#bingo#GetCommand(buffer) abort
+    return '%e' . ale#Pad(ale#Var(a:buffer, 'go_bingo_options'))
+endfunction
+
+function! ale_linters#go#bingo#FindProjectRoot(buffer) abort
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'go.mod')
+    let l:mods = ':h'
+
+    if empty(l:project_root)
+        let l:project_root = ale#path#FindNearestDirectory(a:buffer, '.git')
+        let l:mods = ':h:h'
+    endif
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, l:mods) : ''
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'bingo',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'go_bingo_executable')},
+\   'command': function('ale_linters#go#bingo#GetCommand'),
+\   'project_root': function('ale_linters#go#bingo#FindProjectRoot'),
+\})

ale_linters/go/gobuild.vim

@@ -0,0 +1,56 @@
+" Author: Joshua Rubin <joshua@rubixconsulting.com>, Ben Reedy <https://github.com/breed808>,
+" Jeff Willette <jrwillette88@gmail.com>
+" Description: go build for Go files
+" inspired by work from dzhou121 <dzhou121@gmail.com>
+
+call ale#Set('go_go_executable', 'go')
+call ale#Set('go_gobuild_options', '')
+
+function! ale_linters#go#gobuild#GetCommand(buffer) abort
+    let l:options = ale#Var(a:buffer, 'go_gobuild_options')
+
+    " Run go test in local directory with relative path
+    return ale#path#BufferCdString(a:buffer)
+    \   . ale#Var(a:buffer, 'go_go_executable') . ' test'
+    \   . (!empty(l:options) ? ' ' . l:options : '')
+    \   . ' -c -o /dev/null ./'
+endfunction
+
+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"
+    " go test returns relative paths so use tail of filename as part of pattern matcher
+    let l:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+):?(\d+)?:? (.+)$'
+
+    return ale#util#GetMatches(a:lines, l:pattern)
+endfunction
+
+function! ale_linters#go#gobuild#Handler(buffer, lines) abort
+    let l:dir = expand('#' . a:buffer . ':p:h')
+    let l:output = []
+
+    for l:match in ale_linters#go#gobuild#GetMatches(a:lines)
+        call add(l:output, {
+        \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'text': l:match[4],
+        \   'type': 'E',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'gobuild',
+\   'aliases': ['go build'],
+\   'executable': {b -> ale#Var(b, 'go_go_executable')},
+\   'command': function('ale_linters#go#gobuild#GetCommand'),
+\   'output_stream': 'stderr',
+\   'callback': 'ale_linters#go#gobuild#Handler',
+\   'lint_file': 1,
+\})

ale_linters/go/gofmt.vim

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

ale_linters/go/golangci_lint.vim

@@ -0,0 +1,56 @@
+" Author: Sascha Grunert <mail@saschagrunert.de>
+" Description: Adds support of golangci-lint
+
+call ale#Set('go_golangci_lint_options', '--enable-all')
+call ale#Set('go_golangci_lint_executable', 'golangci-lint')
+call ale#Set('go_golangci_lint_package', 0)
+
+function! ale_linters#go#golangci_lint#GetCommand(buffer) abort
+    let l:filename = expand('#' . a:buffer . ':t')
+    let l:options = ale#Var(a:buffer, 'go_golangci_lint_options')
+    let l:lint_package = ale#Var(a:buffer, 'go_golangci_lint_package')
+
+    if l:lint_package
+        return ale#path#BufferCdString(a:buffer)
+        \   . '%e run '
+        \   .  l:options
+    endif
+
+    return ale#path#BufferCdString(a:buffer)
+    \   . '%e run '
+    \   . ale#Escape(l:filename)
+    \   . ' ' . l:options
+endfunction
+
+function! ale_linters#go#golangci_lint#GetMatches(lines) abort
+    let l:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+):?(\d+)?:?:?:?\s\*?(.+)$'
+
+    return ale#util#GetMatches(a:lines, l:pattern)
+endfunction
+
+function! ale_linters#go#golangci_lint#Handler(buffer, lines) abort
+    let l:dir = expand('#' . a:buffer . ':p:h')
+    let l:output = []
+
+    for l:match in ale_linters#go#golangci_lint#GetMatches(a:lines)
+        " l:match[1] will already be an absolute path, output from
+        " golangci_lint
+        call add(l:output, {
+        \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'type': 'E',
+        \   'text': l:match[4],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'golangci-lint',
+\   'executable': {b -> ale#Var(b, 'go_golangci_lint_executable')},
+\   'command': function('ale_linters#go#golangci_lint#GetCommand'),
+\   'callback': 'ale_linters#go#golangci_lint#Handler',
+\   'lint_file': 1,
+\})

ale_linters/go/golint.vim

@@ -1,15 +1,21 @@
 " Author: neersighted <bjorn@neersighted.com>
 " Description: golint for Go files
 
-if exists('g:loaded_ale_linters_go_golint')
-    finish
-endif
+call ale#Set('go_golint_executable', 'golint')
+call ale#Set('go_golint_options', '')
 
-let g:loaded_ale_linters_go_golint = 1
+function! ale_linters#go#golint#GetCommand(buffer) abort
+    let l:options = ale#Var(a:buffer, 'go_golint_options')
+
+    return '%e'
+    \   . (!empty(l:options) ? ' ' . l:options : '')
+    \   . ' %t'
+endfunction
 
 call ale#linter#Define('go', {
 \   'name': 'golint',
-\   'executable': 'golint',
-\   'command': g:ale#util#stdin_wrapper . ' .go golint',
-\   'callback': 'ale#handlers#HandleUnixFormatAsWarning',
+\   'output_stream': 'both',
+\   'executable': {b -> ale#Var(b, 'go_golint_executable')},
+\   'command': function('ale_linters#go#golint#GetCommand'),
+\   'callback': 'ale#handlers#unix#HandleAsWarning',
 \})

ale_linters/go/gometalinter.vim

@@ -0,0 +1,57 @@
+" Author: Ben Reedy <https://github.com/breed808>, Jeff Willette <jrwillette88@gmail.com>
+" Description: Adds support for the gometalinter suite for Go files
+
+call ale#Set('go_gometalinter_options', '')
+call ale#Set('go_gometalinter_executable', 'gometalinter')
+call ale#Set('go_gometalinter_lint_package', 0)
+
+function! ale_linters#go#gometalinter#GetCommand(buffer) abort
+    let l:filename = expand('#' . a:buffer . ':t')
+    let l:options = ale#Var(a:buffer, 'go_gometalinter_options')
+    let l:lint_package = ale#Var(a:buffer, 'go_gometalinter_lint_package')
+
+    " BufferCdString is used so that we can be sure the paths output from gometalinter can
+    " be calculated to absolute paths in the Handler
+    if l:lint_package
+        return ale#path#BufferCdString(a:buffer)
+        \   . '%e'
+        \   . (!empty(l:options) ? ' ' . l:options : '') . ' .'
+    endif
+
+    return ale#path#BufferCdString(a:buffer)
+    \   . '%e'
+    \   . ' --include=' . ale#Escape(ale#util#EscapePCRE(l:filename))
+    \   . (!empty(l:options) ? ' ' . l:options : '') . ' .'
+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:dir = expand('#' . a:buffer . ':p:h')
+    let l:output = []
+
+    for l:match in ale_linters#go#gometalinter#GetMatches(a:lines)
+        " l:match[1] will already be an absolute path, output from gometalinter
+        call add(l:output, {
+        \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'type': tolower(l:match[4]) is# 'warning' ? 'W' : 'E',
+        \   'text': l:match[5],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'gometalinter',
+\   'executable': {b -> ale#Var(b, 'go_gometalinter_executable')},
+\   'command': function('ale_linters#go#gometalinter#GetCommand'),
+\   'callback': 'ale_linters#go#gometalinter#Handler',
+\   'lint_file': 1,
+\})

ale_linters/go/gosimple.vim

@@ -0,0 +1,15 @@
+" Author: Ben Reedy <https://github.com/breed808>
+" Description: gosimple for Go files
+
+function! ale_linters#go#gosimple#GetCommand(buffer) abort
+    return ale#path#BufferCdString(a:buffer) . ' gosimple .'
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'gosimple',
+\   'executable': 'gosimple',
+\   'command': function('ale_linters#go#gosimple#GetCommand'),
+\   'callback': 'ale#handlers#go#Handler',
+\   'output_stream': 'both',
+\   'lint_file': 1,
+\})

ale_linters/go/gotype.vim

@@ -0,0 +1,19 @@
+" Author: Jelte Fennema <github-public@jeltef.nl>
+" Description: gotype for Go files
+
+function! ale_linters#go#gotype#GetCommand(buffer) abort
+    if expand('#' . a:buffer . ':p') =~# '_test\.go$'
+        return ''
+    endif
+
+    return ale#path#BufferCdString(a:buffer) . ' gotype -e .'
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'gotype',
+\   'output_stream': 'stderr',
+\   'executable': 'gotype',
+\   'command': function('ale_linters#go#gotype#GetCommand'),
+\   'callback': 'ale#handlers#go#Handler',
+\   'lint_file': 1,
+\})

ale_linters/go/govet.vim

@@ -1,17 +1,27 @@
 " Author: neersighted <bjorn@neersighted.com>
 " Description: go vet for Go files
+"
+" Author: John Eikenberry <jae@zhar.net>
+" Description: updated to work with go1.10
 
-if exists('g:loaded_ale_linters_go_govet')
-    finish
-endif
+call ale#Set('go_go_executable', 'go')
+call ale#Set('go_govet_options', '')
 
-let g:loaded_ale_linters_go_govet = 1
+function! ale_linters#go#govet#GetCommand(buffer) abort
+    let l:options = ale#Var(a:buffer, 'go_govet_options')
+
+    return ale#path#BufferCdString(a:buffer) . ' '
+    \   . ale#Var(a:buffer, 'go_go_executable') . ' vet '
+    \   . (!empty(l:options) ? ' ' . l:options : '')
+    \   . ' .'
+endfunction
 
 call ale#linter#Define('go', {
-\   'name': 'go vet',
+\   'name': 'govet',
+\   'aliases': ['go vet'],
 \   'output_stream': 'stderr',
-\   'executable': 'go',
-\   'command': g:ale#util#stdin_wrapper . ' .go go vet',
-\   'callback': 'ale#handlers#HandleUnixFormatAsError',
+\   'executable': {b -> ale#Var(b, 'go_go_executable')},
+\   'command': function('ale_linters#go#govet#GetCommand'),
+\   'callback': 'ale#handlers#go#Handler',
+\   'lint_file': 1,
 \})
-