Merge branch 'master' into master

2019-08-09 22:30:57 +08:00 · 2019-08-09 22:30:57 +08:00 · 6f77e7f86e
parent 00b4fdf963 5439d30a5a
commit 6f77e7f86e
1342 changed files with 87665 additions and 41619 deletions
--- a/.gitignore
+++ b/.gitignore
@ -4,5 +4,7 @@ temp_dirs/yankring_history_v2.txt
 sources_forked/yankring/doc/tags
 sources_non_forked/tlib/doc/tags
 sources_non_forked/ctrlp.vim/doc/tags*
+my_plugins/
+my_configs.vim
 tags
-.DS_Store
+.DS_Store
--- a/README.md
+++ b/README.md
@ -1,43 +1,66 @@
+![VIM](https://dnp4pehkvoo6n.cloudfront.net/43c5af597bd5c1a64eb1829f011c208f/as/Ultimate%20Vimrc.svg)
+
 # The Ultimate vimrc

-Over the last 8 years I have used and tweaked Vim. This is my Ultimate vimrc.
+Over the last 10 years, I have used and tweaked Vim. This configuration is the ultimate vimrc (or at least my version of it).

 There are two versions:

-* **Basic**: If you want something small just copy [basic.vim](https://github.com/amix/vimrc/blob/master/vimrcs/basic.vim) into your ~/.vimrc and you will have a great basic setup
-* **Awesome**: This includes a ton of useful plugins, color schemes and configurations
+* **The Basic**: If you want something small just copy [basic.vim](https://github.com/amix/vimrc/blob/master/vimrcs/basic.vim) into your ~/.vimrc and you will have a good basic setup
+* **The Awesome**: Includes a ton of useful plugins, color schemes, and configurations
+
+I would, of course, recommend using the awesome version.

-I would of course recommend using the awesome version.c

 ## How to install the Awesome version?
-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:
+### 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 https://github.com/amix/vimrc.git ~/.vim_runtime
+	git clone --depth=1 https://github.com/amix/vimrc.git ~/.vim_runtime
 	sh ~/.vim_runtime/install_awesome_vimrc.sh
+	
+### Install for multiple users
+To install for multiple users, the repository needs to be cloned to a location accessible for all the intended users.

-I also recommend using [Source Code Pro font from Adobe](http://store1.adobe.com/cfusion/store/html/index.cfm?event=displayFontPackage&code=1960) (it's free and awesome font for writing and programming). The Awesome vimrc is already setup to try to use it
+	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 basically just one file and no plugins. You can check out [basic.vim](https://github.com/amix/vimrc/blob/master/vimrcs/basic.vim).

-This is useful to install on remote servers where you don't need many plugins and you don't do many edits.
+The basic version is just one file and no plugins. Just copy [basic.vim](https://github.com/amix/vimrc/blob/master/vimrcs/basic.vim) and paste it into your vimrc.

-	git clone git://github.com/amix/vimrc.git ~/.vim_runtime
+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 https://github.com/amix/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?

-Simply just do a git rebase!
+Just do a git rebase!

    cd ~/.vim_runtime
    git pull --rebase
@ -46,49 +69,47 @@ Simply just do a git rebase!
 ## Some screenshots

 Colors when editing a Python file:
-![Screenshot 1](http://files1.wedoist.com/e952fdb343b1e617b90d256e474d0370/as/screenshot_1.png)

-Opening recently opened files [mru.vim](https://github.com/vim-scripts/mru.vim):
-![Screenshot 2](http://files1.wedoist.com/1967b0e48af40e513d1a464e08196990/as/screenshot_2.png)
+![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](http://files1.wedoist.com/b1509d7ed9e9f357e8d04797f9fad67b/as/screenshot3.png)
-
-This vimrc even works on Windows!
-![Screenshot 4](http://files1.wedoist.com/4e85163d97b81422240c822c82022f2f/as/screenshot_4.png)
+![Screenshot 3](https://dnp4pehkvoo6n.cloudfront.net/ae719203166585d64728f28398f4b1b7/as/Terminal%20usage.png)

 Distraction free mode using [goyo.vim](https://github.com/junegunn/goyo.vim) and [vim-zenroom2](https://github.com/amix/vim-zenroom2):
-![Screenshot 5](https://d2dq6e731uoz0t.cloudfront.net/a5182977c3d6c2a6cd3f9e97398ca8ca/as/zen_mode.jpg)
+![Screenshot 4](https://dnp4pehkvoo6n.cloudfront.net/f0dcc4c9739148c56cbf8285a910ac41/as/Zen%20mode.png)


 ## Included Plugins

-I recommend reading the docs of these plugins to understand them better. Each of them provide a much better Vim experience!
+I recommend reading the docs of these plugins to understand them better. Each plugin provides a much better Vim experience!

-* [pathogen.vim](https://github.com/tpope/vim-pathogen): Manages the runtime path of the plugins
-* [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
-* [bufexplorer.zip](https://github.com/vim-scripts/bufexplorer.zip): Buffer Explorer / Browser. This plugin can be opened with `<leader+o>`
+* [ack.vim](https://github.com/mileszs/ack.vim): Vim plugin for `the_silver_searcher` (ag) or ack -- a wicked fast grep
+* [bufexplorer.zip](https://github.com/vim-scripts/bufexplorer.zip): Quickly and easily switch between buffers. This plugin can be opened with `<leader+o>`
+* [ctrlp.vim](https://github.com/ctrlpvim/ctrlp.vim): Fuzzy file, buffer, mru and tag finder. It's mapped to `<Ctrl+F>`
+* [goyo.vim](https://github.com/junegunn/goyo.vim) and [vim-zenroom2](https://github.com/amix/vim-zenroom2): 
+* [lightline.vim](https://github.com/itchyny/lightline.vim): A light and configurable statusline/tabline for Vim
 * [NERD Tree](https://github.com/scrooloose/nerdtree): A tree explorer plugin for vim
-* [ack.vim](https://github.com/mileszs/ack.vim): Vim plugin for the Perl module / CLI script 'ack'
-* [ag.vim](https://github.com/rking/ag.vim): A much faster Ack
-* [ctrlp.vim](https://github.com/ctrlpvim/ctrlp.vim): Fuzzy file, buffer, mru and tag finder. In my config it's mapped to `<Ctrl+F>`, because `<Ctrl+P>` is used by YankRing
-* [mru.vim](https://github.com/vim-scripts/mru.vim): Plugin to manage Most Recently Used (MRU) files. Includes my own fork which adds syntax highlighting to MRU. This plugin can be opened with `<leader+f>`
+* [mru.vim](https://github.com/vim-scripts/mru.vim): Plugin to manage Most Recently Used (MRU) files. This plugin can be opened with `<leader+f>`
 * [open_file_under_cursor.vim](https://github.com/amix/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
+* [ale](https://github.com/w0rp/ale): Syntax and lint checking for vim (async)
+* [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-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
-* [goyo.vim](https://github.com/junegunn/goyo.vim) and [vim-zenroom2](https://github.com/amix/vim-zenroom2): 
-Remove all clutter and focus only on the essential. Similar to iA Writer or Write Room [Read more here](http://amix.dk/blog/post/19744)
-* [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.
-* [syntastic](https://github.com/scrooloose/syntastic): Syntax checking hacks for vim
 * [vim-yankstack](https://github.com/maxbrunsfeld/vim-yankstack): Maintains a history of previous yanks, changes and deletes
-* [lightline.vim](https://github.com/itchyny/lightline.vim): A light and configurable statusline/tabline for Vim
+* [vim-zenroom2](https://github.com/amix/vim-zenroom2) Remove all clutter and focus only on the essential. Similar to iA Writer or Write Room


 ## Included color schemes

-* [peaksea](https://github.com/vim-scripts/peaksea): My favorite!
+* [peaksea](https://github.com/vim-scripts/peaksea): The default
 * [vim-colors-solarized](https://github.com/altercation/vim-colors-solarized)
 * [vim-irblack](https://github.com/wgibbs/vim-irblack)
 * [mayansmoke](https://github.com/vim-scripts/mayansmoke)
@ -107,37 +128,38 @@ Remove all clutter and focus only on the essential. Similar to iA Writer or Writ

 ## How to include your own stuff?

-After you have installed the setup you can create **~/.vim_runtime/my_configs.vim** to fill in any configurations that are important for you. For instance, my **my_configs.vim** looks like this:
+After you have installed the setup, you can create **~/.vim_runtime/my_configs.vim** to fill in any configurations that are important for you. For instance, my **my_configs.vim** looks like this:

 	~/.vim_runtime (master)> cat my_configs.vim
 	map <leader>ct :cd ~/Desktop/Todoist/todoist<cr>
 	map <leader>cw :cd ~/Desktop/Wedoist/wedoist<cr> 

-You can also install your own plugins, for instance, via pathogen we can install [vim-rails](https://github.com/tpope/vim-rails):
+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
-	
-Now you have vim-rails installed ;-)
+	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) and see and manage the current buffers (`<leader>o`):
+Open [bufexplorer](https://github.com/vim-scripts/bufexplorer.zip) to see and manage the current buffers (`<leader>o`):
    
    map <leader>o :BufExplorer<cr>

-Open [MRU.vim](https://github.com/vim-scripts/mru.vim) and see the recently open files (`<leader>f`):
+Open [MRU.vim](https://github.com/vim-scripts/mru.vim) to see the recently open files (`<leader>f`):

    map <leader>f :MRU<CR>

-Open [ctrlp.vim](https://github.com/kien/ctrlp.vim) plugin (`<leader>j` or `<ctrl>f`):
+Open [ctrlp.vim](https://github.com/kien/ctrlp.vim) plugin to quickly find a file or a buffer (`<leader>j` or `<ctrl>f`):
    
    let g:ctrlp_map = '<c-f>'

-Managing the [NERD Tree](https://github.com/scrooloose/nerdtree) plugin:
+[NERD Tree](https://github.com/scrooloose/nerdtree) mappings:

    map <leader>nn :NERDTreeToggle<cr>
    map <leader>nb :NERDTreeFromBookmark 
@ -147,6 +169,7 @@ Managing the [NERD Tree](https://github.com/scrooloose/nerdtree) plugin:

    map <leader>z :Goyo<cr>

+
 ### Normal mode mappings

 Fast saving of a buffer (`<leader>w`):
@ -159,7 +182,7 @@ Map `<Space>` to `/` (search) and `<Ctrl>+<Space>` to `?` (backwards search):
 	map <c-space> ?
 	map <silent> <leader><cr> :noh<cr>

-Disable highlight when `<leader><cr>` is pressed:
+Disable highlights when you press `<leader><cr>`:
 	
 	map <silent> <leader><cr> :noh<cr>

@ -170,7 +193,7 @@ Smart way to move between windows (`<ctrl>j` etc.):
 	map <C-h> <C-W>h
 	map <C-l> <C-W>l

-Closing of current buffer(s) (`<leader>bd` and (`<leader>ba`)):
+Closing of the current buffer(s) (`<leader>bd` and (`<leader>ba`)):
 	
 	" Close current buffer
 	map <leader>bd :Bclose<cr>
@ -189,22 +212,14 @@ Useful mappings for managing tabs:
 	" Super useful when editing files in the same directory
 	map <leader>te :tabedit <c-r>=expand("%:p:h")<cr>/
 	
-Switch CWD to the directory of the open buffer:
+Switch [CWD](http://vim.wikia.com/wiki/Set_working_directory_to_the_current_file) to the directory of the open buffer:
 	
 	map <leader>cd :cd %:p:h<cr>:pwd<cr>
 	
-Open vimgrep and put the cursor in the right position:
+Open `ack.vim` for fast search:
 	
-	map <leader>g :vimgrep // **/*.<left><left><left><left><left><left><left>
+	map <leader>g :Ack 

-Vimgreps in the current file:
-	
-	map <leader><space> :vimgrep // <C-R>%<C-A><right><right><right><right><right><right><right><right><right>
-
-Remove the Windows ^M - when the encodings gets messed up:
-	
-	noremap <leader>m mmHmt:%s/<C-V><cr>//ge<cr>'tzt'm
-	
 Quickly open a buffer for scripbble:
 	
 	map <leader>q :e ~/buffer<cr>
@ -214,6 +229,31 @@ Toggle paste mode on and off:
 	map <leader>pp :setlocal paste!<cr>


+### Visual mode mappings
+
+Visual mode pressing `*` or `#` searches for the current selection:
+
+	vnoremap <silent> * :call VisualSelection('f')<CR>
+	vnoremap <silent> # :call VisualSelection('b')<CR>
+
+When you press gv you `Ack.vim` after the selected text:
+
+	vnoremap <silent> gv :call VisualSelection('gv', '')<CR>
+
+When you press `<leader>r` you can search and replace the selected text:
+
+	vnoremap <silent> <leader>r :call VisualSelection('replace')<CR>
+
+Surround the visual selection in parenthesis/brackets/etc.:
+
+    vnoremap $1 <esc>`>a)<esc>`<i(<esc>
+    vnoremap $2 <esc>`>a]<esc>`<i[<esc>
+    vnoremap $3 <esc>`>a}<esc>`<i{<esc>
+    vnoremap $$ <esc>`>a"<esc>`<i"<esc>
+    vnoremap $q <esc>`>a'<esc>`<i'<esc>
+    vnoremap $e <esc>`>a"<esc>`<i"<esc>
+
+
 ### Insert mode mappings

 Quickly insert parenthesis/brackets/etc.:
@ -231,31 +271,6 @@ Insert the current date and time (useful for timestamps):
    iab xdate <c-r>=strftime("%d/%m/%y %H:%M:%S")<cr>


-### Visual mode mappings
-
-Visual mode pressing `*` or `#` searches for the current selection:
-
-	vnoremap <silent> * :call VisualSelection('f')<CR>
-	vnoremap <silent> # :call VisualSelection('b')<CR>
-
-When you press gv you vimgrep after the selected text:
-
-	vnoremap <silent> gv :call VisualSelection('gv')<CR>
-
-When you press `<leader>r` you can search and replace the selected text:
-
-	vnoremap <silent> <leader>r :call VisualSelection('replace')<CR>
-
-Surround the visual selection in parenthesis/brackets/etc.:
-
-    vnoremap $1 <esc>`>a)<esc>`<i(<esc>
-    vnoremap $2 <esc>`>a]<esc>`<i[<esc>
-    vnoremap $3 <esc>`>a}<esc>`<i{<esc>
-    vnoremap $$ <esc>`>a"<esc>`<i"<esc>
-    vnoremap $q <esc>`>a'<esc>`<i'<esc>
-    vnoremap $e <esc>`>a"<esc>`<i"<esc>
-	
-
 ### Command line mappings

 $q is super useful when browsing on the command line. It deletes everything until the last slash:
@ -271,27 +286,28 @@ Bash like keys for the command line:
    cnoremap <C-P> <Up>
    cnoremap <C-N> <Down>

-Write the file as sudo (only on Unix). Super useful when you open a file and you don't have permissions to save your changes. [Vim tip](http://vim.wikia.com/wiki/Su-write):
+Write the file as sudo (works only on Unix). Super useful when you open a file and you don't have permissions to save your changes. [Vim tip](http://vim.wikia.com/wiki/Su-write):

    :W 


 ### Spell checking
-Pressing `<leader>ss` will toggle and untoggle spell checking
+Pressing `<leader>ss` will toggle spell checking:

    map <leader>ss :setlocal spell!<cr>

-Shortcuts using `<leader>` instead of special chars
+Shortcuts using `<leader>` instead of special characters:

    map <leader>sn ]s
    map <leader>sp [s
    map <leader>sa zg
    map <leader>s? z=

-### Cope	
-Do :help cope if you are unsure what cope is. It's super useful!

-When you search with vimgrep, display your results in cope by doing:
+### Cope
+Query `:help cope` if you are unsure what cope is. It's super useful!
+
+When you search with `Ack.vim`, display your results in cope by doing:
 `<leader>cc`

 To go to the next search result do:
@ -300,15 +316,22 @@ To go to the next search result do:
 To go to the previous search results do:
 `<leader>p`

-Vimscript mappings:
+Cope mappings:

    map <leader>cc :botright cope<cr>
    map <leader>co ggVGy:tabnew<cr>:set syntax=qf<cr>pgg
    map <leader>n :cn<cr>
    map <leader>p :cp<cr>

-## How to uninstall
-Do following:
-* Remove `~/.vim_runtime`
-* Remove any lines that refernce `.vim_runtime` in your `~/.vimrc`

+## How to uninstall
+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 😄
--- a/install_awesome_parameterized.sh
+++ b/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
--- a/install_awesome_vimrc.sh
+++ b/install_awesome_vimrc.sh
@ -1,3 +1,6 @@
+#!/bin/sh
+set -e
+
 cd ~/.vim_runtime

 echo 'set runtimepath+=~/.vim_runtime
--- a/install_basic_vimrc.sh
+++ b/install_basic_vimrc.sh
@ -1,3 +1,6 @@
+#!/bin/sh
+set -e
+
 cd ~/.vim_runtime
 cat ~/.vim_runtime/vimrcs/basic.vim > ~/.vimrc
 echo "Installed the Basic Vim configuration successfully! Enjoy :-)"
--- a/my_plugins/.gitkeep
+++ b/my_plugins/.gitkeep
--- a/sources_non_forked/ack.vim/README.md
+++ b/sources_non_forked/ack.vim/README.md
@ -2,22 +2,22 @@

 Run your favorite search tool from Vim, with an enhanced results list.

-This plugin was designed as a Vim frontend for the Perl module [App::Ack]. Ack
-can be used as a replacement for 99% of the uses of _grep_. The plugin allows
-you to run ack from Vim, and shows the results in a split window.
+This plugin was designed as a Vim frontend for the programmer's search tool
+[ack]. ack can be used as a replacement for 99% of the uses of `grep`. The
+plugin allows you to search with ack from within Vim and shows the results in a
+split window.

 But here's a little secret for the Vim-seasoned: it's just a light wrapper for
 Vim's [grepprg] and the [quickfix] window for match results. This makes it easy
 to integrate with your own Vim configuration and use existing knowledge of core
 features. It also means the plugin is flexible to use with other search tools.

-[App::Ack]: http://search.cpan.org/~petdance/ack/ack
 [grepprg]: http://vimdoc.sourceforge.net/htmldoc/options.html#'grepprg'
 [quickfix]: http://vimdoc.sourceforge.net/htmldoc/quickfix.html#quickfix

 ## Installation

-### Ack
+### ack

 You will need ack (>= 2.0), of course. To install it follow the
 [manual](http://beyondgrep.com/install/).
@ -49,8 +49,6 @@ NeoBundle 'mileszs/ack.vim'
 [Download][releases] the plugin and extract it in `~/.vim/` (or
 `%PROGRAMFILES%/Vim/vimfiles` on Windows).

-[zipball]: https://github.com/mileszs/ack.vim/archive/master.zip
-
 ## Usage

    :Ack [options] {pattern} [{directories}]
@ -60,7 +58,7 @@ for the `{pattern}`.

 Files containing the search term will be listed in the quickfix window, along
 with the line number of the occurrence, once for each occurrence. `<Enter>` on
-a line in this window will open the file, and place the cursor on the matching
+a line in this window will open the file and place the cursor on the matching
 line.

 Just like where you use `:grep`, `:grepadd`, `:lgrep`, and :`lgrepadd`, you can
@ -89,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].
@ -140,22 +142,22 @@ the convention of Vim's built-in `:grep` and `:make` commands.

 ## Changelog

-Please see [the Github releases page][releases].
+Please see [the GitHub releases page][releases].

 ## Credits

-This plugin is derived from Antoine Imbert's blog post [Ack and Vim
+This plugin is derived from Antoine Imbert's blog post [ack and Vim
 Integration][] (in particular, the function in the update to the post). [Miles
 Sterrett][mileszs] packaged it up as a plugin and documented it in Vim's help
 format, and since then [many contributors][contributors] have submitted
 enhancements and fixes.

-And of course, where would we be without [Ack]. And, you know, Vim.
+And of course, where would we be without [ack]. And, you know, Vim.

-[Ack and Vim Integration]: http://blog.ant0ine.com/typepad/2007/03/ack-and-vim-integration.html
+[ack and Vim Integration]: http://blog.ant0ine.com/typepad/2007/03/ack-and-vim-integration.html
 [mileszs]: https://github.com/mileszs
 [contributors]: https://github.com/mileszs/ack.vim/graphs/contributors
-[Ack]: http://beyondgrep.com/
+[ack]: http://beyondgrep.com/

 [vim-dispatch]: https://github.com/tpope/vim-dispatch
 [releases]: https://github.com/mileszs/ack.vim/releases
--- a/sources_non_forked/ack.vim/autoload/ack.vim
+++ b/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> k k<CR><C-W><C-W>
+    nnoremap <buffer> <silent> j j<CR><C-W><C-P>
+    nnoremap <buffer> <silent> k k<CR><C-W><C-P>
    nmap <buffer> <silent> <Down> j
    nmap <buffer> <silent> <Up> k
  endif
--- a/sources_non_forked/ag.vim/.gitignore
+++ b/sources_non_forked/ag.vim/.gitignore
@ -1,2 +0,0 @@
-tags
-ag-vim.tgz
--- a/sources_non_forked/ag.vim/README.md
+++ b/sources_non_forked/ag.vim/README.md
@ -1,81 +0,0 @@
-# ag.vim #
-
-## Deprecated: See [this comment](https://github.com/rking/ag.vim/issues/124#issuecomment-227038003) for more info. Maybe try [ack.vim](https://github.com/mileszs/ack.vim#can-i-use-ag-the-silver-searcher-with-this) as an alternative. ##
-
-This plugin is a front for ag, A.K.A.
-[the_silver_searcher](https://github.com/ggreer/the_silver_searcher).  Ag can
-be used as a replacement for 153% of the uses of `ack`.  This plugin will allow
-you to run ag from vim, and shows the results in a split window.
-
-## Installation ##
-
-See [the_silver_searcher's README](https://github.com/ggreer/the_silver_searcher#installing) for its installation instructions (if you haven't installed it already).
-
-You have to first install [ag](https://github.com/ggreer/the_silver_searcher), itself. On Mac+Homebrew, Gentoo Linux, several others, there's package named `the_silver_searcher`, but if your OS/distro don't have one, the GitHub repo installs fine:
-
-Vim has various ways of installing plugins, the standard way is in [the documentation](http://vimdoc.sourceforge.net/htmldoc/usr_05.html#plugin), but most people use a plugin to manage their plugins. If you don't already have a preferred plugin manager plugin, why not try one of the following?
- [vim-plug](https://github.com/junegunn/vim-plug#readme)
- [vim-pathogen](https://github.com/tpope/vim-pathogen#readme)
- [Vundle.vim](https://github.com/gmarik/Vundle.vim#readme)
- Or, if you don't use any sort of Vim plugin management:
-
-  ```sh
-  cd ~/.vim/bundle && git clone https://github.com/rking/ag.vim ag && echo "set runtimepath^=~/.vim/bundle/ag" >> ~/.vimrc
-  ```
-
-  Then open vim and run `:helptags ~/.vim/bundle/ag/doc`.
-
-### Configuration ###
-
-You can specify a custom ag name and path in your .vimrc like so:
-
-    let g:ag_prg="<custom-ag-path-goes-here> --vimgrep"
-
-You can configure ag.vim to always start searching from your project root
-instead of the cwd
-
-    let g:ag_working_path_mode="r"
-
-## Usage ##
-
-    :Ag [options] {pattern} [{directory}]
-
-Search recursively in {directory} (which defaults to the current directory) for the {pattern}.
-
-Files containing the search term will be listed in the split window, along with
-the line number of the occurrence, once for each occurrence.  [Enter] on a line
-in this window will open the file, and place the cursor on the matching line.
-
-Just like where you use :grep, :grepadd, :lgrep, and :lgrepadd, you can use `:Ag`, `:AgAdd`, `:LAg`, and `:LAgAdd` respectively. (See `doc/ag.txt`, or install and `:h Ag` for more information.)
-
-### Gotchas ###
-
-Some characters have special meaning, and need to be escaped your search pattern. For instance, '#'. You have to escape it like this `:Ag '\\\#define foo'` to search for `#define foo`. (From [blueyed in issue #5](https://github.com/mileszs/ack.vim/issues/5).)
-
-Sometimes `git grep` is even faster, though in my experience it's not noticeably so.
-
-### Keyboard Shortcuts ###
-
-In the quickfix window, you can use:
-
-    e    to open file and close the quickfix window
-    o    to open (same as enter)
-    go   to preview file (open but maintain focus on ag.vim results)
-    t    to open in new tab
-    T    to open in new tab silently
-    h    to open in horizontal split
-    H    to open in horizontal split silently
-    v    to open in vertical split
-    gv   to open in vertical split silently
-    q    to close the quickfix window
-
-### Related Plugin ###
-[vim-ag-anything](https://github.com/Chun-Yang/vim-ag-anything) adds an 'ga' action to search any text object.
-
-### Acknowledgements ###
-
-This Vim plugin is derived (and by derived, I mean copied, almost entirely)
-from [milesz's ack.vim](https://github.com/mileszs/ack.vim), which I also
-recommend installing since you might be in a situation where you have ack but
-not ag, and don't want to stop to install ag. Also, ack supports `--type`, and
-a few other features.
--- a/sources_non_forked/ag.vim/Rakefile
+++ b/sources_non_forked/ag.vim/Rakefile
@ -1,3 +0,0 @@
-task :tgz do
-  sh 'cd ..; tar czvf ag/ag-vim.tgz ag/{plugin,autoload,doc}'
-end
--- a/sources_non_forked/ag.vim/autoload/ag.vim
+++ b/sources_non_forked/ag.vim/autoload/ag.vim
@ -1,234 +0,0 @@
-" NOTE: You must, of course, install ag / the_silver_searcher
-
-" FIXME: Delete deprecated options below on or after 2016-4 (6 months from when the deprecation warning was added) {{{
-
-if exists("g:agprg")
-  let g:ag_prg = g:agprg
-  echohl WarningMsg
-  call input('g:agprg is deprecated and will be removed. Please use g:ag_prg')
-  echohl None
-endif
-
-if exists("g:aghighlight")
-  let g:ag_highlight = g:aghighlight
-  echohl WarningMsg
-  call input('g:aghighlight is deprecated and will be removed. Please use g:ag_highlight')
-  echohl None
-endif
-
-if exists("g:agformat")
-  let g:ag_format = g:agformat
-  echohl WarningMsg
-  call input('g:agformat is deprecated and will be removed. Please use g:ag_format')
-  echohl None
-endif
-
-" }}} FIXME: Delete the deprecated options above on or after 15-7 (6 months from when they were changed)
-
-" Location of the ag utility
-if !exists("g:ag_prg")
-  " --vimgrep (consistent output we can parse) is available from version  0.25.0+
-  if split(system("ag --version"), "[ \n\r\t]")[2] =~ '\d\+.\(\(2[5-9]\)\|\([3-9][0-9]\)\)\(.\d\+\)\?'
-    let g:ag_prg="ag --vimgrep"
-  else
-    " --noheading seems odd here, but see https://github.com/ggreer/the_silver_searcher/issues/361
-    let g:ag_prg="ag --column --nogroup --noheading"
-  endif
-endif
-
-if !exists("g:ag_apply_qmappings")
-  let g:ag_apply_qmappings=1
-endif
-
-if !exists("g:ag_apply_lmappings")
-  let g:ag_apply_lmappings=1
-endif
-
-if !exists("g:ag_qhandler")
-  let g:ag_qhandler="botright copen"
-endif
-
-if !exists("g:ag_lhandler")
-  let g:ag_lhandler="botright lopen"
-endif
-
-if !exists("g:ag_mapping_message")
-  let g:ag_mapping_message=1
-endif
-
-if !exists("g:ag_working_path_mode")
-    let g:ag_working_path_mode = 'c'
-endif
-
-function! ag#AgBuffer(cmd, args)
-  let l:bufs = filter(range(1, bufnr('$')), 'buflisted(v:val)')
-  let l:files = []
-  for buf in l:bufs
-    let l:file = fnamemodify(bufname(buf), ':p')
-    if !isdirectory(l:file)
-      call add(l:files, l:file)
-    endif
-  endfor
-  call ag#Ag(a:cmd, a:args . ' ' . join(l:files, ' '))
-endfunction
-
-function! ag#Ag(cmd, args)
-  let l:ag_executable = get(split(g:ag_prg, " "), 0)
-
-  " Ensure that `ag` is installed
-  if !executable(l:ag_executable)
-    echoe "Ag command '" . l:ag_executable . "' was not found. Is the silver searcher installed and on your $PATH?"
-    return
-  endif
-
-  " If no pattern is provided, search for the word under the cursor
-  if empty(a:args)
-    let l:grepargs = expand("<cword>")
-  else
-    let l:grepargs = a:args . join(a:000, ' ')
-  end
-
-  if empty(l:grepargs)
-    echo "Usage: ':Ag {pattern}' (or just :Ag to search for the word under the cursor). See ':help :Ag' for more information."
-    return
-  endif
-
-  " Format, used to manage column jump
-  if a:cmd =~# '-g$'
-    let s:ag_format_backup=g:ag_format
-    let g:ag_format="%f"
-  elseif exists("s:ag_format_backup")
-    let g:ag_format=s:ag_format_backup
-  elseif !exists("g:ag_format")
-    let g:ag_format="%f:%l:%c:%m"
-  endif
-
-  let l:grepprg_bak=&grepprg
-  let l:grepformat_bak=&grepformat
-  let l:t_ti_bak=&t_ti
-  let l:t_te_bak=&t_te
-  try
-    let &grepprg=g:ag_prg
-    let &grepformat=g:ag_format
-    set t_ti=
-    set t_te=
-    if g:ag_working_path_mode ==? 'r' " Try to find the projectroot for current buffer
-      let l:cwd_back = getcwd()
-      let l:cwd = s:guessProjectRoot()
-      try
-        exe "lcd ".l:cwd
-      catch
-        echom 'Failed to change directory to:'.l:cwd
-      finally
-        silent! execute a:cmd . " " . escape(l:grepargs, '|')
-        exe "lcd ".l:cwd_back
-      endtry
-    else " Someone chose an undefined value or 'c' so we revert to the default
-      silent! execute a:cmd . " " . escape(l:grepargs, '|')
-    endif
-  finally
-    let &grepprg=l:grepprg_bak
-    let &grepformat=l:grepformat_bak
-    let &t_ti=l:t_ti_bak
-    let &t_te=l:t_te_bak
-  endtry
-
-  if a:cmd =~# '^l'
-    let l:match_count = len(getloclist(winnr()))
-  else
-    let l:match_count = len(getqflist())
-  endif
-
-  if a:cmd =~# '^l' && l:match_count
-    exe g:ag_lhandler
-    let l:apply_mappings = g:ag_apply_lmappings
-    let l:matches_window_prefix = 'l' " we're using the location list
-  elseif l:match_count
-    exe g:ag_qhandler
-    let l:apply_mappings = g:ag_apply_qmappings
-    let l:matches_window_prefix = 'c' " we're using the quickfix window
-  endif
-
-  " If highlighting is on, highlight the search keyword.
-  if exists('g:ag_highlight')
-    let @/ = matchstr(a:args, "\\v(-)\@<!(\<)\@<=\\w+|['\"]\\zs.{-}\\ze['\"]")
-    call feedkeys(":let &hlsearch=1 \| echo \<CR>", 'n')
-  end
-
-  redraw!
-
-  if l:match_count
-    if l:apply_mappings
-      nnoremap <silent> <buffer> h  <C-W><CR><C-w>K
-      nnoremap <silent> <buffer> H  <C-W><CR><C-w>K<C-w>b
-      nnoremap <silent> <buffer> o  <CR>
-      nnoremap <silent> <buffer> t  <C-w><CR><C-w>T
-      nnoremap <silent> <buffer> T  <C-w><CR><C-w>TgT<C-W><C-W>
-      nnoremap <silent> <buffer> v  <C-w><CR><C-w>H<C-W>b<C-W>J<C-W>t
-
-      exe 'nnoremap <silent> <buffer> e <CR><C-w><C-w>:' . l:matches_window_prefix .'close<CR>'
-      exe 'nnoremap <silent> <buffer> go <CR>:' . l:matches_window_prefix . 'open<CR>'
-      exe 'nnoremap <silent> <buffer> q  :' . l:matches_window_prefix . 'close<CR>'
-
-      exe 'nnoremap <silent> <buffer> gv :let b:height=winheight(0)<CR><C-w><CR><C-w>H:' . l:matches_window_prefix . 'open<CR><C-w>J:exe printf(":normal %d\<lt>c-w>_", b:height)<CR>'
-      " Interpretation:
-      " :let b:height=winheight(0)<CR>                      Get the height of the quickfix/location list window
-      " <CR><C-w>                                           Open the current item in a new split
-      " <C-w>H                                              Slam the newly opened window against the left edge
-      " :copen<CR> -or- :lopen<CR>                          Open either the quickfix window or the location list (whichever we were using)
-      " <C-w>J                                              Slam the quickfix/location list window against the bottom edge
-      " :exe printf(":normal %d\<lt>c-w>_", b:height)<CR>   Restore the quickfix/location list window's height from before we opened the match
-
-      if g:ag_mapping_message && l:apply_mappings
-        echom "ag.vim keys: q=quit <cr>/e/t/h/v=enter/edit/tab/split/vsplit go/T/H/gv=preview versions of same"
-      endif
-    endif
-  else " Close the split window automatically:
-    cclose
-    lclose
-    echohl WarningMsg
-    echom 'No matches for "'.a:args.'"'
-    echohl None
-  endif
-endfunction
-
-function! ag#AgFromSearch(cmd, args)
-  let search =  getreg('/')
-  " translate vim regular expression to perl regular expression.
-  let search = substitute(search,'\(\\<\|\\>\)','\\b','g')
-  call ag#Ag(a:cmd, '"' .  search .'" '. a:args)
-endfunction
-
-function! ag#GetDocLocations()
-  let dp = ''
-  for p in split(&runtimepath,',')
-    let p = p.'doc/'
-    if isdirectory(p)
-      let dp = p.'*.txt '.dp
-    endif
-  endfor
-  return dp
-endfunction
-
-function! ag#AgHelp(cmd,args)
-  let args = a:args.' '.ag#GetDocLocations()
-  call ag#Ag(a:cmd,args)
-endfunction
-
-function! s:guessProjectRoot()
-  let l:splitsearchdir = split(getcwd(), "/")
-
-  while len(l:splitsearchdir) > 2
-    let l:searchdir = '/'.join(l:splitsearchdir, '/').'/'
-    for l:marker in ['.rootdir', '.git', '.hg', '.svn', 'bzr', '_darcs', 'build.xml']
-      " found it! Return the dir
-      if filereadable(l:searchdir.l:marker) || isdirectory(l:searchdir.l:marker)
-        return l:searchdir
-      endif
-    endfor
-    let l:splitsearchdir = l:splitsearchdir[0:-2] " Splice the list to get rid of the tail directory
-  endwhile
-
-  " Nothing found, fallback to current working dir
-  return getcwd()
-endfunction
--- a/sources_non_forked/ag.vim/doc/ag.txt
+++ b/sources_non_forked/ag.vim/doc/ag.txt
@ -1,174 +0,0 @@
-*ag.txt*   Plugin that integrates ag with Vim
-
-==============================================================================
-INTRODUCTION                                                               *ag*
-
-This plugin is a front for the_silver_searcher: ag. Ag can be used as a
-replacement for ack. This plugin will allow you to run ag from vim, and shows
-the results in a split window.
-
-:Ag[!] [options] {pattern} [{directory}]                                  *:Ag*
-
-    Search recursively in {directory} (which defaults to the current
-    directory) for the {pattern}. Behaves just like the |:grep| command, but
-    will open the |Quickfix| window for you. If [!] is not given the first
-    error is jumped to.
-
-:AgBuffer[!] [options] {pattern}                                    *:AgBuffer*
-
-    Search for {pattern} in all open buffers. Behaves just like the |:grep|
-    command, but will open the |Quickfix| window for you. If [!] is not given
-    the first error is jumped to.
-
-    Note: this will not find changes in modified buffers, since ag can only
-    find what is on disk! You can save buffers automatically when searching
-    with the 'autowrite' option. A buffer will be ignored if it is a directory
-    (an explorer, like netrw).
-
-:AgAdd [options] {pattern} [{directory}]                               *:AgAdd*
-
-    Just like |:Ag|, but instead of making a new list, the matches are
-    appended to the current |quickfix| list.
-
-:AgFromSearch [{directory}]                                     *:AgFromSearch*
-
-    Just like |:Ag| but the pattern is from previous search.
-
-:LAg [options] {pattern} [{directory}]                                   *:LAg*
-
-    Just like |:Ag| but instead of the |quickfix| list, matches are placed in
-    the current |location-list|.
-
-:LAgBuffer [options] {pattern}                                     *:LAgBuffer*
-
-    Just like |:AgBuffer| but instead of the |quickfix| list, matches are
-    placed in the current |location-list|.
-
-:LAgAdd [options] {pattern} [{directory}]                             *:LAgAdd*
-
-    Just like |:AgAdd| but instead of the |quickfix| list, matches are added
-    to the current |location-list|
-
-:AgFile [options] {pattern} [{directory}]                             *:AgFile*
-
-    Search recursively in {directory} (which defaults to the current
-    directory) for filenames matching the {pattern}. Behaves just like the
-    |:grep| command, but will open the |Quickfix| window for you.
-
-:AgHelp[!] [options] {pattern}                                        *:AgHelp*
-
-    Search vim documentation files for the {pattern}. Behaves just like the
-    |:Ag| command, but searches only vim documentation .txt files
-
-:LAgHelp [options] {pattern}                                         *:LAgHelp*
-
-    Just like |:AgHelp| but instead of the |quickfix| list, matches are placed
-    in the current |location-list|.
-
-Files containing the search term will be listed in the split window, along
-with the line number of the occurrence, once for each occurrence. <Enter> on a
-line in this window will open the file, and place the cursor on the matching
-line.
-
-See http://geoff.greer.fm/2011/12/27/the-silver-searcher-better-than-ack/ for
-more information.
-
-==============================================================================
-OPTIONS                                                            *ag-options*
-
-                                                                     *g:ag_prg*
-The location of the Ag program, and any options you want passed to it before
-searching. Default: "ag --vimgrep" (for parsable output). Example: >
-  let g:ag_prg="ag --vimgrep --smart-case"
-<
-Note: the `--vimgrep` option was added in Ag 0.25.0. If ag.vim detects that
-you're using a lower version, the following default will be used instead: >
-  let g:ag_prg="ag --column --nogroup --noheading"
-<
-This works around inconsistent behaviors in earlier Ag versions, but it is
-recommended that you upgrade if possible for a better experience. `--vimgrep`
-supports multiple matches on the same line of text, for example.
-
-For background, see: https://github.com/rking/ag.vim/pull/88
-
-                                                       *g:ag_working_path_mode*
-A mapping that describes where ag will be run. Default is the current working
-directory. Specifying 'r' as the argument will tell it to run from the project
-rootdirectory. For now any other mapping will result to the default.
-Example:
-  let g:ag_working_path_mode='r'
-
-                                                               *g:ag_highlight*
-If 1, highlight the search terms after searching. Default: 0. Example: >
-  let g:ag_highlight=1
-<
-
-                                                                  *g:ag_format*
-Format to recognize the matches. See 'errorformat' for more info. Default:
-"%f" when searching for files, "%f:%l:%c:%m" if not otherwise set. For
-example, if your `g:ag_prg` is set to just "ag" (no column numbers in the
-output, so when you jump to a match your cursor will be on the start of the
-line): >
-  let g:ag_format="%f:%l:%m"
-<
-
-                                                         *g:ag_apply_lmappings*
-Whether or not to add custom mappings to location list windows opened by this
-plugin. Only applies if you're using the location list. Default 1. Example: >
-  let g:ag_apply_lmappings=0
-<
-
-                                                         *g:ag_apply_qmappings*
-Whether or not to add custom mappings to quickfix windows opened by this
-plugin. Only applies if you're using the error list. Default 1. Example: >
-  let g:ag_apply_qmappings=0
-<
-
-                                                                *g:ag_lhandler*
-A custom command used to open the location list after it's populated.
-Default: "botright lopen". You might want to set this to change where the
-location list is opened, or what size it is. Example: >
-  let g:ag_lhandler="topleft lopen"
-<
-
-                                                                *g:ag_qhandler*
-A custom command used to open the error list after it's populated. Default:
-"botright copen". You might want to set this to change where the quickfix
-window is opened, or what size it is. Example: >
-  let g:ag_qhandler="copen 20"
-<
-
-                                                         *g:ag_mapping_message*
-Whether or not to show the message explaining the extra mappings that are
-added to the results list this plugin populates. This message is not shown if
-the mappings are not applied (see |g:ag_apply_qmappings| and
-|g:ag_apply_lmappings| for more info. Default 1. Example: >
-  let g:ag_mapping_message=0
-<
-
-==============================================================================
-MAPPINGS                                                         *ag-mappings*
-
-The following keyboard shortcuts are available in the quickfix window:
-
-e                   open file and close the quickfix window.
-
-o                   open file (same as enter).
-
-go                  preview file (open but maintain focus on ag.vim results).
-
-t                   open in a new tab.
-
-T                   open in new tab silently.
-
-h                   open in horizontal split.
-
-H                  open in horizontal split silently.
-
-v                   open in vertical split.
-
-gv                  open in vertical split silently.
-
-q                   close the quickfix window.
-
-  vim:tw=78:fo=tcq2:ft=help:norl:
--- a/sources_non_forked/ag.vim/plugin/ag.vim
+++ b/sources_non_forked/ag.vim/plugin/ag.vim
@ -1,11 +0,0 @@
-" NOTE: You must, of course, install ag / the_silver_searcher
-command! -bang -nargs=* -complete=file Ag call ag#Ag('grep<bang>',<q-args>)
-command! -bang -nargs=* -complete=file AgBuffer call ag#AgBuffer('grep<bang>',<q-args>)
-command! -bang -nargs=* -complete=file AgAdd call ag#Ag('grepadd<bang>', <q-args>)
-command! -bang -nargs=* -complete=file AgFromSearch call ag#AgFromSearch('grep<bang>', <q-args>)
-command! -bang -nargs=* -complete=file LAg call ag#Ag('lgrep<bang>', <q-args>)
-command! -bang -nargs=* -complete=file LAgBuffer call ag#AgBuffer('lgrep<bang>',<q-args>)
-command! -bang -nargs=* -complete=file LAgAdd call ag#Ag('lgrepadd<bang>', <q-args>)
-command! -bang -nargs=* -complete=file AgFile call ag#Ag('grep<bang> -g', <q-args>)
-command! -bang -nargs=* -complete=help AgHelp call ag#AgHelp('grep<bang>',<q-args>)
-command! -bang -nargs=* -complete=help LAgHelp call ag#AgHelp('lgrep<bang>',<q-args>)
--- a/sources_non_forked/ale/LICENSE
+++ b/sources_non_forked/ale/LICENSE
@ -0,0 +1,22 @@
+Copyright (c) 2016-2018, 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.
--- a/sources_non_forked/ale/ale_linters/ada/gcc.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/ansible/ansible_lint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/apiblueprint/drafter.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/asciidoc/alex.vim
+++ b/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')
--- a/sources_non_forked/ale/ale_linters/asciidoc/proselint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/asciidoc/redpen.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/asciidoc/textlint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/asciidoc/vale.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/asciidoc/writegood.vim
+++ b/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')
--- a/sources_non_forked/ale/ale_linters/asm/gcc.vim
+++ b/sources_non_forked/ale/ale_linters/asm/gcc.vim
@ -0,0 +1,34 @@
+" Author: Lucas Kolstad <lkolstad@uw.edu>
+" Description: gcc linter for asm files
+
+call ale#Set('asm_gcc_executable', 'gcc')
+call ale#Set('asm_gcc_options', '-Wall')
+
+function! ale_linters#asm#gcc#GetCommand(buffer) abort
+    return '%e -x assembler -fsyntax-only '
+    \   . '-iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ' ' . ale#Var(a:buffer, 'asm_gcc_options') . ' -'
+endfunction
+
+function! ale_linters#asm#gcc#Handle(buffer, lines) abort
+    let l:pattern = '^.\+:\(\d\+\): \([^:]\+\): \(.\+\)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \ 'lnum': l:match[1] + 0,
+        \ 'type': l:match[2] =~? 'error' ? 'E' : 'W',
+        \ 'text': l:match[3],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('asm', {
+\    'name': 'gcc',
+\    'output_stream': 'stderr',
+\    'executable': {b -> ale#Var(b, 'asm_gcc_executable')},
+\    'command': function('ale_linters#asm#gcc#GetCommand'),
+\    'callback': 'ale_linters#asm#gcc#Handle',
+\})
--- a/sources_non_forked/ale/ale_linters/awk/gawk.vim
+++ b/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'
+\})
--- a/sources_non_forked/ale/ale_linters/bib/bibclean.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/c/ccls.vim
+++ b/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')},
+\})
--- a/sources_non_forked/ale/ale_linters/c/clang.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/c/clangd.vim
+++ b/sources_non_forked/ale/ale_linters/c/clangd.vim
@ -0,0 +1,23 @@
+" Author: Andrey Melentyev <andrey.melentyev@protonmail.com>
+" Description: Clangd language server
+
+call ale#Set('c_clangd_executable', 'clangd')
+call ale#Set('c_clangd_options', '')
+
+function! ale_linters#c#clangd#GetProjectRoot(buffer) abort
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
+endfunction
+
+function! ale_linters#c#clangd#GetCommand(buffer) abort
+    return '%e' . ale#Pad(ale#Var(a:buffer, 'c_clangd_options'))
+endfunction
+
+call ale#linter#Define('c', {
+\   'name': 'clangd',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'c_clangd_executable')},
+\   'command': function('ale_linters#c#clangd#GetCommand'),
+\   'project_root': function('ale_linters#c#clangd#GetProjectRoot'),
+\})
--- a/sources_non_forked/ale/ale_linters/c/clangtidy.vim
+++ b/sources_non_forked/ale/ale_linters/c/clangtidy.vim
@ -0,0 +1,42 @@
+" Author: vdeurzen <tim@kompiler.org>, w0rp <devw0rp@gmail.com>,
+" gagbo <gagbobada@gmail.com>, Andrej Radovic <r.andrej@gmail.com>
+" Description: clang-tidy linter for c files
+
+call ale#Set('c_clangtidy_executable', 'clang-tidy')
+" Set this option to check the checks clang-tidy will apply.
+" The number of checks that can be applied to C files is limited in contrast to
+" C++
+"
+" Consult the check list in clang-tidy's documentation:
+" http://clang.llvm.org/extra/clang-tidy/checks/list.html
+
+call ale#Set('c_clangtidy_checks', [])
+" Set this option to manually set some options for clang-tidy.
+" This will disable compile_commands.json detection.
+call ale#Set('c_clangtidy_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#c#clangtidy#GetCommand(buffer) abort
+    let l:checks = join(ale#Var(a:buffer, 'c_clangtidy_checks'), ',')
+    let l:build_dir = ale#c#GetBuildDirectory(a:buffer)
+
+    " Get the extra options if we couldn't find a build directory.
+    let l:options = empty(l:build_dir)
+    \   ? ale#Var(a:buffer, 'c_clangtidy_options')
+    \   : ''
+
+    return '%e'
+    \   . (!empty(l:checks) ? ' -checks=' . ale#Escape(l:checks) : '')
+    \   . ' %s'
+    \   . (!empty(l:build_dir) ? ' -p ' . ale#Escape(l:build_dir) : '')
+    \   . (!empty(l:options) ? ' -- ' . l:options : '')
+endfunction
+
+call ale#linter#Define('c', {
+\   'name': 'clangtidy',
+\   'output_stream': 'stdout',
+\   'executable': {b -> ale#Var(b, 'c_clangtidy_executable')},
+\   'command': function('ale_linters#c#clangtidy#GetCommand'),
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})
--- a/sources_non_forked/ale/ale_linters/c/cppcheck.vim
+++ b/sources_non_forked/ale/ale_linters/c/cppcheck.vim
@ -0,0 +1,34 @@
+" Author: Bart Libert <bart.libert@gmail.com>
+" Description: cppcheck linter for c files
+
+call ale#Set('c_cppcheck_executable', 'cppcheck')
+call ale#Set('c_cppcheck_options', '--enable=style')
+
+function! ale_linters#c#cppcheck#GetCommand(buffer) abort
+    " Search upwards from the file for compile_commands.json.
+    "
+    " If we find it, we'll `cd` to where the compile_commands.json file is,
+    " then use the file to set up import paths, etc.
+    let l:compile_commmands_path = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    let l:cd_command = !empty(l:compile_commmands_path)
+    \   ? ale#path#CdString(fnamemodify(l:compile_commmands_path, ':h'))
+    \   : ''
+    let l:compile_commands_option = !empty(l:compile_commmands_path)
+    \   ? '--project=compile_commands.json '
+    \   : ''
+
+    return l:cd_command
+    \   . '%e -q --language=c '
+    \   . l:compile_commands_option
+    \   . ale#Var(a:buffer, 'c_cppcheck_options')
+    \   . ' %t'
+endfunction
+
+call ale#linter#Define('c', {
+\   'name': 'cppcheck',
+\   'output_stream': 'both',
+\   'executable': {b -> ale#Var(b, 'c_cppcheck_executable')},
+\   'command': function('ale_linters#c#cppcheck#GetCommand'),
+\   'callback': 'ale#handlers#cppcheck#HandleCppCheckFormat',
+\})
--- a/sources_non_forked/ale/ale_linters/c/cquery.vim
+++ b/sources_non_forked/ale/ale_linters/c/cquery.vim
@ -0,0 +1,28 @@
+" Author: Ben Falconer <ben@falconers.me.uk>, jtalowell <jtalowell@protonmail.com>
+" Description: A language server for C
+
+call ale#Set('c_cquery_executable', 'cquery')
+call ale#Set('c_cquery_cache_directory', expand('~/.cache/cquery'))
+
+function! ale_linters#c#cquery#GetProjectRoot(buffer) abort
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    if empty(l:project_root)
+        let l:project_root = ale#path#FindNearestFile(a:buffer, '.cquery')
+    endif
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
+endfunction
+
+function! ale_linters#c#cquery#GetInitializationOptions(buffer) abort
+    return {'cacheDirectory': ale#Var(a:buffer, 'c_cquery_cache_directory')}
+endfunction
+
+call ale#linter#Define('c', {
+\   'name': 'cquery',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'c_cquery_executable')},
+\   'command': '%e',
+\   'project_root': function('ale_linters#c#cquery#GetProjectRoot'),
+\   'initialization_options': function('ale_linters#c#cquery#GetInitializationOptions'),
+\})
--- a/sources_non_forked/ale/ale_linters/c/flawfinder.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/c/gcc.vim
+++ b/sources_non_forked/ale/ale_linters/c/gcc.vim
@ -0,0 +1,24 @@
+" 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.
+    return '%e -S -x c -fsyntax-only'
+    \   . ' -iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ale#Pad(l:cflags)
+    \   . ale#Pad(ale#Var(a:buffer, 'c_gcc_options')) . ' -'
+endfunction
+
+call ale#linter#Define('c', {
+\   'name': 'gcc',
+\   'output_stream': 'stderr',
+\   'executable': {b -> ale#Var(b, 'c_gcc_executable')},
+\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#c#gcc#GetCommand'))},
+\   'callback': 'ale#handlers#gcc#HandleGCCFormatWithIncludes',
+\})
--- a/sources_non_forked/ale/ale_linters/chef/cookstyle.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/chef/foodcritic.vim
+++ b/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,
+\})
--- a/sources_non_forked/ale/ale_linters/clojure/clj_kondo.vim
+++ b/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 --lint %t',
+\   'callback': 'ale_linters#clojure#clj_kondo#HandleCljKondoFormat',
+\})
--- a/sources_non_forked/ale/ale_linters/clojure/joker.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/cloudformation/cfn_python_lint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/cmake/cmakelint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/coffee/coffee.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/coffee/coffeelint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/cpp/ccls.vim
+++ b/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')},
+\})
--- a/sources_non_forked/ale/ale_linters/cpp/clang.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/cpp/clangcheck.vim
+++ b/sources_non_forked/ale/ale_linters/cpp/clangcheck.vim
@ -0,0 +1,34 @@
+" Author: gagbo <gagbobada@gmail.com>
+" Description: clang-check linter for cpp files
+
+call ale#Set('cpp_clangcheck_executable', 'clang-check')
+call ale#Set('cpp_clangcheck_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#cpp#clangcheck#GetCommand(buffer) abort
+    let l:user_options = ale#Var(a:buffer, 'cpp_clangcheck_options')
+
+    " Try to find compilation database to link automatically
+    let l:build_dir = ale#Var(a:buffer, 'c_build_dir')
+
+    if empty(l:build_dir)
+        let l:build_dir = ale#path#Dirname(ale#c#FindCompileCommands(a:buffer))
+    endif
+
+    " The extra arguments in the command are used to prevent .plist files from
+    " being generated. These are only added if no build directory can be
+    " detected.
+    return '%e -analyze %s'
+    \   . (empty(l:build_dir) ? ' -extra-arg -Xclang -extra-arg -analyzer-output=text' : '')
+    \   . ale#Pad(l:user_options)
+    \   . (!empty(l:build_dir) ? ' -p ' . ale#Escape(l:build_dir) : '')
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'clangcheck',
+\   'output_stream': 'stderr',
+\   'executable': {b -> ale#Var(b, 'cpp_clangcheck_executable')},
+\   'command': function('ale_linters#cpp#clangcheck#GetCommand'),
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})
--- a/sources_non_forked/ale/ale_linters/cpp/clangd.vim
+++ b/sources_non_forked/ale/ale_linters/cpp/clangd.vim
@ -0,0 +1,23 @@
+" Author: Andrey Melentyev <andrey.melentyev@protonmail.com>
+" Description: Clangd language server
+
+call ale#Set('cpp_clangd_executable', 'clangd')
+call ale#Set('cpp_clangd_options', '')
+
+function! ale_linters#cpp#clangd#GetProjectRoot(buffer) abort
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
+endfunction
+
+function! ale_linters#cpp#clangd#GetCommand(buffer) abort
+    return '%e' . ale#Pad(ale#Var(a:buffer, 'cpp_clangd_options'))
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'clangd',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'cpp_clangd_executable')},
+\   'command': function('ale_linters#cpp#clangd#GetCommand'),
+\   'project_root': function('ale_linters#cpp#clangd#GetProjectRoot'),
+\})
--- a/sources_non_forked/ale/ale_linters/cpp/clangtidy.vim
+++ b/sources_non_forked/ale/ale_linters/cpp/clangtidy.vim
@ -0,0 +1,36 @@
+" Author: vdeurzen <tim@kompiler.org>, w0rp <devw0rp@gmail.com>,
+" gagbo <gagbobada@gmail.com>
+" Description: clang-tidy linter for cpp files
+
+call ale#Set('cpp_clangtidy_executable', 'clang-tidy')
+" Set this option to check the checks clang-tidy will apply.
+call ale#Set('cpp_clangtidy_checks', [])
+" Set this option to manually set some options for clang-tidy.
+" This will disable compile_commands.json detection.
+call ale#Set('cpp_clangtidy_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#cpp#clangtidy#GetCommand(buffer) abort
+    let l:checks = join(ale#Var(a:buffer, 'cpp_clangtidy_checks'), ',')
+    let l:build_dir = ale#c#GetBuildDirectory(a:buffer)
+
+    " Get the extra options if we couldn't find a build directory.
+    let l:options = empty(l:build_dir)
+    \   ? ale#Var(a:buffer, 'cpp_clangtidy_options')
+    \   : ''
+
+    return '%e'
+    \   . (!empty(l:checks) ? ' -checks=' . ale#Escape(l:checks) : '')
+    \   . ' %s'
+    \   . (!empty(l:build_dir) ? ' -p ' . ale#Escape(l:build_dir) : '')
+    \   . (!empty(l:options) ? ' -- ' . l:options : '')
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'clangtidy',
+\   'output_stream': 'stdout',
+\   'executable': {b -> ale#Var(b, 'cpp_clangtidy_executable')},
+\   'command': function('ale_linters#cpp#clangtidy#GetCommand'),
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})
--- a/sources_non_forked/ale/ale_linters/cpp/clazy.vim
+++ b/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,
+\})
--- a/sources_non_forked/ale/ale_linters/cpp/cppcheck.vim
+++ b/sources_non_forked/ale/ale_linters/cpp/cppcheck.vim
@ -0,0 +1,34 @@
+" Author: Bart Libert <bart.libert@gmail.com>
+" Description: cppcheck linter for cpp files
+
+call ale#Set('cpp_cppcheck_executable', 'cppcheck')
+call ale#Set('cpp_cppcheck_options', '--enable=style')
+
+function! ale_linters#cpp#cppcheck#GetCommand(buffer) abort
+    " Search upwards from the file for compile_commands.json.
+    "
+    " If we find it, we'll `cd` to where the compile_commands.json file is,
+    " then use the file to set up import paths, etc.
+    let l:compile_commmands_path = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    let l:cd_command = !empty(l:compile_commmands_path)
+    \   ? ale#path#CdString(fnamemodify(l:compile_commmands_path, ':h'))
+    \   : ''
+    let l:compile_commands_option = !empty(l:compile_commmands_path)
+    \   ? '--project=compile_commands.json '
+    \   : ''
+
+    return l:cd_command
+    \   . '%e -q --language=c++ '
+    \   . l:compile_commands_option
+    \   . ale#Var(a:buffer, 'cpp_cppcheck_options')
+    \   . ' %t'
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'cppcheck',
+\   'output_stream': 'both',
+\   'executable': {b -> ale#Var(b, 'cpp_cppcheck_executable')},
+\   'command': function('ale_linters#cpp#cppcheck#GetCommand'),
+\   'callback': 'ale#handlers#cppcheck#HandleCppCheckFormat',
+\})
--- a/sources_non_forked/ale/ale_linters/cpp/cpplint.vim
+++ b/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,
+\})
--- a/sources_non_forked/ale/ale_linters/cpp/cquery.vim
+++ b/sources_non_forked/ale/ale_linters/cpp/cquery.vim
@ -0,0 +1,28 @@
+" Author: Ben Falconer <ben@falconers.me.uk>
+" Description: A language server for C++
+
+call ale#Set('cpp_cquery_executable', 'cquery')
+call ale#Set('cpp_cquery_cache_directory', expand('~/.cache/cquery'))
+
+function! ale_linters#cpp#cquery#GetProjectRoot(buffer) abort
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
+
+    if empty(l:project_root)
+        let l:project_root = ale#path#FindNearestFile(a:buffer, '.cquery')
+    endif
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
+endfunction
+
+function! ale_linters#cpp#cquery#GetInitializationOptions(buffer) abort
+    return {'cacheDirectory': ale#Var(a:buffer, 'cpp_cquery_cache_directory')}
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'cquery',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'cpp_cquery_executable')},
+\   'command': '%e',
+\   'project_root': function('ale_linters#cpp#cquery#GetProjectRoot'),
+\   'initialization_options': function('ale_linters#cpp#cquery#GetInitializationOptions'),
+\})
--- a/sources_non_forked/ale/ale_linters/cpp/flawfinder.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/cpp/gcc.vim
+++ b/sources_non_forked/ale/ale_linters/cpp/gcc.vim
@ -0,0 +1,25 @@
+" Author: geam <mdelage@student.42.fr>
+" Description: gcc linter for cpp files
+"
+call ale#Set('cpp_gcc_executable', 'gcc')
+call ale#Set('cpp_gcc_options', '-std=c++14 -Wall')
+
+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.
+    return '%e -S -x c++ -fsyntax-only'
+    \   . ' -iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
+    \   . ale#Pad(l:cflags)
+    \   . ale#Pad(ale#Var(a:buffer, 'cpp_gcc_options')) . ' -'
+endfunction
+
+call ale#linter#Define('cpp', {
+\   'name': 'gcc',
+\   'aliases': ['g++'],
+\   'output_stream': 'stderr',
+\   'executable': {b -> ale#Var(b, 'cpp_gcc_executable')},
+\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#cpp#gcc#GetCommand'))},
+\   'callback': 'ale#handlers#gcc#HandleGCCFormatWithIncludes',
+\})
--- a/sources_non_forked/ale/ale_linters/crystal/ameba.vim
+++ b/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,
+\})
--- a/sources_non_forked/ale/ale_linters/crystal/crystal.vim
+++ b/sources_non_forked/ale/ale_linters/crystal/crystal.vim
@ -0,0 +1,31 @@
+" Author: Jordan Andree <https://github.com/jordanandree>, David Alexander <opensource@thelonelyghost.com>
+" Description: This file adds support for checking Crystal with crystal build
+
+function! ale_linters#crystal#crystal#Handle(buffer, lines) abort
+    let l:output = []
+
+    for l:error in ale#util#FuzzyJSONDecode(a:lines, [])
+        call add(l:output, {
+        \   'lnum': l:error.line + 0,
+        \   'col': l:error.column + 0,
+        \   'text': l:error.message,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+function! ale_linters#crystal#crystal#GetCommand(buffer) abort
+    return 'crystal build -f json --no-codegen --no-color -o '
+    \   . ale#Escape(g:ale#util#nul_file)
+    \   . ' %s'
+endfunction
+
+call ale#linter#Define('crystal', {
+\   'name': 'crystal',
+\   'executable': 'crystal',
+\   'output_stream': 'both',
+\   'lint_file': 1,
+\   'command': function('ale_linters#crystal#crystal#GetCommand'),
+\   'callback': 'ale_linters#crystal#crystal#Handle',
+\})
--- a/sources_non_forked/ale/ale_linters/cs/mcs.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/cs/mcsc.vim
+++ b/sources_non_forked/ale/ale_linters/cs/mcsc.vim
@ -0,0 +1,81 @@
+call ale#Set('cs_mcsc_options', '')
+call ale#Set('cs_mcsc_source', '')
+call ale#Set('cs_mcsc_assembly_path', [])
+call ale#Set('cs_mcsc_assemblies', [])
+
+function! s:GetWorkingDirectory(buffer) abort
+    let l:working_directory = ale#Var(a:buffer, 'cs_mcsc_source')
+
+    if !empty(l:working_directory)
+        return l:working_directory
+    endif
+
+    return expand('#' . a:buffer . ':p:h')
+endfunction
+
+function! ale_linters#cs#mcsc#GetCommand(buffer) abort
+    " Pass assembly paths via the -lib: parameter.
+    let l:path_list = ale#Var(a:buffer, 'cs_mcsc_assembly_path')
+
+    let l:lib_option = !empty(l:path_list)
+    \   ? '-lib:' . join(map(copy(l:path_list), 'ale#Escape(v:val)'), ',')
+    \   : ''
+
+    " Pass paths to DLL files via the -r: parameter.
+    let l:assembly_list = ale#Var(a:buffer, 'cs_mcsc_assemblies')
+
+    let l:r_option = !empty(l:assembly_list)
+    \   ? '-r:' . join(map(copy(l:assembly_list), 'ale#Escape(v:val)'), ',')
+    \   : ''
+
+    " register temporary module target file with ale
+    " register temporary module target file with ALE.
+    let l:out = ale#command#CreateFile(a:buffer)
+
+    " The code is compiled as a module and the output is redirected to a
+    " temporary file.
+    return ale#path#CdString(s:GetWorkingDirectory(a:buffer))
+    \    . 'mcs -unsafe'
+    \    . ale#Pad(ale#Var(a:buffer, 'cs_mcsc_options'))
+    \    . ale#Pad(l:lib_option)
+    \    . ale#Pad(l:r_option)
+    \    . ' -out:' . l:out
+    \    . ' -t:module'
+    \    . ' -recurse:' . ale#Escape('*.cs')
+endfunction
+
+function! ale_linters#cs#mcsc#Handle(buffer, lines) abort
+    " Look for lines like the following.
+    "
+    " Tests.cs(12,29): error CSXXXX: ; expected
+    "
+    " NOTE: pattern also captures file name as linter compiles all
+    " files within the source tree rooted at the specified source
+    " path and not just the file loaded in the buffer
+    let l:pattern = '^\v(.+\.cs)\((\d+),(\d+)\)\: ([^ ]+) ([^ ]+): (.+)$'
+    let l:output = []
+
+    let l:dir = s:GetWorkingDirectory(a:buffer)
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'type': l:match[4] is# 'error' ? 'E' : 'W',
+        \   'code': l:match[5],
+        \   'text': l:match[6],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('cs',{
+\   'name': 'mcsc',
+\   'output_stream': 'stderr',
+\   'executable': 'mcs',
+\   'command': function('ale_linters#cs#mcsc#GetCommand'),
+\   'callback': 'ale_linters#cs#mcsc#Handle',
+\   'lint_file': 1
+\})
--- a/sources_non_forked/ale/ale_linters/css/csslint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/css/fecs.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/css/stylelint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/cucumber/cucumber.vim
+++ b/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'
+\})
--- a/sources_non_forked/ale/ale_linters/cuda/nvcc.vim
+++ b/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,
+\})
--- a/sources_non_forked/ale/ale_linters/cypher/cypher_lint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/d/dls.vim
+++ b/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'),
+\})
--- a/sources_non_forked/ale/ale_linters/d/dmd.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/dafny/dafny.vim
+++ b/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,
+\ })
--- a/sources_non_forked/ale/ale_linters/dart/dartanalyzer.vim
+++ b/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,
+\})
--- a/sources_non_forked/ale/ale_linters/dart/language_server.vim
+++ b/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'),
+\})
--- a/sources_non_forked/ale/ale_linters/dockerfile/dockerfile_lint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/dockerfile/hadolint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/elixir/credo.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/elixir/dialyxir.vim
+++ b/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',
+\})
+
--- a/sources_non_forked/ale/ale_linters/elixir/dogma.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/elixir/elixir_ls.vim
+++ b/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')},
+\})
--- a/sources_non_forked/ale/ale_linters/elixir/mix.vim
+++ b/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,
+\})
--- a/sources_non_forked/ale/ale_linters/elm/elm_lsp.vim
+++ b/sources_non_forked/ale/ale_linters/elm/elm_lsp.vim
@ -0,0 +1,22 @@
+" Author: antew - https://github.com/antew
+" Description: LSP integration for elm, currently supports diagnostics (linting)
+
+call ale#Set('elm_lsp_executable', 'elm-lsp')
+call ale#Set('elm_lsp_use_global', get(g:, 'ale_use_global_executables', 0))
+
+function! elm_lsp#GetRootDir(buffer) abort
+    let l:elm_json = ale#path#FindNearestFile(a:buffer, 'elm.json')
+
+    return !empty(l:elm_json) ? fnamemodify(l:elm_json, ':p:h') : ''
+endfunction
+
+call ale#linter#Define('elm', {
+\   'name': 'elm_lsp',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#node#FindExecutable(b, 'elm_lsp', [
+\       'node_modules/.bin/elm-lsp',
+\   ])},
+\   'command': '%e --stdio',
+\   'project_root': function('elm_lsp#GetRootDir'),
+\   'language': 'elm'
+\})
--- a/sources_non_forked/ale/ale_linters/elm/make.vim
+++ b/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'
+\})
--- a/sources_non_forked/ale/ale_linters/erlang/erlc.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/erlang/syntaxerl.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/eruby/erb.vim
+++ b/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',
+\})
+
--- a/sources_non_forked/ale/ale_linters/eruby/erubi.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/eruby/erubis.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/eruby/ruumba.vim
+++ b/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#handlers#ruby#EscapeExecutable(l:executable, 'ruumba')
+    \   . ' --format json --force-exclusion '
+    \   . ale#Var(a:buffer, 'eruby_ruumba_options')
+    \   . ' --stdin ' . ale#Escape(expand('#' . a:buffer . ':p'))
+endfunction
+
+function! ale_linters#eruby#ruumba#Handle(buffer, lines) abort
+    try
+        let l:errors = json_decode(a:lines[0])
+    catch
+        return []
+    endtry
+
+    if !has_key(l:errors, 'summary')
+    \|| l:errors['summary']['offense_count'] == 0
+    \|| empty(l:errors['files'])
+        return []
+    endif
+
+    let l:output = []
+
+    for l:error in l:errors['files'][0]['offenses']
+        let l:start_col = l:error['location']['column'] + 0
+        call add(l:output, {
+        \   'lnum': l:error['location']['line'] + 0,
+        \   'col': l:start_col,
+        \   'end_col': l:start_col + l:error['location']['length'] - 1,
+        \   'code': l:error['cop_name'],
+        \   'text': l:error['message'],
+        \   'type': ale_linters#eruby#ruumba#GetType(l:error['severity']),
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+function! ale_linters#eruby#ruumba#GetType(severity) abort
+    if a:severity is? 'convention'
+    \|| a:severity is? 'warning'
+    \|| a:severity is? 'refactor'
+        return 'W'
+    endif
+
+    return 'E'
+endfunction
+
+call ale#linter#Define('eruby', {
+\   'name': 'ruumba',
+\   'executable': {b -> ale#Var(b, 'eruby_ruumba_executable')},
+\   'command': function('ale_linters#eruby#ruumba#GetCommand'),
+\   'callback': 'ale_linters#eruby#ruumba#Handle',
+\})
--- a/sources_non_forked/ale/ale_linters/fish/fish.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/fortran/gcc.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/fortran/language_server.vim
+++ b/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'),
+\})
--- a/sources_non_forked/ale/ale_linters/fountain/proselint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/fuse/fusionlint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/gitcommit/gitlint.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/glsl/glslang.vim
+++ b/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',
+\})
--- a/sources_non_forked/ale/ale_linters/glsl/glslls.vim
+++ b/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'),
+\})
--- a/sources_non_forked/ale/ale_linters/go/bingo.vim
+++ b/sources_non_forked/ale/ale_linters/go/bingo.vim
@ -0,0 +1,29 @@
+" Author: Jerko Steiner <https://github.com/jeremija>
+" Description: https://github.com/saibing/bingo
+
+call ale#Set('go_bingo_executable', 'bingo')
+call ale#Set('go_bingo_options', '--mode stdio')
+
+function! ale_linters#go#bingo#GetCommand(buffer) abort
+    return '%e' . ale#Pad(ale#Var(a:buffer, 'go_bingo_options'))
+endfunction
+
+function! ale_linters#go#bingo#FindProjectRoot(buffer) abort
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'go.mod')
+    let l:mods = ':h'
+
+    if empty(l:project_root)
+        let l:project_root = ale#path#FindNearestDirectory(a:buffer, '.git')
+        let l:mods = ':h:h'
+    endif
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, l:mods) : ''
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'bingo',
+\   'lsp': 'stdio',
+\   'executable': {b -> ale#Var(b, 'go_bingo_executable')},
+\   'command': function('ale_linters#go#bingo#GetCommand'),
+\   'project_root': function('ale_linters#go#bingo#FindProjectRoot'),
+\})
--- a/sources_non_forked/ale/ale_linters/go/gobuild.vim
+++ b/sources_non_forked/ale/ale_linters/go/gobuild.vim
@ -0,0 +1,56 @@
+" Author: Joshua Rubin <joshua@rubixconsulting.com>, Ben Reedy <https://github.com/breed808>,
+" Jeff Willette <jrwillette88@gmail.com>
+" Description: go build for Go files
+" inspired by work from dzhou121 <dzhou121@gmail.com>
+
+call ale#Set('go_go_executable', 'go')
+call ale#Set('go_gobuild_options', '')
+
+function! ale_linters#go#gobuild#GetCommand(buffer) abort
+    let l:options = ale#Var(a:buffer, 'go_gobuild_options')
+
+    " Run go test in local directory with relative path
+    return ale#path#BufferCdString(a:buffer)
+    \   . ale#Var(a:buffer, 'go_go_executable') . ' test'
+    \   . (!empty(l:options) ? ' ' . l:options : '')
+    \   . ' -c -o /dev/null ./'
+endfunction
+
+function! ale_linters#go#gobuild#GetMatches(lines) abort
+    " Matches patterns like the following:
+    "
+    " file.go:27: missing argument for Printf("%s"): format reads arg 2, have only 1 args
+    " file.go:53:10: if block ends with a return statement, so drop this else and outdent its block (move short variable declaration to its own line if necessary)
+    " file.go:5:2: expected declaration, found 'STRING' "log"
+    " go test returns relative paths so use tail of filename as part of pattern matcher
+    let l:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+):?(\d+)?:? (.+)$'
+
+    return ale#util#GetMatches(a:lines, l:pattern)
+endfunction
+
+function! ale_linters#go#gobuild#Handler(buffer, lines) abort
+    let l:dir = expand('#' . a:buffer . ':p:h')
+    let l:output = []
+
+    for l:match in ale_linters#go#gobuild#GetMatches(a:lines)
+        call add(l:output, {
+        \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'text': l:match[4],
+        \   'type': 'E',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'gobuild',
+\   'aliases': ['go build'],
+\   'executable': {b -> ale#Var(b, 'go_go_executable')},
+\   'command': function('ale_linters#go#gobuild#GetCommand'),
+\   'output_stream': 'stderr',
+\   'callback': 'ale_linters#go#gobuild#Handler',
+\   'lint_file': 1,
+\})
--- a/sources_non_forked/ale/ale_linters/go/gofmt.vim
+++ b/sources_non_forked/ale/ale_linters/go/gofmt.vim
@ -0,0 +1,10 @@
+" Author: neersighted <bjorn@neersighted.com>
+" Description: gofmt for Go files
+
+call ale#linter#Define('go', {
+\   'name': 'gofmt',
+\   'output_stream': 'stderr',
+\   'executable': 'gofmt',
+\   'command': 'gofmt -e %t',
+\   'callback': 'ale#handlers#unix#HandleAsError',
+\})
--- a/sources_non_forked/ale/ale_linters/go/golangci_lint.vim
+++ b/sources_non_forked/ale/ale_linters/go/golangci_lint.vim
@ -0,0 +1,56 @@
+" Author: Sascha Grunert <mail@saschagrunert.de>
+" Description: Adds support of golangci-lint
+
+call ale#Set('go_golangci_lint_options', '--enable-all')
+call ale#Set('go_golangci_lint_executable', 'golangci-lint')
+call ale#Set('go_golangci_lint_package', 0)
+
+function! ale_linters#go#golangci_lint#GetCommand(buffer) abort
+    let l:filename = expand('#' . a:buffer . ':t')
+    let l:options = ale#Var(a:buffer, 'go_golangci_lint_options')
+    let l:lint_package = ale#Var(a:buffer, 'go_golangci_lint_package')
+
+    if l:lint_package
+        return ale#path#BufferCdString(a:buffer)
+        \   . '%e run '
+        \   .  l:options
+    endif
+
+    return ale#path#BufferCdString(a:buffer)
+    \   . '%e run '
+    \   . ale#Escape(l:filename)
+    \   . ' ' . l:options
+endfunction
+
+function! ale_linters#go#golangci_lint#GetMatches(lines) abort
+    let l:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+):?(\d+)?:?:?:?\s\*?(.+)$'
+
+    return ale#util#GetMatches(a:lines, l:pattern)
+endfunction
+
+function! ale_linters#go#golangci_lint#Handler(buffer, lines) abort
+    let l:dir = expand('#' . a:buffer . ':p:h')
+    let l:output = []
+
+    for l:match in ale_linters#go#golangci_lint#GetMatches(a:lines)
+        " l:match[1] will already be an absolute path, output from
+        " golangci_lint
+        call add(l:output, {
+        \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'type': 'E',
+        \   'text': l:match[4],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'golangci-lint',
+\   'executable': {b -> ale#Var(b, 'go_golangci_lint_executable')},
+\   'command': function('ale_linters#go#golangci_lint#GetCommand'),
+\   'callback': 'ale_linters#go#golangci_lint#Handler',
+\   'lint_file': 1,
+\})
--- a/sources_non_forked/ale/ale_linters/go/golint.vim
+++ b/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 '%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',
+\})
--- a/sources_non_forked/ale/ale_linters/go/gometalinter.vim
+++ b/sources_non_forked/ale/ale_linters/go/gometalinter.vim
@ -0,0 +1,57 @@
+" Author: Ben Reedy <https://github.com/breed808>, Jeff Willette <jrwillette88@gmail.com>
+" Description: Adds support for the gometalinter suite for Go files
+
+call ale#Set('go_gometalinter_options', '')
+call ale#Set('go_gometalinter_executable', 'gometalinter')
+call ale#Set('go_gometalinter_lint_package', 0)
+
+function! ale_linters#go#gometalinter#GetCommand(buffer) abort
+    let l:filename = expand('#' . a:buffer . ':t')
+    let l:options = ale#Var(a:buffer, 'go_gometalinter_options')
+    let l:lint_package = ale#Var(a:buffer, 'go_gometalinter_lint_package')
+
+    " BufferCdString is used so that we can be sure the paths output from gometalinter can
+    " be calculated to absolute paths in the Handler
+    if l:lint_package
+        return ale#path#BufferCdString(a:buffer)
+        \   . '%e'
+        \   . (!empty(l:options) ? ' ' . l:options : '') . ' .'
+    endif
+
+    return ale#path#BufferCdString(a:buffer)
+    \   . '%e'
+    \   . ' --include=' . ale#Escape(ale#util#EscapePCRE(l:filename))
+    \   . (!empty(l:options) ? ' ' . l:options : '') . ' .'
+endfunction
+
+function! ale_linters#go#gometalinter#GetMatches(lines) abort
+    let l:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+):?(\d+)?:?:?(warning|error):?\s\*?(.+)$'
+
+    return ale#util#GetMatches(a:lines, l:pattern)
+endfunction
+
+function! ale_linters#go#gometalinter#Handler(buffer, lines) abort
+    let l:dir = expand('#' . a:buffer . ':p:h')
+    let l:output = []
+
+    for l:match in ale_linters#go#gometalinter#GetMatches(a:lines)
+        " l:match[1] will already be an absolute path, output from gometalinter
+        call add(l:output, {
+        \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'type': tolower(l:match[4]) is# 'warning' ? 'W' : 'E',
+        \   'text': l:match[5],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'gometalinter',
+\   'executable': {b -> ale#Var(b, 'go_gometalinter_executable')},
+\   'command': function('ale_linters#go#gometalinter#GetCommand'),
+\   'callback': 'ale_linters#go#gometalinter#Handler',
+\   'lint_file': 1,
+\})
--- a/sources_non_forked/ale/ale_linters/go/gopls.vim
+++ b/sources_non_forked/ale/ale_linters/go/gopls.vim
@ -0,0 +1,30 @@
+" 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 '%e' . ale#Pad(ale#Var(a:buffer, 'go_gopls_options'))
+endfunction
+
+function! ale_linters#go#gopls#FindProjectRoot(buffer) abort
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'go.mod')
+    let l:mods = ':h'
+
+    if empty(l:project_root)
+        let l:project_root = ale#path#FindNearestDirectory(a:buffer, '.git')
+        let l:mods = ':h:h'
+    endif
+
+    return !empty(l:project_root) ? fnamemodify(l:project_root, l:mods) : ''
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': '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'),
+\})
--- a/sources_non_forked/ale/ale_linters/go/gosimple.vim
+++ b/sources_non_forked/ale/ale_linters/go/gosimple.vim
@ -0,0 +1,15 @@
+" Author: Ben Reedy <https://github.com/breed808>
+" Description: gosimple for Go files
+
+function! ale_linters#go#gosimple#GetCommand(buffer) abort
+    return ale#path#BufferCdString(a:buffer) . ' gosimple .'
+endfunction
+
+call ale#linter#Define('go', {
+\   'name': 'gosimple',
+\   'executable': 'gosimple',
+\   'command': function('ale_linters#go#gosimple#GetCommand'),
+\   'callback': 'ale#handlers#go#Handler',
+\   'output_stream': 'both',
+\   'lint_file': 1,
+\})
--- a/Show More
+++ b/Show More