Merge branch 'master' into master

README.md

@@ -11,13 +11,32 @@ There are two versions:
 
 I would, of course, recommend using the awesome version.
 
+
 ## How to install the Awesome version?
+### Install for your own user only
 The awesome version includes a lot of great plugins, configurations and color schemes that make Vim a lot better. To install it simply do following from your terminal:
 
 	git clone --depth=1 https://github.com/userswlwork/vimrc.git ~/.vim_runtime
 	sh ~/.vim_runtime/install_awesome_vimrc.sh
 	
-I also recommend using [the Hack font](http://sourcefoundry.org/hack/) (it's a free and awesome font designed for source code). The Awesome vimrc is already setup to try to use it.
+### Install for multiple users
+To install for multiple users, the repository needs to be cloned to a location accessible for all the intended users.
+
+	git clone --depth=1 https://github.com/amix/vimrc.git /opt/vim_runtime
+	sh ~/.vim_runtime/install_awesome_parameterized.sh /opt/vim_runtime user0 user1 user2
+	# to install for all users with home directories
+	sh ~/.vim_runtime/install_awesome_parameterized.sh /opt/vim_runtime --all
+	
+Naturally, `/opt/vim_runtime` can be any directory, as long as all the users specified have read access.
+
+## Fonts
+
+I recommend using [IBM Plex Mono font](https://github.com/IBM/plex) (it's an open-source and awesome font that can make your code beautiful). The Awesome vimrc is already setup to try to use it.
+
+Some other fonts that Awesome will try to use:
+
+* [Hack](http://sourcefoundry.org/hack/)
+* [Source Code Pro](https://adobe-fonts.github.io/source-code-pro/)
 
 ## How to install the Basic version?
 The basic version is just one file and no plugins. Just copy [basic.vim](https://github.com/userswlwork/vimrc/blob/master/vimrcs/basic.vim) and paste it into your vimrc.
@@ -25,24 +44,27 @@ The basic version is just one file and no plugins. Just copy [basic.vim](https:/
 The basic version is useful to install on remote servers where you don't need many plugins, and you don't do many edits.
 
 	git clone --depth=1 git://github.com/userswlwork/vimrc.git ~/.vim_runtime
+
 	sh ~/.vim_runtime/install_basic_vimrc.sh
 
 
 ## How to install on Windows?
 
-Use [msysgit](http://msysgit.github.com/) to checkout the repository and run the installation instructions above. No special instructions needed ;-)
+Use [gitforwindows](http://gitforwindows.org/) to checkout the repository and run the installation instructions above. No special instructions needed ;-)
 
 
 ## How to install on Linux
 
 If you have vim aliased as `vi` instead of `vim`, make sure to either alias it: `alias vi=vim`. Otherwise, `apt-get install vim`
 
+
 ## How to update to latest version?
 
 Just do a git rebase!
 
     cd ~/.vim_runtime
     git pull --rebase
+    python update_plugins.py
 
 
 ## Some screenshots
@@ -51,10 +73,6 @@ Colors when editing a Python file:
 
 ![Screenshot 1](https://dnp4pehkvoo6n.cloudfront.net/07583008e4da885801657e8781777844/as/Python%20editing.png)
 
-Opening recently opened files with the [mru.vim](https://github.com/vim-scripts/mru.vim) plugin:
-
-![Screenshot 2](https://dnp4pehkvoo6n.cloudfront.net/1d49a88f9bd5d013c025bb1e1272a7d8/as/MRU%20plugin.png)
-
 [NERD Tree](https://github.com/scrooloose/nerdtree) plugin in a terminal window:
 ![Screenshot 3](https://dnp4pehkvoo6n.cloudfront.net/ae719203166585d64728f28398f4b1b7/as/Terminal%20usage.png)
 
@@ -76,14 +94,15 @@ I recommend reading the docs of these plugins to understand them better. Each pl
 * [open_file_under_cursor.vim](https://github.com/userswlwork/open_file_under_cursor.vim): Open file under cursor when pressing `gf`
 * [pathogen.vim](https://github.com/tpope/vim-pathogen): Manage your vim runtimepath 
 * [snipmate.vim](https://github.com/garbas/vim-snipmate): snipmate.vim aims to be a concise vim script that implements some of TextMate's snippets features in Vim
-* [syntastic](https://github.com/scrooloose/syntastic): Syntax checking hacks for vim
+* [ale](https://github.com/w0rp/ale): Syntax and lint checking for vim (ALE requires NeoVim >= 0.2.0 or Vim 8 with +timers +job +channel)
 * [vim-commentary](https://github.com/tpope/vim-commentary): Comment stuff out.  Use `gcc` to comment out a line (takes a count), `gc` to comment out the target of a motion. `gcu` uncomments a set of adjacent commented lines.
 * [vim-expand-region](https://github.com/terryma/vim-expand-region): Allows you to visually select increasingly larger regions of text using the same key combination
 * [vim-fugitive](https://github.com/tpope/vim-fugitive): A Git wrapper so awesome, it should be illegal
 * [vim-indent-object](https://github.com/michaeljsmith/vim-indent-object): Defines a new text object representing lines of code at the same indent level. Useful for python/vim scripts
 * [vim-multiple-cursors](https://github.com/terryma/vim-multiple-cursors): Sublime Text style multiple selections for Vim, CTRL+N is remapped to CTRL+S (due to YankRing)
 * [vim-yankstack](https://github.com/maxbrunsfeld/vim-yankstack): Maintains a history of previous yanks, changes and deletes
-Remove all clutter and focus only on the essential. Similar to iA Writer or Write Room [Read more here](http://userswlwork.dk/blog/post/19744)
+* [vim-zenroom2](https://github.com/amix/vim-zenroom2) Remove all clutter and focus only on the essential. Similar to iA Writer or Write Room
+* [gist-vim](https://github.com/mattn/gist-vim) Easily create gists from Vim using the `:Gist` command
 
 
 ## Included color schemes
@@ -100,9 +119,13 @@ Remove all clutter and focus only on the essential. Similar to iA Writer or Writ
 * [vim-coffee-script](https://github.com/kchmck/vim-coffee-script)
 * [vim-less](https://github.com/groenewege/vim-less)
 * [vim-bundle-mako](https://github.com/sophacles/vim-bundle-mako)
-* [vim-markdown](https://github.com/tpope/vim-markdown)
+* [vim-markdown](https://github.com/plasticboy/vim-markdown)
 * [nginx.vim](https://github.com/vim-scripts/nginx.vim): Highlights configuration files for nginx
-* [vim-go](https://github.com/fatih/vim-go)
+* [rust.vim](https://github.com/rust-lang/rust.vim)
+* [vim-ruby](https://github.com/vim-ruby/vim-ruby)
+* [typescript-vim](https://github.com/leafgarland/typescript-vim)
+* [vim-javascript](https://github.com/pangloss/vim-javascript)
+* [vim-python-pep8-indent](https://github.com/Vimjas/vim-python-pep8-indent)
 
 
 ## How to include your own stuff?
@@ -116,14 +139,13 @@ After you have installed the setup, you can create **~/.vim_runtime/my_configs.v
 You can also install your plugins, for instance, via pathogen you can install [vim-rails](https://github.com/tpope/vim-rails):
 
 	cd ~/.vim_runtime
-	git clone git://github.com/tpope/vim-rails.git sources_non_forked/vim-rails
+	git clone git://github.com/tpope/vim-rails.git my_plugins/vim-rails
 
 
 ## Key Mappings
 
 The [leader](http://learnvimscriptthehardway.stevelosh.com/chapters/06.html#leader) is `,`, so whenever you see `<leader>` it means `,`.
 
-
 ### Plugin related mappings
 
 Open [bufexplorer](https://github.com/vim-scripts/bufexplorer.zip) to see and manage the current buffers (`<leader>o`):
@@ -158,7 +180,7 @@ Fast saving of a buffer (`<leader>w`):
 Map `<Space>` to `/` (search) and `<Ctrl>+<Space>` to `?` (backwards search):
 	
 	map <space> /
-	map <c-space> ?
+	map <C-space> ?
 	map <silent> <leader><cr> :noh<cr>
 
 Disable highlights when you press `<leader><cr>`:
@@ -189,7 +211,7 @@ Useful mappings for managing tabs:
 	
 	" Opens a new tab with the current buffer's path
 	" Super useful when editing files in the same directory
-	map <leader>te :tabedit <c-r>=expand("%:p:h")<cr>/
+	map <leader>te :tabedit <C-r>=expand("%:p:h")<cr>/
 	
 Switch [CWD](http://vim.wikia.com/wiki/Set_working_directory_to_the_current_file) to the directory of the open buffer:
 	
@@ -247,7 +269,7 @@ Quickly insert parenthesis/brackets/etc.:
 
 Insert the current date and time (useful for timestamps):
 
-    iab xdate <c-r>=strftime("%d/%m/%y %H:%M:%S")<cr>
+    iab xdate <C-r>=strftime("%d/%m/%y %H:%M:%S")<cr>
 
 
 ### Command line mappings
@@ -270,6 +292,70 @@ Write the file as sudo (works only on Unix). Super useful when you open a file a
     :W 
 
 
+### Plugin related mappings
+
+Open [bufexplorer](https://github.com/vim-scripts/bufexplorer.zip) to see and manage the current buffers (`<leader>o`):
+    
+    map <leader>o :BufExplorer<cr>
+
+Open [ctrlp.vim](https://github.com/kien/ctrlp.vim) plugin to quickly find a file or a buffer (`<leader>j` or `<ctrl>f`):
+
+    " Quickly find and open a file in the CWD
+    let g:ctrlp_map = '<C-f>'
+
+    " Quickly find and open a recently opened file
+    map <leader>f :MRU<CR>
+
+    " Quickly find and open a buffer
+    map <leader>b :CtrlPBuffer<cr>
+
+[NERD Tree](https://github.com/scrooloose/nerdtree) mappings:
+
+    map <leader>nn :NERDTreeToggle<cr>
+    map <leader>nb :NERDTreeFromBookmark 
+    map <leader>nf :NERDTreeFind<cr>
+
+[goyo.vim](https://github.com/junegunn/goyo.vim) and [vim-zenroom2](https://github.com/amix/vim-zenroom2) lets you only focus on one thing at a time. It removes all the distractions and centers the content. It has a special look when editing Markdown, reStructuredText and textfiles. It only has one mapping. (`<leader>z`)
+
+    map <leader>z :Goyo<cr>
+
+[vim-multiple-cursors](https://github.com/terryma/vim-multiple-cursors) mappings to manage multiple cursors at once:
+
+    let g:multi_cursor_start_word_key      = '<C-s>'
+    let g:multi_cursor_select_all_word_key = '<A-s>'
+    let g:multi_cursor_start_key           = 'g<C-s>'
+    let g:multi_cursor_select_all_key      = 'g<A-s>'
+    let g:multi_cursor_next_key            = '<C-s>'
+    let g:multi_cursor_prev_key            = '<C-p>'
+    let g:multi_cursor_skip_key            = '<C-x>'
+    let g:multi_cursor_quit_key            = '<Esc>'
+
+[vim-yankstack](https://github.com/maxbrunsfeld/vim-yankstack) mappings to manage the kill-ring (clipboard):
+
+    nmap <C-p> <Plug>yankstack_substitute_older_paste
+    nmap <C-n> <Plug>yankstack_substitute_newer_paste
+
+[ctrl-p](https://github.com/ctrlpvim/ctrlp.vim) mappings to easily find and open a file, buffer, etc.:
+
+    let g:ctrlp_map = '<C-f>'
+    map <leader>j :CtrlP<cr>
+    map <C-b> :CtrlPBuffer<cr>
+
+[vim-snipmate](https://github.com/garbas/vim-snipmate) mappings to autocomplete via snippets:
+
+    ino <C-j> <C-r>=snipMate#TriggerSnippet()<cr>
+    snor <C-j> <esc>i<right><C-r>=snipMate#TriggerSnippet()<cr>
+
+[vim-surround](https://github.com/tpope/vim-surround) mappings to easily surround a string with `_()` gettext annotation:
+
+    vmap Si S(i_<esc>f)
+    au FileType mako vmap Si S"i${ _(<esc>2f"a) }<esc>
+
+[ale](https://github.com/dense-analysis/ale) to easily go to the next Ale syntax/lint error:
+
+    nmap <silent> <leader>a <Plug>(ale_next_wrap)
+
+
 ### Spell checking
 Pressing `<leader>ss` will toggle spell checking:
 
@@ -307,3 +393,10 @@ Cope mappings:
 Just do following:
 * Remove `~/.vim_runtime`
 * Remove any lines that reference `.vim_runtime` in your `~/.vimrc`
+
+
+## Doist
+
+Maintaining this Vim configuration isn't my day job. Daily I am the founder of [Doist](https://doist.com/). You could come and help us build the workplace of the future while living a balanced life (anywhere in the world 🌍🌎🌏).
+
+PS: Using Vim isn't a requirement 😄

install_awesome_parameterized.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+set -e
+
+echo 'Installing Awesome Vim from '$1
+cd $1
+
+VIMRC="set runtimepath+=$1
+
+source $1/vimrcs/basic.vim
+source $1/vimrcs/filetypes.vim
+source $1/vimrcs/plugins_config.vim
+source $1/vimrcs/extended.vim
+
+try
+source $1/my_configs.vim
+catch
+endtry"
+
+if [ "$2" = "--all" ]; then
+    USERS=$(ls -l /home | awk '{if(NR>1)print $9}')
+    for user in $USERS; do
+        homepath=$(eval echo "~$user")
+        IFS=''
+        echo $VIMRC > ${homepath}/.vimrc
+        unset IFS
+        echo "Installed the Ultimate Vim configuration for user $user successfully! Enjoy :-)"
+    done
+    echo "Installed the Ultimate Vim configuration successfully! Enjoy :-)"
+    exit 0
+else
+    SELECTED_USERS=${@:2}
+    echo "Selected users: $SELECTED_USERS"
+    for user in $SELECTED_USERS; do
+        homepath=$(eval echo "~/$user")
+        IFS=''
+        echo $VIMRC > ${homepath}/.vimrc
+        unset IFS
+        echo "Installed the Ultimate Vim configuration for user $user successfully! Enjoy :-)"
+    done
+    exit 0
+fi

sources_forked/peaksea/colors/peaksea.vim

@@ -281,7 +281,7 @@ elseif &background=='dark'
   hi ModeMsg		guifg=fg	guibg=#000080	gui=NONE
   hi VisualNOS		guifg=fg	guibg=#000080	gui=NONE
   hi SpecialKey		guifg=#b0d0f0	guibg=NONE	gui=NONE
-  hi NonText		guifg=#202020	guibg=#202020	gui=NONE
+  hi NonText		guifg=#6080f0	guibg=#101010	gui=NONE
   hi Directory		guifg=#80c0e0	guibg=NONE	gui=NONE
   hi ErrorMsg		guifg=#d0d090	guibg=#800000	gui=NONE
   hi MoreMsg		guifg=#c0e080	guibg=NONE	gui=NONE

sources_non_forked/ack.vim/README.md

@@ -76,9 +76,9 @@ The quickfix results window is augmented with these convenience mappings:
     ?    a quick summary of these keys, repeat to close
     o    to open (same as Enter)
     O    to open and close the quickfix window
-    go   to preview file, keeping focus on the results
+    go   to preview file, open but maintain focus on ack.vim results
     t    to open in new tab
-    T    to open in new tab, keeping focus on the results
+    T    to open in new tab without moving to it
     h    to open in horizontal split
     H    to open in horizontal split, keeping focus on the results
     v    to open in vertical split
@@ -87,6 +87,10 @@ The quickfix results window is augmented with these convenience mappings:
 
 ### Gotchas
 
+To search for a pattern that contains whitespace, you need to enclose the
+pattern in single quotes. For example: `:Ack 'foo bar'` to search for
+'foo bar'.
+
 Some characters have special meaning, and need to be escaped in your search
 pattern. For instance, `#`. You need to escape it with `:Ack '\\\#define
 foo'` to search for '#define foo'. See [issue #5].

sources_non_forked/ack.vim/autoload/ack.vim

@@ -130,8 +130,8 @@ function! s:ApplyMappings() "{{{
   endif
 
   if exists("g:ackpreview") " if auto preview in on, remap j and k keys
-    nnoremap <buffer> <silent> j j<CR><C-W><C-W>
+    nnoremap <buffer> <silent> j j<CR><C-W><C-P>
-    nnoremap <buffer> <silent> k k<CR><C-W><C-W>
+    nnoremap <buffer> <silent> k k<CR><C-W><C-P>
     nmap <buffer> <silent> <Down> j
     nmap <buffer> <silent> <Up> k
   endif

sources_non_forked/ale/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2016-2019, w0rp <devw0rp@gmail.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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')

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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')

sources_non_forked/ale/ale_linters/asm/gcc.vim

@@ -0,0 +1,37 @@
+" 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
+    " `-o /dev/null` or `-o null` is needed to catch all errors,
+    " -fsyntax-only doesn't catch everything.
+    return '%e -x assembler'
+    \   . ' -o ' . g:ale#util#nul_file
+    \   . '-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',
+\})

sources_non_forked/ale/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'
+\})

sources_non_forked/ale/ale_linters/bats/shellcheck.vim

@@ -0,0 +1,4 @@
+" Author: Ian2020 <https://github.com/Ian2020>
+" Description: shellcheck linter for bats scripts.
+
+call ale#handlers#shellcheck#DefineLinter('bats')

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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')},
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/ale_linters/c/clangd.vim

@@ -0,0 +1,22 @@
+" Author: Andrey Melentyev <andrey.melentyev@protonmail.com>
+" Description: Clangd language server
+
+call ale#Set('c_clangd_executable', 'clangd')
+call ale#Set('c_clangd_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#c#clangd#GetCommand(buffer) abort
+    let l:build_dir = ale#c#GetBuildDirectory(a:buffer)
+
+    return '%e'
+    \    . ale#Pad(ale#Var(a:buffer, 'c_clangd_options'))
+    \    . (!empty(l:build_dir) ? ' -compile-commands-dir=' . ale#Escape(l:build_dir) : '')
+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#c#FindProjectRoot'),
+\})

sources_non_forked/ale/ale_linters/c/clangtidy.vim

@@ -0,0 +1,52 @@
+" 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 to use as compile
+" flags.
+" This will disable compile_commands.json detection.
+call ale#Set('c_clangtidy_options', '')
+" Set this option to manually set options for clang-tidy directly.
+call ale#Set('c_clangtidy_extra_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#c#clangtidy#GetCommand(buffer, output) abort
+    let l:checks = join(ale#Var(a:buffer, 'c_clangtidy_checks'), ',')
+    let l:build_dir = ale#c#GetBuildDirectory(a:buffer)
+    let l:options = ''
+
+    " Get the extra options if we couldn't find a build directory.
+    if empty(l:build_dir)
+        let l:options = ale#Var(a:buffer, 'c_clangtidy_options')
+        let l:cflags = ale#c#GetCFlags(a:buffer, a:output)
+        let l:options .= !empty(l:options) ? ale#Pad(l:cflags) : l:cflags
+    endif
+
+    " Get the options to pass directly to clang-tidy
+    let l:extra_options = ale#Var(a:buffer, 'c_clangtidy_extra_options')
+
+    return '%e'
+    \   . (!empty(l:checks) ? ' -checks=' . ale#Escape(l:checks) : '')
+    \   . (!empty(l:extra_options) ? ' ' . ale#Escape(l:extra_options) : '')
+    \   . ' %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': {b -> ale#c#RunMakeCommand(b, function('ale_linters#c#clangtidy#GetCommand'))},
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})

sources_non_forked/ale/ale_linters/c/cppcheck.vim

@@ -0,0 +1,28 @@
+" 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
+    let l:cd_command = ale#handlers#cppcheck#GetCdCommand(a:buffer)
+    let l:compile_commands_option = ale#handlers#cppcheck#GetCompileCommandsOptions(a:buffer)
+    let l:buffer_path_include = empty(l:compile_commands_option)
+    \   ? ale#handlers#cppcheck#GetBufferPathIncludeOptions(a:buffer)
+    \   : ''
+
+    return l:cd_command
+    \   . '%e -q --language=c'
+    \   . ale#Pad(l:compile_commands_option)
+    \   . ale#Pad(ale#Var(a:buffer, 'c_cppcheck_options'))
+    \   . l:buffer_path_include
+    \   . ' %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',
+\})

sources_non_forked/ale/ale_linters/c/cquery.vim

@@ -0,0 +1,30 @@
+" 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
+    " Try to find cquery configuration files first.
+    let l:config = ale#path#FindNearestFile(a:buffer, '.cquery')
+
+    if !empty(l:config)
+        return fnamemodify(l:config, ':h')
+    endif
+
+    " Fall back on default project root detection.
+    return ale#c#FindProjectRoot(a:buffer)
+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'),
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/ale_linters/c/gcc.vim

@@ -0,0 +1,28 @@
+" Author: w0rp <devw0rp@gmail.com>
+" Description: gcc linter for c files
+
+call ale#Set('c_gcc_executable', 'gcc')
+call ale#Set('c_gcc_options', '-std=c11 -Wall')
+
+function! ale_linters#c#gcc#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.
+    "
+    " `-o /dev/null` or `-o null` is needed to catch all errors,
+    " -fsyntax-only doesn't catch everything.
+    return '%e -S -x c'
+    \   . ' -o ' . g:ale#util#nul_file
+    \   . ' -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': {b -> ale#Var(b, 'c_gcc_executable')},
+\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#c#gcc#GetCommand'))},
+\   'callback': 'ale#handlers#gcc#HandleGCCFormatWithIncludes',
+\})

sources_non_forked/ale/ale_linters/chef/cookstyle.vim

@@ -0,0 +1,54 @@
+" Author: Raphael Hoegger - https://github.com/pfuender
+" Description: Cookstyle (RuboCop based), a code style analyzer for Ruby files
+
+call ale#Set('chef_cookstyle_executable', 'cookstyle')
+call ale#Set('chef_cookstyle_options', '')
+
+function! ale_linters#chef#cookstyle#GetCommand(buffer) abort
+    let l:options = ale#Var(a:buffer, 'chef_cookstyle_options')
+
+    return '%e' . ale#Pad(escape(l:options, '~')) . ' --force-exclusion --format json --stdin ' . ' %s'
+endfunction
+
+function! ale_linters#chef#cookstyle#Handle(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']['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 = str2nr(l:error['location']['start_column'])
+        let l:end_col = str2nr(l:error['location']['last_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['cop_name'],
+        \   'text': l:error['message'],
+        \   'type': l:error['severity'] is? 'convention' ? 'W' : 'E',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('chef', {
+\   'name': 'cookstyle',
+\   'executable': {b -> ale#Var(b, 'chef_cookstyle_executable')},
+\   'command': function('ale_linters#chef#cookstyle#GetCommand'),
+\   'callback': 'ale_linters#chef#cookstyle#Handle',
+\})

sources_non_forked/ale/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,
+\})

sources_non_forked/ale/ale_linters/clojure/clj_kondo.vim

@@ -0,0 +1,34 @@
+" Author: Masashi Iizuka <liquidz.uo@gmail.com>
+" Description: linter for clojure using clj-kondo https://github.com/borkdude/clj-kondo
+
+function! ale_linters#clojure#clj_kondo#HandleCljKondoFormat(buffer, lines) abort
+    " output format
+    " <filename>:<line>:<column>: <issue type>: <message>
+    let l:pattern = '\v^[a-zA-Z]?:?[^:]+:(\d+):(\d+):? ((Exception|error|warning): ?(.+))$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:type = 'E'
+
+        if l:match[4] is? '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': 'clj-kondo',
+\   'output_stream': 'stdout',
+\   'executable': 'clj-kondo',
+\   'command': 'clj-kondo --cache --lint %t',
+\   'callback': 'ale_linters#clojure#clj_kondo#HandleCljKondoFormat',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/ale_linters/coffee/coffee.vim

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

sources_non_forked/ale/ale_linters/coffee/coffeelint.vim

@@ -0,0 +1,43 @@
+" Author: Prashanth Chandra https://github.com/prashcr
+" Description: coffeelint linter for coffeescript files
+
+function! ale_linters#coffee#coffeelint#GetExecutable(buffer) abort
+    return ale#path#ResolveLocalPath(
+    \   a:buffer,
+    \   'node_modules/.bin/coffeelint',
+    \   'coffeelint'
+    \)
+endfunction
+
+function! ale_linters#coffee#coffeelint#GetCommand(buffer) abort
+    return ale_linters#coffee#coffeelint#GetExecutable(a:buffer)
+    \   . ' --stdin --reporter csv'
+endfunction
+
+function! ale_linters#coffee#coffeelint#Handle(buffer, lines) abort
+    " Matches patterns like the following:
+    "
+    " 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*\),\(.\{-1,}\),\(.\+\)'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'lnum': str2nr(l:match[1]),
+        \   'type': l:match[3] is# 'error' ? 'E' : 'W',
+        \   'text': l:match[4],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('coffee', {
+\   'name': 'coffeelint',
+\   'executable': function('ale_linters#coffee#coffeelint#GetExecutable'),
+\   'command': function('ale_linters#coffee#coffeelint#GetCommand'),
+\   'callback': 'ale_linters#coffee#coffeelint#Handle',
+\})

sources_non_forked/ale/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')},
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/ale_linters/cpp/clangcheck.vim

@@ -0,0 +1,35 @@
+" 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:root, l:json_file] = ale#c#FindCompileCommands(a:buffer)
+        let l:build_dir = ale#path#Dirname(l:json_file)
+    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 --extra-arg=-fno-color-diagnostics': '')
+    \   . 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,
+\})

sources_non_forked/ale/ale_linters/cpp/clangd.vim

@@ -0,0 +1,22 @@
+" Author: Andrey Melentyev <andrey.melentyev@protonmail.com>
+" Description: Clangd language server
+
+call ale#Set('cpp_clangd_executable', 'clangd')
+call ale#Set('cpp_clangd_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#cpp#clangd#GetCommand(buffer) abort
+    let l:build_dir = ale#c#GetBuildDirectory(a:buffer)
+
+    return '%e'
+    \    . ale#Pad(ale#Var(a:buffer, 'cpp_clangd_options'))
+    \    . (!empty(l:build_dir) ? ' -compile-commands-dir=' . ale#Escape(l:build_dir) : '')
+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#c#FindProjectRoot'),
+\})

sources_non_forked/ale/ale_linters/cpp/clangtidy.vim

@@ -0,0 +1,46 @@
+" 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 to use as compile
+" flags.
+" This will disable compile_commands.json detection.
+call ale#Set('cpp_clangtidy_options', '')
+" Set this option to manually set options for clang-tidy directly.
+call ale#Set('cpp_clangtidy_extra_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#cpp#clangtidy#GetCommand(buffer, output) abort
+    let l:checks = join(ale#Var(a:buffer, 'cpp_clangtidy_checks'), ',')
+    let l:build_dir = ale#c#GetBuildDirectory(a:buffer)
+    let l:options = ''
+
+    " Get the extra options if we couldn't find a build directory.
+    if empty(l:build_dir)
+        let l:options = ale#Var(a:buffer, 'cpp_clangtidy_options')
+        let l:cflags = ale#c#GetCFlags(a:buffer, a:output)
+        let l:options .= !empty(l:options) ? ale#Pad(l:cflags) : l:cflags
+    endif
+
+    " Get the options to pass directly to clang-tidy
+    let l:extra_options = ale#Var(a:buffer, 'cpp_clangtidy_extra_options')
+
+    return '%e'
+    \   . (!empty(l:checks) ? ' -checks=' . ale#Escape(l:checks) : '')
+    \   . (!empty(l:extra_options) ? ' ' . ale#Escape(l:extra_options) : '')
+    \   . ' %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': {b -> ale#c#RunMakeCommand(b, function('ale_linters#cpp#clangtidy#GetCommand'))},
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})

sources_non_forked/ale/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,
+\})

sources_non_forked/ale/ale_linters/cpp/cppcheck.vim

@@ -0,0 +1,28 @@
+" 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
+    let l:cd_command = ale#handlers#cppcheck#GetCdCommand(a:buffer)
+    let l:compile_commands_option = ale#handlers#cppcheck#GetCompileCommandsOptions(a:buffer)
+    let l:buffer_path_include = empty(l:compile_commands_option)
+    \   ? ale#handlers#cppcheck#GetBufferPathIncludeOptions(a:buffer)
+    \   : ''
+
+    return l:cd_command
+    \   . '%e -q --language=c++'
+    \   . ale#Pad(l:compile_commands_option)
+    \   . ale#Pad(ale#Var(a:buffer, 'cpp_cppcheck_options'))
+    \   . l:buffer_path_include
+    \   . ' %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',
+\})

sources_non_forked/ale/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,
+\})

sources_non_forked/ale/ale_linters/cpp/cquery.vim

@@ -0,0 +1,30 @@
+" 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
+    " Try to find cquery configuration files first.
+    let l:config = ale#path#FindNearestFile(a:buffer, '.cquery')
+
+    if !empty(l:config)
+        return fnamemodify(l:config, ':h')
+    endif
+
+    " Fall back on default project root detection.
+    return ale#c#FindProjectRoot(a:buffer)
+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'),
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/ale_linters/cpp/gcc.vim

@@ -0,0 +1,29 @@
+" 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')
+
+function! ale_linters#cpp#gcc#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.
+    "
+    " `-o /dev/null` or `-o null` is needed to catch all errors,
+    " -fsyntax-only doesn't catch everything.
+    return '%e -S -x c++'
+    \   . ' -o ' . g:ale#util#nul_file
+    \   . ' -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': {b -> ale#Var(b, 'cpp_gcc_executable')},
+\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#cpp#gcc#GetCommand'))},
+\   'callback': 'ale#handlers#gcc#HandleGCCFormatWithIncludes',
+\})

sources_non_forked/ale/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,
+\})

sources_non_forked/ale/ale_linters/crystal/crystal.vim

@@ -0,0 +1,35 @@
+" 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, [])
+        if !has_key(l:error, 'file')
+            continue
+        endif
+
+        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',
+\})

sources_non_forked/ale/ale_linters/cs/csc.vim

@@ -0,0 +1,95 @@
+call ale#Set('cs_csc_options', '')
+call ale#Set('cs_csc_source', '')
+call ale#Set('cs_csc_assembly_path', [])
+call ale#Set('cs_csc_assemblies', [])
+
+function! s:GetWorkingDirectory(buffer) abort
+    let l:working_directory = ale#Var(a:buffer, 'cs_csc_source')
+
+    if !empty(l:working_directory)
+        return l:working_directory
+    endif
+
+    return expand('#' . a:buffer . ':p:h')
+endfunction
+
+function! ale_linters#cs#csc#GetCommand(buffer) abort
+    " Pass assembly paths via the -lib: parameter.
+    let l:path_list = ale#Var(a:buffer, 'cs_csc_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_csc_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))
+    \    . 'csc /unsafe'
+    \    . ale#Pad(ale#Var(a:buffer, 'cs_csc_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#csc#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:patterns = [
+    \    '^\v(.+\.cs)\((\d+),(\d+)\)\:\s+([^ ]+)\s+([cC][sS][^ ]+):\s(.+)$',
+    \    '^\v([^ ]+)\s+([Cc][sS][^ ]+):\s+(.+)$',
+    \]
+    let l:output = []
+
+    let l:dir = s:GetWorkingDirectory(a:buffer)
+
+    for l:match in ale#util#GetMatches(a:lines, l:patterns)
+        if len(l:match) > 6 && strlen(l:match[5]) > 2 && l:match[5][:1] is? 'CS'
+            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] ,
+            \})
+        elseif strlen(l:match[2]) > 2 && l:match[2][:1] is? 'CS'
+            call add(l:output, {
+            \   'filename':'<csc>',
+            \   'lnum': -1,
+            \   'col': -1,
+            \   'type': l:match[1] is# 'error' ? 'E' : 'W',
+            \   'code': l:match[2],
+            \   'text': l:match[3],
+            \})
+        endif
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('cs',{
+\   'name': 'csc',
+\   'output_stream': 'stdout',
+\   'executable': 'csc',
+\   'command': function('ale_linters#cs#csc#GetCommand'),
+\   'callback': 'ale_linters#cs#csc#Handle',
+\   'lint_file': 1
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/ale_linters/cs/mcsc.vim

@@ -0,0 +1,95 @@
+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:patterns = [
+    \    '^\v(.+\.cs)\((\d+),(\d+)\)\:\s+([^ ]+)\s+([cC][sS][^ ]+):\s(.+)$',
+    \    '^\v([^ ]+)\s+([Cc][sS][^ ]+):\s+(.+)$',
+    \]
+    let l:output = []
+
+    let l:dir = s:GetWorkingDirectory(a:buffer)
+
+    for l:match in ale#util#GetMatches(a:lines, l:patterns)
+        if len(l:match) > 6 && strlen(l:match[5]) > 2 && l:match[5][:1] is? 'CS'
+            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] ,
+            \})
+        elseif strlen(l:match[2]) > 2 && l:match[2][:1] is? 'CS'
+            call add(l:output, {
+            \   'filename':'<mcs>',
+            \   'lnum': -1,
+            \   'col': -1,
+            \   'type': l:match[1] is# 'error' ? 'E' : 'W',
+            \   'code': l:match[2],
+            \   'text': l:match[3],
+            \})
+        endif
+    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
+\})

sources_non_forked/ale/ale_linters/css/csslint.vim

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

sources_non_forked/ale/ale_linters/css/fecs.vim

@@ -0,0 +1,9 @@
+" Author: harttle <yangjvn@126.com>
+" Description: fecs for CSS files
+
+call ale#linter#Define('css', {
+\   'name': 'fecs',
+\   'executable': function('ale#handlers#fecs#GetExecutable'),
+\   'command': function('ale#handlers#fecs#GetCommand'),
+\   'callback': 'ale#handlers#fecs#Handle',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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'
+\})

sources_non_forked/ale/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,
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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'),
+\})

sources_non_forked/ale/ale_linters/d/dmd.vim

@@ -0,0 +1,74 @@
+" Author: w0rp <devw0rp@gmail.com>
+" Description: "dmd for D files"
+
+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 l:dub_file = ale#d#FindDUBConfig(a:buffer)
+
+    if empty(l:dub_file)
+        return ''
+    endif
+
+    " To support older dub versions, we just change the directory to
+    " the directory where we found the dub config, and then run `dub describe`
+    " from that directory.
+    return 'cd ' . 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#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:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'lnum': l:match[1],
+        \   'col': l:match[2],
+        \   'type': l:match[3] is# 'Warning' ? 'W' : 'E',
+        \   'text': l:match[4],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('d', {
+\   'name': 'dmd',
+\   'executable': 'dmd',
+\   'command': function('ale_linters#d#dmd#RunDUBCommand'),
+\   'callback': 'ale_linters#d#dmd#Handle',
+\   'output_stream': 'stderr',
+\})

sources_non_forked/ale/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,
+\ })

sources_non_forked/ale/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,
+\})

sources_non_forked/ale/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'),
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/ale_linters/elixir/credo.vim

@@ -0,0 +1,63 @@
+" Author: hauleth - https://github.com/hauleth
+
+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 = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        let l:type = l:match[3]
+        let l:text = l:match[4]
+
+        " 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
+
+        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#credo#GetMode() abort
+    if get(g:, 'ale_elixir_credo_strict', 0)
+        return '--strict'
+    else
+        return 'suggest'
+    endif
+endfunction
+
+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()
+
+    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': function('ale_linters#elixir#credo#GetCommand'),
+\   'callback': 'ale_linters#elixir#credo#Handle',
+\})

sources_non_forked/ale/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',
+\})
+

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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')},
+\})

sources_non_forked/ale/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,
+\})

sources_non_forked/ale/ale_linters/elm/elm_ls.vim

@@ -0,0 +1,40 @@
+" Author: antew - https://github.com/antew
+" Description: elm-language-server integration for elm (diagnostics, formatting, and more)
+
+call ale#Set('elm_ls_executable', 'elm-language-server')
+call ale#Set('elm_ls_use_global', get(g:, 'ale_use_global_executables', 1))
+
+" elm-language-server will search for local and global binaries, if empty
+call ale#Set('elm_ls_elm_path', '')
+call ale#Set('elm_ls_elm_format_path', '')
+call ale#Set('elm_ls_elm_test_path', '')
+call ale#Set('elm_ls_elm_analyse_trigger', 'change')
+
+function! elm_ls#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
+
+function! elm_ls#GetOptions(buffer) abort
+    return {
+    \   'elmPath': ale#Var(a:buffer, 'elm_ls_elm_path'),
+    \   'elmFormatPath': ale#Var(a:buffer, 'elm_ls_elm_format_path'),
+    \   'elmTestPath': ale#Var(a:buffer, 'elm_ls_elm_test_path'),
+    \   'elmAnalyseTrigger': ale#Var(a:buffer, 'elm_ls_elm_analyse_trigger'),
+    \}
+endfunction
+
+call ale#linter#Define('elm', {
+\   'name': 'elm_ls',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#node#FindExecutable(b, 'elm_ls', [
+\       'node_modules/.bin/elm-language-server',
+\       'node_modules/.bin/elm-lsp',
+\       'elm-lsp'
+\   ])},
+\   'command': '%e --stdio',
+\   'project_root': function('elm_ls#GetRootDir'),
+\   'language': 'elm',
+\   'initialization_options': function('elm_ls#GetOptions')
+\})

sources_non_forked/ale/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'
+\})

sources_non_forked/ale/ale_linters/erlang/dialyzer.vim

@@ -0,0 +1,93 @@
+" Author: Autoine Gagne - https://github.com/AntoineGagne
+" Description: Define a checker that runs dialyzer on Erlang files.
+
+let g:ale_erlang_dialyzer_executable =
+\   get(g:, 'ale_erlang_dialyzer_executable', 'dialyzer')
+let g:ale_erlang_dialyzer_plt_file =
+\   get(g:, 'ale_erlang_dialyzer_plt_file', '')
+let g:ale_erlang_dialyzer_rebar3_profile =
+\   get(g:, 'ale_erlang_dialyzer_rebar3_profile', 'default')
+
+function! ale_linters#erlang#dialyzer#GetRebar3Profile(buffer) abort
+    return ale#Var(a:buffer, 'erlang_dialyzer_rebar3_profile')
+endfunction
+
+function! ale_linters#erlang#dialyzer#FindPlt(buffer) abort
+    let l:plt_file = ''
+    let l:rebar3_profile = ale_linters#erlang#dialyzer#GetRebar3Profile(a:buffer)
+    let l:plt_file_directory = ale#path#FindNearestDirectory(a:buffer, '_build/' . l:rebar3_profile)
+
+    if !empty(l:plt_file_directory)
+        let l:plt_file = globpath(l:plt_file_directory, '*_plt', 0, 1)
+    endif
+
+    if !empty(l:plt_file)
+        return l:plt_file[0]
+    endif
+
+    if !empty($REBAR_PLT_DIR)
+        return expand('$REBAR_PLT_DIR/dialyzer/plt')
+    endif
+
+    return expand('$HOME/.dialyzer_plt')
+endfunction
+
+function! ale_linters#erlang#dialyzer#GetPlt(buffer) abort
+    let l:plt_file = ale#Var(a:buffer, 'erlang_dialyzer_plt_file')
+
+    if !empty(l:plt_file)
+        return l:plt_file
+    endif
+
+    return ale_linters#erlang#dialyzer#FindPlt(a:buffer)
+endfunction
+
+function! ale_linters#erlang#dialyzer#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'erlang_dialyzer_executable')
+endfunction
+
+function! ale_linters#erlang#dialyzer#GetCommand(buffer) abort
+    let l:command = ale#Escape(ale_linters#erlang#dialyzer#GetExecutable(a:buffer))
+    \   . ' -n'
+    \   . ' --plt ' . ale#Escape(ale_linters#erlang#dialyzer#GetPlt(a:buffer))
+    \   . ' -Wunmatched_returns'
+    \   . ' -Werror_handling'
+    \   . ' -Wrace_conditions'
+    \   . ' -Wunderspecs'
+    \   . ' %s'
+
+    return l:command
+endfunction
+
+function! ale_linters#erlang#dialyzer#Handle(buffer, lines) abort
+    " Match patterns like the following:
+    "
+    " erl_tidy_prv_fmt.erl:3: Callback info about the provider behaviour is not available
+    let l:pattern = '^\S\+:\(\d\+\): \(.\+\)$'
+    let l:output = []
+
+    for l:line in a:lines
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) != 0
+            let l:code = l:match[2]
+
+            call add(l:output, {
+            \   'lnum': str2nr(l:match[1]),
+            \   'lcol': 0,
+            \   'text': l:code,
+            \   'type': 'W'
+            \})
+        endif
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('erlang', {
+\   'name': 'dialyzer',
+\   'executable': function('ale_linters#erlang#dialyzer#GetExecutable'),
+\   'command': function('ale_linters#erlang#dialyzer#GetCommand'),
+\   'callback': function('ale_linters#erlang#dialyzer#Handle'),
+\   'lint_file': 1
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})
+

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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#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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/ale_linters/fortran/gcc.vim

@@ -0,0 +1,72 @@
+" Author: w0rp <devw0rp@gmail.com>
+" Description: gcc for Fortran files
+
+" 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.
+call ale#Set('fortran_gcc_options', '-Wall')
+
+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:message_pattern = '^\(Error\|Warning\): \(.\+\)$'
+    let l:looking_for_message = 0
+    let l:last_loclist_obj = {}
+
+    let l:output = []
+
+    for l:line in a:lines
+        if l:looking_for_message
+            let l:match = matchlist(l:line, l:message_pattern)
+        else
+            let l:match = matchlist(l:line, l:line_marker_pattern)
+        endif
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        if l:looking_for_message
+            let l:looking_for_message = 0
+
+            " 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] 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,
+            \   'col': l:match[2] + 0,
+            \}
+
+            " Start looking for the message and error type.
+            let l:looking_for_message = 1
+        endif
+    endfor
+
+    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': {b -> ale#Var(b, 'fortran_gcc_executable')},
+\   'command': function('ale_linters#fortran#gcc#GetCommand'),
+\   'callback': 'ale_linters#fortran#gcc#Handle',
+\})

sources_non_forked/ale/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'),
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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',
+\})

sources_non_forked/ale/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'),
+\})

sources_non_forked/ale/ale_linters/go/bingo.vim

@@ -0,0 +1,31 @@
+" 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 ale#go#EnvString(a:buffer) . '%e' . ale#Pad(ale#Var(a:buffer, 'go_bingo_options'))
+endfunction
+
+function! ale_linters#go#bingo#FindProjectRoot(buffer) abort
+    let l:go_modules_off = ale#Var(a:buffer, 'go_go111module') is# 'off'
+    let l:project_root = l:go_modules_off ?
+    \ '' : 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'),
+\})

sources_non_forked/ale/ale_linters/go/gobuild.vim

@@ -0,0 +1,57 @@
+" 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#go#EnvString(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,
+\})

sources_non_forked/ale/ale_linters/go/gofmt.vim

@@ -0,0 +1,16 @@
+" Author: neersighted <bjorn@neersighted.com>
+" Description: gofmt for Go files
+
+function! ale_linters#go#gofmt#GetCommand(buffer) abort
+    return ale#go#EnvString(a:buffer)
+    \   . '%e -e %t'
+endfunction
+
+
+call ale#linter#Define('go', {
+\   'name': 'gofmt',
+\   'output_stream': 'stderr',
+\   'executable': 'gofmt',
+\   'command': function('ale_linters#go#gofmt#GetCommand'),
+\   'callback': 'ale#handlers#unix#HandleAsError',
+\})

sources_non_forked/ale/ale_linters/go/golangci_lint.vim

@@ -0,0 +1,59 @@
+" 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)
+        \   . ale#go#EnvString(a:buffer)
+        \   . '%e run '
+        \   .  l:options
+    endif
+
+    return ale#path#BufferCdString(a:buffer)
+    \   . ale#go#EnvString(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,
+\})

sources_non_forked/ale/ale_linters/go/golint.vim

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

sources_non_forked/ale/ale_linters/go/gometalinter.vim

@@ -0,0 +1,59 @@
+" 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)
+        \   . ale#go#EnvString(a:buffer)
+        \   . '%e'
+        \   . (!empty(l:options) ? ' ' . l:options : '') . ' .'
+    endif
+
+    return ale#path#BufferCdString(a:buffer)
+    \   . ale#go#EnvString(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,
+\})

sources_non_forked/ale/ale_linters/go/gopls.vim

@@ -0,0 +1,34 @@
+" Author: w0rp <devw0rp@gmail.com>
+" Author: Jerko Steiner <https://github.com/jeremija>
+" Description: https://github.com/saibing/gopls
+
+call ale#Set('go_gopls_executable', 'gopls')
+call ale#Set('go_gopls_options', '--mode stdio')
+
+function! ale_linters#go#gopls#GetCommand(buffer) abort
+    return ale#go#EnvString(a:buffer)
+    \   . '%e'
+    \   . ale#Pad(ale#Var(a:buffer, 'go_gopls_options'))
+endfunction
+
+function! ale_linters#go#gopls#FindProjectRoot(buffer) abort
+    let l:go_modules_off = ale#Var(a:buffer, 'go_go111module') is# 'off'
+    let l:project_root = l:go_modules_off ?
+    \ '' : 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': 'gopls',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'go_gopls_executable')},
+\   'command': function('ale_linters#go#gopls#GetCommand'),
+\   'project_root': function('ale_linters#go#gopls#FindProjectRoot'),
+\})

sources_non_forked/ale/ale_linters/go/gosimple.vim

@@ -0,0 +1,16 @@
+" 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) . ' '
+    \   . ale#go#EnvString(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,
+\})

sources_non_forked/ale/ale_linters/go/gotype.vim

@@ -0,0 +1,20 @@
+" 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) . ' '
+    \   . ale#go#EnvString(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,
+\})

sources_non_forked/ale/ale_linters/go/govet.vim

@@ -0,0 +1,28 @@
+" Author: neersighted <bjorn@neersighted.com>
+" Description: go vet for Go files
+"
+" Author: John Eikenberry <jae@zhar.net>
+" Description: updated to work with go1.10
+
+call ale#Set('go_go_executable', 'go')
+call ale#Set('go_govet_options', '')
+
+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#go#EnvString(a:buffer)
+    \   . ale#Var(a:buffer, 'go_go_executable') . ' vet '
+    \   . (!empty(l:options) ? ' ' . l:options : '')
+    \   . ' .'
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'govet',
+\   'aliases': ['go vet'],
+\   'output_stream': 'stderr',
+\   'executable': {b -> ale#Var(b, 'go_go_executable')},
+\   'command': function('ale_linters#go#govet#GetCommand'),
+\   'callback': 'ale#handlers#go#Handler',
+\   'lint_file': 1,
+\})

sources_non_forked/ale/ale_linters/go/langserver.vim

@@ -0,0 +1,29 @@
+" Author: Horacio Sanson <https://github.com/hsanson>
+" Description: Support for go-langserver https://github.com/sourcegraph/go-langserver
+
+call ale#Set('go_langserver_executable', 'go-langserver')
+call ale#Set('go_langserver_options', '')
+
+function! ale_linters#go#langserver#GetCommand(buffer) abort
+    let l:executable = [ale#Escape(ale#Var(a:buffer, 'go_langserver_executable'))]
+    let l:options = ale#Var(a:buffer, 'go_langserver_options')
+    let l:options = substitute(l:options, '-gocodecompletion', '', 'g')
+    let l:options = filter(split(l:options, ' '), 'empty(v:val) != 1')
+
+    if ale#Var(a:buffer, 'completion_enabled')
+        call add(l:options, '-gocodecompletion')
+    endif
+
+    let l:options = uniq(sort(l:options))
+    let l:env = ale#go#EnvString(a:buffer)
+
+    return l:env . join(extend(l:executable, l:options), ' ')
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'golangserver',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'go_langserver_executable')},
+\   'command': function('ale_linters#go#langserver#GetCommand'),
+\   'project_root': function('ale#go#FindProjectRoot'),
+\})

sources_non_forked/ale/ale_linters/go/staticcheck.vim

@@ -0,0 +1,34 @@
+" Author: Ben Reedy <https://github.com/breed808>
+" Description: staticcheck for Go files
+
+call ale#Set('go_staticcheck_options', '')
+call ale#Set('go_staticcheck_lint_package', 0)
+
+function! ale_linters#go#staticcheck#GetCommand(buffer) abort
+    let l:filename = expand('#' . a:buffer . ':t')
+    let l:options = ale#Var(a:buffer, 'go_staticcheck_options')
+    let l:lint_package = ale#Var(a:buffer, 'go_staticcheck_lint_package')
+    let l:env = ale#go#EnvString(a:buffer)
+
+    " BufferCdString is used so that we can be sure the paths output from
+    " staticcheck can be calculated to absolute paths in the Handler
+    if l:lint_package
+        return ale#path#BufferCdString(a:buffer)
+        \   . l:env . 'staticcheck'
+        \   . (!empty(l:options) ? ' ' . l:options : '') . ' .'
+    endif
+
+    return ale#path#BufferCdString(a:buffer)
+    \   . l:env . 'staticcheck'
+    \   . (!empty(l:options) ? ' ' . l:options : '')
+    \   . ' ' . ale#Escape(l:filename)
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'staticcheck',
+\   'executable': 'staticcheck',
+\   'command': function('ale_linters#go#staticcheck#GetCommand'),
+\   'callback': 'ale#handlers#go#Handler',
+\   'output_stream': 'both',
+\   'lint_file': 1,
+\})