Resolve syntax highlighting group in neovim/treesitter (#160)

Co-authored-by: Junegunn Choi <junegunn.c@gmail.com>

DEMO.md

@@ -1,91 +0,0 @@
-# vim: set buftype=nofile colorcolumn= scrolloff=0 noshowcmd:
-
-vim-easy-align
-==============
-
-Where's Lennon?
----------------
-
-Paul McCartney 1942
-George Harrison 1943
-Ringo Starr 1940
-Pete Best 1941
-
-
-Formatting table
-----------------
-```
-
-| Option| Type | Default | Description |
-|--|--|--|--|
-| threads | Fixnum | 1 | number of threads in the thread pool |
-|queues |Fixnum | 1 | number of concurrent queues |
-|queue_size | Fixnum | 1000 | size of each queue |
-|   interval | Numeric | 0 | dispatcher interval for processing |
-|batch | Boolean | false | enables batch processing mode |
- |batch_size | Fixnum | nil | maximum number of items in batch|
- |logger | Logger | nil | logger instance for debug logs |
-
-```
-Operators with = sign
----------------------
-```ruby
-
-a =
-a = 1
-bbbb = 2
-ccccccc = 3
-ccccccccccccccc
-ddd = 4
-eeee === eee = eee = eee=f
-fff = ggg += gg &&= gg
-g != hhhhhhhh == 888
-i   := 5
-i     %= 5
-i       *= 5
-j     =~ 5
-j   >= 5
-aa      =>         123
-aa <<= 123
-aa        >>= 123
-bbb               => 123
-c     => 1233123
-d   =>      123
-dddddd &&= 123
-dddddd ||= 123
-dddddd /= 123
-gg <=> ee
-
-```
-Formatting YAML (or JSON)
--------------------------
-```yaml
-
-mysql:
-  # JDBC driver for MySQL database:
-  driver: com.mysql.jdbc.Driver
-  # JDBC URL for the connection (jdbc:mysql://HOSTNAME/DATABASE)
-  url: jdbc:mysql://localhost/test
-  database: test
-  "user:pass":r00t:pa55
-
-```
-Using blockwise-visual mode or negative N-th parameter
-------------------------------------------------------
-```ruby
-
-options = { :caching => nil,
-            :versions => 3,
-            "cache=blocks" => false }.merge(options)
-
-```
-Commas
-------
-
-aaa,   bb,c
-d,eeeeeee
-fffff, gggggggggg,
-h, ,           ii
-j,,k
-
-

EXAMPLES.md

@@ -1,18 +1,23 @@
-vim-easy-align examples
-=======================
+easy-align examples
+===================
 
 Open this document in your Vim and try it yourself.
 
-This document assumes that you have defined the following mappings.
+This document assumes that you have the following mappings in your .vimrc.
 
 ```vim
-" Start interactive EasyAlign in visual mode (e.g. vip<Enter>)
-vmap <Enter> <Plug>(EasyAlign)
+" Start interactive EasyAlign in visual mode (e.g. vipga)
+xmap ga <Plug>(EasyAlign)
 
-" Start interactive EasyAlign for a motion/text object (e.g. <Leader>aip)
-nmap <Leader>a <Plug>(EasyAlign)
+" Start interactive EasyAlign for a motion/text object (e.g. gaip)
+nmap ga <Plug>(EasyAlign)
 ```
 
+You can use either of the maps. Place the cursor on the paragraph and press
+
+- `gaip` "(ga) start easy-align on (i)nner (p)aragraph"
+- or `vipga` "(v)isual-select (i)nner (p)aragraph and (ga) start easy-align"
+
 To enable syntax highlighting in the code blocks, define and call the following
 function.
 
@@ -37,15 +42,17 @@ Alignment around whitespaces
 
 You can align text around whitespaces with `<space>` delimiter key.
 
-Try these commands:
+Start the interactive mode as described above (`gaip` or `vipga`) and try
+these commands:
+
+- `<space>`
+- `2<space>`
+- `*<space>`
+- `-<space>`
+- `-2<space>`
 - `<Enter><space>`
-- `<Enter>2<space>`
 - `<Enter>*<space>`
-- `<Enter>-<space>`
-- `<Enter>-2<space>`
-- `<Enter><Enter><space>`
 - `<Enter><Enter>*<space>`
-- `<Enter><Enter><Enter>*<space>`
 
 ### Example
 
@@ -61,12 +68,13 @@ Pete Best 1941
 Formatting table
 ----------------
 
-Try these commands:
+Again, start the interactive mode and try these commands:
+
+- `*|`
+- `**|`
 - `<Enter>*|`
 - `<Enter>**|`
 - `<Enter><Enter>*|`
-- `<Enter><Enter>**|`
-- `<Enter><Enter><Enter>*|`
 
 ### Example
 
@@ -88,15 +96,16 @@ Try these commands:
 Alignment around =
 ------------------
 
-The default rule for delimiter key `=` aligns around a whole family of operators
-containing `=` character.
+The default rule for delimiter key `=` aligns around a whole family of
+operators containing `=` character.
 
-Try these commands:
-- `<Enter>=`
-- `<Enter>*=`
+Try these commands in the interactive mode.
+
+- `=`
+- `*=`
+- `**=`
 - `<Enter>**=`
-- `<Enter><Enter>**=`
-- `<Enter><Enter><Enter>*=`
+- `<Enter><Enter>*=`
 
 ### Example
 
@@ -132,8 +141,8 @@ gg <=> ee
 Formatting YAML (or JSON)
 -------------------------
 
-Try `<Enter>:` here, to align text around only the first occurrences of colons.
-In this case, you don't want to align around all the colons: `<Enter>*:`.
+You can use `:`-rule here to align text around only the first occurrences of
+colons. In this case, you don't want to align around all the colons: `*:`.
 
 ```yaml
 mysql:
@@ -148,7 +157,7 @@ mysql:
 Formatting multi-line method chaining
 -------------------------------------
 
-Try `<Enter>.` or `<Enter>*.` on the following lines.
+Try `.` or `*.` on the following lines.
 
 ```ruby
 my_object
@@ -174,8 +183,8 @@ Using blockwise-visual mode or negative N-th parameter
 ------------------------------------------------------
 
 You can try either:
-- select text around `=>` in blockwise-visual mode (`CTRL-V`) and `<Enter>=`
-- or `<Enter>-=`
+- select text around `=>` in blockwise-visual mode (`CTRL-V`) and `ga=`
+- or `gaip-=`
 
 ```ruby
 options = { :caching => nil,
@@ -186,8 +195,7 @@ options = { :caching => nil,
 Commas
 ------
 
-There is also a predefined rule for commas, try `<Enter>*,` on the following
-lines.
+There is also a predefined rule for commas, try `*,`.
 
 ```
 aaa,   bb,c
@@ -201,7 +209,7 @@ Ignoring delimiters in comments or strings
 ------------------------------------------
 
 Delimiters highlighted as comments or strings are ignored by default, try
-`<Enter>*=` on the following lines.
+`gaip*=` on the following lines.
 
 ```c
 
@@ -226,9 +234,9 @@ apple = 1 # comment not aligned
 banana = 'Gros Michel' # comment 2
 ```
 
-So, how do we align the trailing comments in the above lines?
-Simply try `<Enter>-<space>`. The spaces in the comments are ignored, so the
-trailing comment in each line is considered to be a single chunk.
+So, how do we align the trailing comments in the above lines? Simply try
+`-<space>`. The spaces in the comments are ignored, so the trailing comment in
+each line is considered to be a single chunk.
 
 But that doesn't work in the following case.
 
@@ -253,7 +261,7 @@ let g:easy_align_delimiters['#'] = { 'pattern': '#', 'ignore_groups': ['String']
 Notice that the rule overrides `ignore_groups` attribute in order *not to ignore*
 delimiters highlighted as comments.
 
-Then on `<Enter>#`, we get
+Then on `#`, we get
 
 ```ruby
 apple = 1         # comment not aligned
@@ -266,13 +274,16 @@ command:
 
 ```vim
 " Using regular expression /#/
-" - "is" is fuzzy-matched to "*i*gnore*s*"
-:EasyAlign/#/{'is':['String']}
+" - "ig" is a shorthand notation of "ignore_groups"
+:EasyAlign/#/{'ig':['String']}
+
+" Or more concisely with the shorthand notation;
+:EasyAlign/#/ig['String']
 ```
 
-In this case, the second line is ignored as it doesn't contain a `#`. (The one
-highlighted as String is ignored.) If you don't want the second line to be
-ignored, there are three options:
+In this case, the second line is ignored as it doesn't contain a `#` (The one
+in `'F#AD'` is ignored as it's highlighted as String). If you don't want the
+second line to be ignored, there are three options:
 
 1. Set global `g:easy_align_ignore_unmatched` flag to 0
 2. Use `:EasyAlign` command with `ignore_unmatched` option
@@ -284,11 +295,13 @@ let g:easy_align_ignore_unmatched = 0
 
 " 2. Using :EasyAlign command with ignore_unmatched option
 " 2-1. Using predefined rule with delimiter key #
-"      - "iu" is fuzzy-matched to "*i*gnore_*u*nmatched"
+"      - "iu" is expanded to "*i*gnore_*u*nmatched"
 :EasyAlign#{'iu':0}
+" or
+:EasyAlign#iu0
 
 " 2-2. Using regular expression /#/
-:EasyAlign/#/{'is':['String'],'iu':0}
+:EasyAlign/#/ig['String']iu0
 
 " 3. Update the alignment rule with ignore_unmatched option
 let g:easy_align_delimiters['#'] = {
@@ -315,7 +328,7 @@ static double pi = 3.14;
 ```
 
 We can align these lines with the predefined `=` rule. Select the lines and
-press `<Enter>=`
+press `ga=`
 
 ```c
 const char* str  = "Hello";
@@ -325,7 +338,7 @@ static double pi = 3.14;
 
 Not bad. However, the names of the variables, `str`, `count`, and `pi` are not
 aligned with each other. Can we do better? We can clearly see that simple
-`<Enter><space>` won't properly align those names.
+`<space>`-rule won't properly align those names.
 So let's define an alignment rule than can handle this case.
 
 ```vim
@@ -336,7 +349,7 @@ let g:easy_align_delimiters['d'] = {
 ```
 
 This new rule aligns text around spaces that are *not* preceded by
-`const` or `static`. Let's try it with `<Enter>d`.
+`const` or `static`. Let's select the lines and try `gad`.
 
 ```c
 const char*   str = "Hello";
@@ -345,7 +358,7 @@ static double pi = 3.14;
 ```
 
 Okay, the names are now aligned. We select the lines again with `gv`, and then
-press `<Enter>=` to finish our alignment.
+press `ga=` to finish our alignment.
 
 ```c
 const char*   str   = "Hello";
@@ -376,14 +389,14 @@ So what do we do? Let's try to improve our alignment rule.
 
 ```vim
 let g:easy_align_delimiters['d'] = {
-\ 'pattern': ' \(\S\+\s*[;=]\)\@=',
+\ 'pattern': ' \ze\S\+\s*[;=]',
 \ 'left_margin': 0, 'right_margin': 0
 \ }
 ```
 
 Now the new rule has changed to align text around spaces that are followed
 by some non-whitespace characters and then an equals sign or a semi-colon.
-Try `<Enter>d`
+Try `vipgad`
 
 ```c
 const char*                          str = "Hello";
@@ -392,7 +405,7 @@ static double                        pi = 3.14;
 static std::map<std::string, float>* scores = pointer;
 ```
 
-We're right on track, now press `gv<Enter>=` and voila!
+We're right on track, now press `gvga=` and voila!
 
 ```c
 const char*                          str    = "Hello";

README.md

@@ -3,29 +3,12 @@ vim-easy-align ![travis-ci](https://travis-ci.org/junegunn/vim-easy-align.svg?br
 
 A simple, easy-to-use Vim alignment plugin.
 
-Demo
-----
-
-<img src="https://raw.githubusercontent.com/junegunn/i/master/vim-easy-align.gif" height="494" alt="Screencast">
-
-(Too fast? Slower GIF is [here](https://raw.githubusercontent.com/junegunn/i/master/vim-easy-align-slow.gif))
-
-Features
---------
-
-- Easy to use
-  - Comes with a predefined set of alignment rules
-  - Provides a fast and intuitive interface
-- Extensible
-  - You can define your own rules
-  - Supports arbitrary regular expressions
-- Optimized for code editing
-  - Takes advantage of syntax highlighting feature to avoid unwanted alignments
+![](https://raw.githubusercontent.com/junegunn/i/master/easy-align/equals.gif)
 
 Installation
 ------------
 
-User your favorite plugin manager.
+Use your favorite plugin manager.
 
 Using [vim-plug](https://github.com/junegunn/vim-plug):
 
@@ -33,20 +16,20 @@ Using [vim-plug](https://github.com/junegunn/vim-plug):
 Plug 'junegunn/vim-easy-align'
 ```
 
-TL;DR - One-minute guide
-------------------------
+Quick start guide
+-----------------
 
 Add the following mappings to your .vimrc.
 
 ```vim
-" Start interactive EasyAlign in visual mode (e.g. vip<Enter>)
-vmap <Enter> <Plug>(EasyAlign)
+" Start interactive EasyAlign in visual mode (e.g. vipga)
+xmap ga <Plug>(EasyAlign)
 
 " Start interactive EasyAlign for a motion/text object (e.g. gaip)
 nmap ga <Plug>(EasyAlign)
 ```
 
-And with the following lines of text,
+Then with the following lines of text,
 
 ```
 apple   =red
@@ -56,80 +39,110 @@ sky-=   blue
 
 try these commands:
 
-- `vip<Enter>=`
+- `vipga=`
     - `v`isual-select `i`nner `p`aragraph
-    - Start EasyAlign command (`<Enter>`)
+    - Start EasyAlign command (`ga`)
     - Align around `=`
 - `gaip=`
     - Start EasyAlign command (`ga`) for `i`nner `p`aragraph
     - Align around `=`
 
-Notice that the commands are repeatable with `.` key if you have installed
-[repeat.vim](https://github.com/tpope/vim-repeat). Install
-[visualrepeat](https://github.com/vim-scripts/visualrepeat) as well if you want
-to repeat in visual mode.
+Demo
+----
+
+*Click on each image to see from the beginning.*
+
+### Using predefined alignment rules
+
+An *alignment rule* is a predefined set of options for common alignment tasks,
+which is identified by a single character, such as `<Space>`, `=`, `:`, `.`,
+`|`, `&`, `#`, and `,`.
+
+#### `=`
+
+![](https://raw.githubusercontent.com/junegunn/i/master/easy-align/equals.gif)
+
+- `=` Around the 1st occurrences
+- `2=` Around the 2nd occurrences
+- `*=` Around all occurrences
+- `**=` Left/Right alternating alignment around all occurrences
+- `<Enter>` Switching between left/right/center alignment modes
+
+#### `<Space>`
+
+![](https://raw.githubusercontent.com/junegunn/i/master/easy-align/spaces.gif)
+
+- `<Space>` Around the 1st occurrences of whitespaces
+- `2<Space>` Around the 2nd occurrences
+- `-<Space>` Around the last occurrences
+- `<Enter><Enter>2<Space>` Center-alignment around the 2nd occurrences
+
+#### `,`
+
+![](https://raw.githubusercontent.com/junegunn/i/master/easy-align/commas.gif)
+
+- The predefined comma-rule places a comma right next to the preceding token
+  without margin (`{'stick_to_left': 1, 'left_margin': 0}`)
+- You can change it with `<Right>` arrow
+
+### Using regular expression
+
+![](https://raw.githubusercontent.com/junegunn/i/master/easy-align/regex.gif)
+
+You can use an arbitrary regular expression by
+- pressing `<Ctrl-X>` in interactive mode
+- or using `:EasyAlign /REGEX/` command in visual mode or in normal mode with
+  a range (e.g. `:%`)
+
+### Different ways to start
+
+![](https://raw.githubusercontent.com/junegunn/i/master/easy-align/modes.gif)
+
+This demo shows how you can start interactive mode with visual selection or use
+non-interactive `:EasyAlign` command.
+
+### Aligning table cells
+
+![](https://raw.githubusercontent.com/junegunn/i/master/easy-align/tables.gif)
+
+Check out various alignment options and "live interactive mode".
+
+### Syntax-aware alignment
+
+![](https://raw.githubusercontent.com/junegunn/i/master/easy-align/yaml.gif)
+
+Delimiters in strings and comments are ignored by default.
+
+### Using blockwise-visual mode
+
+![](https://raw.githubusercontent.com/junegunn/i/master/easy-align/blockwise-visual.gif)
+
+You can limit the scope with blockwise-visual mode.
 
 Usage
 -----
 
-### Concept of _alignment rule_
+### Flow of execution
 
-Though easy-align can align lines of text around any delimiter, it provides
-shortcuts for the most common use cases with the concept of "_alignment rule_".
-
-An *alignment rule* is a predefined set of options for common alignment tasks,
-which is identified by a single character, *DELIMITER KEY*, such as `<Space>`,
-`=`, `:`, `.`, `|`, `&`, `#`, and `,`.
-
-Think of it as a shortcut. Instead of writing regular expression and setting
-several options, you can just type in a single character.
-
-### Execution models
+<img src="https://raw.githubusercontent.com/junegunn/i/master/easy-align/usage.png" width="469">
 
 There are two ways to use easy-align.
 
-#### 1. Using `<Plug>` mappings
+#### 1. `<Plug>` mappings (interactive mode)
 
-The recommended method is to use `<Plug>` mappings as described earlier.
-
-| Mapping                 | Mode   | Description                                          |
-| ----------------------- | ------ | ---------------------------------------------------- |
-| `<Plug>(EasyAlign)`     | normal | Start interactive mode for a motion/text object      |
-| `<Plug>(EasyAlign)`     | visual | Start interactive mode for the selection             |
-| `<Plug>(LiveEasyAlign)` | normal | Start live-interactive mode for a motion/text object |
-| `<Plug>(LiveEasyAlign)` | visual | Start live-interactive mode for the selection        |
-
-#### 2. Using `:EasyAlign` command
-
-If you prefer command-line or do not want to start interactive mode, you can use
-`:EasyAlign` command instead.
-
-| Mode                                       | Command                                          |
-| ------------------------------------------ | ------------------------------------------------ |
-| Interactive mode                           | `:EasyAlign[!] [OPTIONS]`                        |
-| Live interactive mode                      | `:LiveEasyAlign[!] [...]`                        |
-| Non-interactive mode (predefined rules)    | `:EasyAlign[!] [N-th] DELIMITER_KEY [OPTIONS]`   |
-| Non-interactive mode (regular expressions) | `:EasyAlign[!] [N-th] /REGEXP/ [OPTIONS]`        |
-
-### Interactive mode
-
-The following sections will assume that you have `<Plug>(EasyAlign)` mappings in
-your .vimrc as below:
+The recommended method is to use `<Plug>(EasyAlign)` mapping in normal and
+visual mode. They are usually mapped to `ga`, but you can choose any key
+sequences.
 
 ```vim
-" Start interactive EasyAlign in visual mode (e.g. vip<Enter>)
-vmap <Enter> <Plug>(EasyAlign)
-
-" Start interactive EasyAlign for a motion/text object (e.g. gaip)
 nmap ga <Plug>(EasyAlign)
+xmap ga <Plug>(EasyAlign)
 ```
 
-With these mappings, you can align text with only a few keystrokes.
-
-1. `<Enter>` key in visual mode, or `ga` followed by a motion or a text
+1. `ga` key in visual mode, or `ga` followed by a motion or a text
    object to start interactive mode
-1. Optional: Enter keys to select alignment mode (left, right, or center)
-1. Optional: N-th delimiter (default: 1)
+1. (Optional) Enter keys to cycle between alignment mode (left, right, or center)
+1. (Optional) N-th delimiter (default: 1)
     - `1`         Around the 1st occurrences of delimiters
     - `2`         Around the 2nd occurrences of delimiters
     - ...
@@ -138,58 +151,72 @@ With these mappings, you can align text with only a few keystrokes.
     - `-`         Around the last occurrences of delimiters (`-1`)
     - `-2`        Around the second to last occurrences of delimiters
     - ...
-1. Delimiter key (a single keystroke; `<Space>`, `=`, `:`, `.`, `|`, `&`, `#`, `,`)
+1. Delimiter key (a single keystroke; `<Space>`, `=`, `:`, `.`, `|`, `&`, `#`, `,`) or an arbitrary regular expression followed by `<CTRL-X>`
 
-#### Predefined alignment rules
+#### 2. Using `:EasyAlign` command
 
-| Delimiter key | Description/Use cases                                                |
-| ------------- | -------------------------------------------------------------------- |
-| `<Space>`     | General alignment around whitespaces                                 |
-| `=`           | Operators containing equals sign (`=`, `==,` `!=`, `+=`, `&&=`, ...) |
-| `:`           | Suitable for formatting JSON or YAML                                 |
-| `.`           | Multi-line method chaining                                           |
-| `,`           | Multi-line method arguments                                          |
-| `&`           | LaTeX tables (matches `&` and `\\`)                                  |
-| `#`           | Ruby/Python comments                                                 |
-| `<Bar>`       | Table markdown                                                       |
+If you prefer command-line, use `:EasyAlign` command instead.
 
-You can override these default rules or define your own rules with
-`g:easy_align_delimiters`, which will be described in
-[the later section](https://github.com/junegunn/vim-easy-align#extending-alignment-rules).
+```vim
+" Using predefined rules
+:EasyAlign[!] [N-th] DELIMITER_KEY [OPTIONS]
 
-#### Examples
+" Using regular expression
+:EasyAlign[!] [N-th] /REGEXP/ [OPTIONS]
+```
 
-| With visual map     | Description                        | Equivalent command    |
-| ------------------- | ---------------------------------- | --------------------- |
-| `<Enter><Space>`    | Around 1st whitespaces             | `:'<,'>EasyAlign\ `   |
-| `<Enter>2<Space>`   | Around 2nd whitespaces             | `:'<,'>EasyAlign2\ `  |
-| `<Enter>-<Space>`   | Around the last whitespaces        | `:'<,'>EasyAlign-\ `  |
-| `<Enter>-2<Space>`  | Around the 2nd to last whitespaces | `:'<,'>EasyAlign-2\ ` |
-| `<Enter>:`          | Around 1st colon (`key:  value`)   | `:'<,'>EasyAlign:`    |
-| `<Enter><Right>:`   | Around 1st colon (`key : value`)   | `:'<,'>EasyAlign:<l1` |
-| `<Enter>=`          | Around 1st operators with =        | `:'<,'>EasyAlign=`    |
-| `<Enter>3=`         | Around 3rd operators with =        | `:'<,'>EasyAlign3=`   |
-| `<Enter>*=`         | Around all operators with =        | `:'<,'>EasyAlign*=`   |
-| `<Enter>**=`        | Left-right alternating around =    | `:'<,'>EasyAlign**=`  |
-| `<Enter><Enter>=`   | Right alignment around 1st =       | `:'<,'>EasyAlign!=`   |
-| `<Enter><Enter>**=` | Right-left alternating around =    | `:'<,'>EasyAlign!**=` |
+### Regular expression vs. predefined rules
 
-#### Using regular expressions
+You can use regular expressions but it's usually much easier to use predefined
+alignment rules that you can trigger with a single keystroke.
 
-Instead of finishing the command with a predefined delimiter key, you can type
-in a regular expression after `<CTRL-/>` or `<CTRL-X>` key.
-For example, if you want to align text around all occurrences of numbers:
+| Key       | Description/Use cases                                                |
+| --------- | -------------------------------------------------------------------- |
+| `<Space>` | General alignment around whitespaces                                 |
+| `=`       | Operators containing equals sign (`=`, `==,` `!=`, `+=`, `&&=`, ...) |
+| `:`       | Suitable for formatting JSON or YAML                                 |
+| `.`       | Multi-line method chaining                                           |
+| `,`       | Multi-line method arguments                                          |
+| `&`       | LaTeX tables (matches `&` and `\\`)                                  |
+| `#`       | Ruby/Python comments                                                 |
+| `"`       | Vim comments                                                         |
+| `<Bar>`   | Table markdown                                                       |
 
-- `<Enter>`
-- `*`
-- `<CTRL-X>`
-  - `[0-9]\+`
+You can also define your own rules with `g:easy_align_delimiters` which will
+be described in [the later section](#extending-alignment-rules).
+
+----
+
+### Interactive mode
+
+Interactive mode is started either with `<Plug>(EasyAlign)` mapping or with
+`:EasyAlign` command with no argument.
+
+#### Examples using predefined rules
+
+| Keystrokes   | Description                        | Equivalent command    |
+| ------------ | ---------------------------------- | --------------------- |
+| `<Space>`    | Around 1st whitespaces             | `:'<,'>EasyAlign\ `   |
+| `2<Space>`   | Around 2nd whitespaces             | `:'<,'>EasyAlign2\ `  |
+| `-<Space>`   | Around the last whitespaces        | `:'<,'>EasyAlign-\ `  |
+| `-2<Space>`  | Around the 2nd to last whitespaces | `:'<,'>EasyAlign-2\ ` |
+| `:`          | Around 1st colon (`key:  value`)   | `:'<,'>EasyAlign:`    |
+| `<Right>:`   | Around 1st colon (`key : value`)   | `:'<,'>EasyAlign:>l1` |
+| `=`          | Around 1st operators with =        | `:'<,'>EasyAlign=`    |
+| `3=`         | Around 3rd operators with =        | `:'<,'>EasyAlign3=`   |
+| `*=`         | Around all operators with =        | `:'<,'>EasyAlign*=`   |
+| `**=`        | Left-right alternating around =    | `:'<,'>EasyAlign**=`  |
+| `<Enter>=`   | Right alignment around 1st =       | `:'<,'>EasyAlign!=`   |
+| `<Enter>**=` | Right-left alternating around =    | `:'<,'>EasyAlign!**=` |
+
+Instead of finishing the alignment with a delimiter key, you can type in
+a regular expression if you press `<CTRL-/>` or `<CTRL-X>`.
 
 #### Alignment options in interactive mode
 
 While in interactive mode, you can set alignment options using special shortcut
 keys listed below. The meaning of each option will be described in
-[the following sections](https://github.com/junegunn/vim-easy-align#alignment-options).
+[the following sections](#alignment-options).
 
 | Key       | Option             | Values                                             |
 | --------- | ------------------ | -------------------------------------------------- |
@@ -199,13 +226,13 @@ keys listed below. The meaning of each option will be described in
 | `CTRL-R`  | `right_margin`     | Input number or string                             |
 | `CTRL-D`  | `delimiter_align`  | left, center, right                                |
 | `CTRL-U`  | `ignore_unmatched` | 0, 1                                               |
-| `CTRL-G`  | `ignore_groups`    | [], ['String'], ['Comment'], ['String', 'Comment'] |
+| `CTRL-G`  | `ignore_groups`    | `[]`, `['String']`, `['Comment']`, `['String', 'Comment']` |
 | `CTRL-A`  | `align`            | Input string (`/[lrc]+\*{0,2}/`)                   |
 | `<Left>`  | `stick_to_left`    | `{ 'stick_to_left': 1, 'left_margin': 0 }`         |
 | `<Right>` | `stick_to_left`    | `{ 'stick_to_left': 0, 'left_margin': 1 }`         |
 | `<Down>`  | `*_margin`         | `{ 'left_margin': 0, 'right_margin': 0 }`          |
 
-### Live interactive mode
+#### Live interactive mode
 
 If you're performing a complex alignment where multiple options should be
 carefully adjusted, try "live interactive mode" where you can preview the result
@@ -215,15 +242,15 @@ Live interactive mode can be started with either `<Plug>(LiveEasyAlign)` map
 or `:LiveEasyAlign` command. Or you can switch to live interactive mode while
 in ordinary interactive mode by pressing `<CTRL-P>`. (P for Preview)
 
-In live interactive mode, you have to type in the same delimiter (or `CTRL-X` on
-regular expression) again to finalize the alignment. This allows you to preview
-the result of the alignment and freely change the delimiter using backspace key
-without leaving the interactive mode.
+In live interactive mode, you have to type in the same delimiter (or
+`<CTRL-X>` on regular expression) again to finalize the alignment. This allows
+you to preview the result of the alignment and freely change the delimiter
+using backspace key without leaving the interactive mode.
 
-### Non-interactive mode
+### :EasyAlign command
 
-Instead of starting interactive mode, you can use declarative, non-interactive
-`:EasyAlign` command.
+Instead of starting interactive mode, you can use non-interactive `:EasyAlign`
+command.
 
 ```vim
 " Using predefined alignment rules
@@ -242,8 +269,7 @@ Instead of starting interactive mode, you can use declarative, non-interactive
 ```
 
 A command can end with alignment options, [each of which will be discussed in
-detail later](https://github.com/junegunn/vim-easy-align#alignment-options),
-in Vim dictionary format.
+detail later](#alignment-options), in Vim dictionary format.
 
 - `:EasyAlign * /[:;]\+/ { 'stick_to_left': 1, 'left_margin': 0 }`
 
@@ -254,11 +280,11 @@ left. So we get:
     apple;: banana::   cake
     data;;  exchange:; format
 
-Option names are fuzzy-matched, so you can write as follows:
+You don't have to write complete names as long as they're distinguishable.
 
 - `:EasyAlign * /[:;]\+/ { 'stl': 1, 'l': 0 }`
 
-You can even omit spaces between the arguments, so concisely (or cryptically):
+You can even omit spaces between the arguments.
 
 - `:EasyAlign*/[:;]\+/{'s':1,'l':0}`
 
@@ -281,15 +307,6 @@ The following table summarizes the shorthand notation.
 | `delimiter_align`  | `d[lrc]`       |
 | `indentation`      | `i[ksdn]`      |
 
-For your information, the same operation can be done in interactive mode as
-follows:
-
-- `<Enter>`
-- `*`
-- `<Left>`
-- `<CTRL-X>`
-  - `[:;]\+`
-
 ### Partial alignment in blockwise-visual mode
 
 In blockwise-visual mode (`CTRL-V`), EasyAlign command aligns only the selected
@@ -389,7 +406,7 @@ highlighted as code comments or strings are ignored.
 ```vim
 " Default:
 "   If a delimiter is in a highlight group whose name matches
-"   any of the followings, it will be ignored.
+"   any of the following regular expressions, it will be ignored.
 let g:easy_align_ignore_groups = ['Comment', 'String']
 ```
 
@@ -446,6 +463,19 @@ If a pattern in `ignore_groups` is prepended by a `!`, it will have the opposite
 meaning. For instance, if `ignore_groups` is given as `['!Comment']`, delimiters
 that are *not* highlighted as Comment will be ignored during the alignment.
 
+To make `ignore_groups` work, and to debug the related issues, it is useful to
+know which highlight group a certain location in a file belongs to. A special
+function exists for this purpose, returning exactly the name of the highlight
+group that is used by the easy align plugin.
+
+```vim
+" Highlight group name of the cursor position
+echo easy_align#get_highlight_group_name()
+
+" Highlight group name of the line 10, column 20
+echo easy_align#get_highlight_group_name(10, 20)
+```
+
 ### Ignoring unmatched lines
 
 `ignore_unmatched` option determines how EasyAlign command processes lines that

autoload/easy_align.vim

@@ -38,6 +38,7 @@ let s:easy_align_delimiters_default = {
 \  '|': { 'pattern': '|',  'left_margin': 1, 'right_margin': 1, 'stick_to_left': 0 },
 \  '.': { 'pattern': '\.', 'left_margin': 0, 'right_margin': 0, 'stick_to_left': 0 },
 \  '#': { 'pattern': '#\+', 'delimiter_align': 'l', 'ignore_groups': ['!Comment']  },
+\  '"': { 'pattern': '"\+', 'delimiter_align': 'l', 'ignore_groups': ['!Comment']  },
 \  '&': { 'pattern': '\\\@<!&\|\\\\',
 \                          'left_margin': 1, 'right_margin': 1, 'stick_to_left': 0 },
 \  '{': { 'pattern': '(\@<!{',
@@ -88,9 +89,30 @@ function! s:floor2(v)
   return a:v % 2 == 0 ? a:v : a:v - 1
 endfunction
 
+function! s:get_highlight_group_name(line, col)
+  let hl = synIDattr(synID(a:line, a:col, 0), 'name')
+
+  if hl == '' && has('nvim-0.9.0')
+    let insp = luaeval('vim.inspect_pos and vim.inspect_pos( nil, ' .. (a:line-1) .. ', ' .. (a:col-1) .. ' ) or { treesitter = {} }')
+    if !empty(insp.treesitter)
+      let hl = insp.treesitter[0].hl_group_link
+    endif
+  endif
+
+  " and, finally
+  return hl
+endfunction
+
+function! easy_align#get_highlight_group_name(...)
+  let l  = get(a:, 1, line('.'))
+  let c  = get(a:, 2, col('.'))
+  let hl = s:get_highlight_group_name(l, c)
+  return { 'line': l, 'column': c, 'group': hl }
+endfunction
+
 function! s:highlighted_as(line, col, groups)
   if empty(a:groups) | return 0 | endif
-  let hl = synIDattr(synID(a:line, a:col, 0), 'name')
+  let hl = s:get_highlight_group_name(a:line, a:col)
   for grp in a:groups
     if grp[0] == '!'
       if hl !~# grp[1:-1]
@@ -264,11 +286,8 @@ function! s:split_line(line, nth, modes, cycle, fc, lc, pattern, stick_to_left,
     \ strpart(getline(a:line), a:fc - 1, a:lc - a:fc + 1) :
     \ strpart(getline(a:line), a:fc - 1)
   let idx     = 0
-  " Do not allow \zs
-  " 1: whole match
-  " 2: token
-  " 3: delimiter
-  let pattern = '^\(\(.\{-}\s*\)\(' .a:pattern. '\)\s' . (a:stick_to_left ? '*' : '\{-}') . '\)'
+  let nomagic = match(a:pattern, '\\v') > match(a:pattern, '\C\\[mMV]')
+  let pattern = '^.\{-}\s*\zs\('.a:pattern.(nomagic ? ')' : '\)')
   let tokens  = []
   let delims  = []
 
@@ -277,18 +296,22 @@ function! s:split_line(line, nth, modes, cycle, fc, lc, pattern, stick_to_left,
   let token = ''
   let phantom = 0
   while 1
-    let matches = matchlist(string, pattern, idx)
+    let matchidx = match(string, pattern, idx)
     " No match
-    if empty(matches) | break | endif
+    if matchidx < 0 | break | endif
+    let matchend = matchend(string, pattern, idx)
+    let spaces = matchstr(string, '\s'.(a:stick_to_left ? '*' : '\{-}'), matchend + (matchidx == matchend))
 
-    " Match, but empty delimiter
-    if empty(matches[1])
+    " Match, but empty
+    if len(spaces) + matchend - idx == 0
       let char = strpart(string, idx, 1)
       if empty(char) | break | endif
       let [match, part, delim] = [char, char, '']
     " Match
     else
-      let [match, part, delim] = matches[1 : 3]
+      let match = strpart(string, idx, matchend - idx + len(spaces))
+      let part  = strpart(string, idx, matchidx - idx)
+      let delim = strpart(string, matchidx, matchend - matchidx)
     endif
 
     let ignorable = s:highlighted_as(a:line, idx + len(part) + a:fc, a:ignore_groups)
@@ -358,9 +381,10 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, nth, r
 
   " Phase 1
   for line in range(a:fl, a:ll)
-    if f == 1 && getline(line) !~ fx
+    let snip = a:lc > 0 ? getline(line)[a:fc-1 : a:lc-1] : getline(line)
+    if f == 1 && snip !~ fx
       continue
-    elseif f == -1 && getline(line) =~ fx
+    elseif f == -1 && snip =~ fx
       continue
     endif
 
@@ -655,7 +679,11 @@ function! s:interactive(range, modes, n, d, opts, rules, vis, bvis)
     let check = 0
     let warn = ''
 
-    let c  = getchar()
+    try
+      let c = getchar()
+    catch /^Vim:Interrupt$/
+      let c = 27
+    endtry
     let ch = nr2char(c)
     if c == 3 || c == 27 " CTRL-C / ESC
       if undo
@@ -822,10 +850,11 @@ function! s:valid_regexp(regexp)
 endfunction
 
 function! s:test_regexp(regexp)
-  if !s:valid_regexp(a:regexp)
-    call s:exit('Invalid regular expression: '. a:regexp)
+  let regexp = empty(a:regexp) ? @/ : a:regexp
+  if !s:valid_regexp(regexp)
+    call s:exit('Invalid regular expression: '. regexp)
   endif
-  return a:regexp
+  return regexp
 endfunction
 
 let s:shorthand_regex =
@@ -1042,18 +1071,21 @@ function! s:build_mode_sequence(expr, recur)
 endfunction
 
 function! s:process(range, mode, n, ch, opts, regexp, rules, bvis)
-  let [nth, recur] = s:parse_nth(a:n)
+  let [nth, recur] = s:parse_nth((empty(a:n) && exists('g:easy_align_nth')) ? g:easy_align_nth : a:n)
   let dict = s:build_dict(a:rules, a:ch, a:regexp, a:opts)
   let [mode_sequence, recur] = s:build_mode_sequence(
     \ get(dict, 'align', recur == 2 ? s:alternating_modes(a:mode) : a:mode),
     \ recur)
 
+  let ve = &virtualedit
+  set ve=all
   let args = [
     \ {}, split(mode_sequence, '\zs'),
     \ {}, {}, a:range[0], a:range[1],
-    \ a:bvis             ? min([col("'<"), col("'>")]) : 1,
-    \ (!recur && a:bvis) ? max([col("'<"), col("'>")]) : 0,
+    \ a:bvis             ? min([virtcol("'<"), virtcol("'>")]) : 1,
+    \ (!recur && a:bvis) ? max([virtcol("'<"), virtcol("'>")]) : 0,
     \ nth, recur, dict ]
+  let &ve = ve
   while len(args) > 1
     let args = call('s:do_align', args)
   endwhile
@@ -1077,10 +1109,12 @@ endfunction
 
 function! s:align(bang, live, visualmode, first_line, last_line, expr)
   " Heuristically determine if the user was in visual mode
-  if empty(a:visualmode)
+  if a:visualmode == 'command'
     let vis  = a:first_line == line("'<") && a:last_line == line("'>")
     let bvis = vis && visualmode() == "\<C-V>"
-  " Visual-mode explicitly given
+  elseif empty(a:visualmode)
+    let vis  = 0
+    let bvis = 0
   else
     let vis  = 1
     let bvis = a:visualmode == "\<C-V>"
@@ -1120,10 +1154,17 @@ endfunction
 function! easy_align#align(bang, live, visualmode, expr) range
   try
     call s:align(a:bang, a:live, a:visualmode, a:firstline, a:lastline, a:expr)
-  catch 'exit'
+  catch /^\%(Vim:Interrupt\|exit\)$/
+    if empty(a:visualmode)
+      echon "\r"
+      echon "\r"
+    else
+      normal! gv
+    endif
   endtry
 endfunction
 
 let &cpo = s:cpo_save
 unlet s:cpo_save
 
+" vim: set et sw=2 :

doc/easy_align.txt

@@ -1,4 +1,4 @@
-easy-align.txt	easy-align	Last change: December 14 2014
+*easy-align.txt*	easy-align	Last change: December 14 2014
 EASY-ALIGN - TABLE OF CONTENTS             *easyalign* *easy-align* *easy-align-toc*
 ==============================================================================
 
@@ -77,7 +77,7 @@ FEATURES                                                   *easy-align-features*
 INSTALLATION                                           *easy-align-installation*
 ==============================================================================
 
-User your favorite plugin manager.
+Use your favorite plugin manager.
 
 Using {vim-plug}{2}:
 >
@@ -234,6 +234,7 @@ Predefined alignment rules~
   `,`            | Multi-line method arguments
   `&`            | LaTeX tables (matches  `&`  and  `\\` )
   `#`            | Ruby/Python comments
+  `"`            | Vim comments
  <Bar>         | Table markdown
  --------------+--------------------------------------------------------------------
 
@@ -516,7 +517,7 @@ highlighted as code comments or strings are ignored.
 >
     " Default:
     "   If a delimiter is in a highlight group whose name matches
-    "   any of the followings, it will be ignored.
+    "   any of the following regular expressions, it will be ignored.
     let g:easy_align_ignore_groups = ['Comment', 'String']
 <
 For example, the following paragraph
@@ -566,6 +567,17 @@ opposite meaning. For instance, if `ignore_groups` is given as `['!Comment']`,
 delimiters that are not highlighted as Comment will be ignored during the
 alignment.
 
+To make `ignore_groups` work, and to debug the related issues, it is useful to
+know which highlight group a certain location in a file belongs to. A special
+function exists for this purpose, returning exactly the name of the highlight
+group that is used by the easy align plugin.
+>
+    " Highlight group name of the cursor position
+    echo easy_align#get_highlight_group_name()
+
+    " Highlight group name of the line 10, column 20
+    echo easy_align#get_highlight_group_name(10, 20)
+<
 
 < Ignoring unmatched lines >__________________________________________________~
                                            *easy-align-ignoring-unmatched-lines*

plugin/easy_align.vim

@@ -26,8 +26,8 @@ if exists("g:loaded_easy_align_plugin")
 endif
 let g:loaded_easy_align_plugin = 1
 
-command! -nargs=* -range -bang EasyAlign <line1>,<line2>call easy_align#align('<bang>' == '!', 0, '', <q-args>)
-command! -nargs=* -range -bang LiveEasyAlign <line1>,<line2>call easy_align#align('<bang>' == '!', 1, '', <q-args>)
+command! -nargs=* -range -bang EasyAlign <line1>,<line2>call easy_align#align(<bang>0, 0, 'command', <q-args>)
+command! -nargs=* -range -bang LiveEasyAlign <line1>,<line2>call easy_align#align(<bang>0, 1, 'command', <q-args>)
 
 let s:last_command = 'EasyAlign'
 
@@ -99,7 +99,7 @@ function! s:generic_easy_align_op(type, vmode, live)
     if get(g:, 'easy_align_need_repeat', 0)
       execute range . g:easy_align_last_command
     else
-      execute range . "call easy_align#align('<bang>' == '!', a:live, vmode, '')"
+      execute range . "call easy_align#align(0, a:live, vmode, '')"
     end
     call s:set_repeat()
   finally
@@ -140,3 +140,4 @@ vnoremap <silent> <Plug>(EasyAlignRepeat) :<C-U>call <SID>repeat_in_visual()<Ent
 " Backward-compatibility (deprecated)
 nnoremap <silent> <Plug>(EasyAlignOperator) :set opfunc=<SID>easy_align_op<Enter>g@
 
+" vim: set et sw=2 :

test/commandline.vader

@@ -105,6 +105,14 @@ Expect:
   ap><pl><e;><:;><;b><an><an><a:><:c><ak>e
   da><ta><;;><ex><ch><an><ge><:;><::><fo> <rm><at
 
+Execute (Use current search pattern as delimiter if empty regular expression is given):
+  /an
+  %EasyAlign*//
+
+Expect:
+  apple;:;;b an  an a::cake
+  data;;exch an ge:;::format
+
 Given javascript (json):
   var jdbc = {
     // JDBC driver for MySQL database:

test/fixed.vader

@@ -212,4 +212,52 @@ Expect:
   aa  -= bb
   aaa ?= bbb
 
+* #67 \v
+Given c:
+  bzero(&servaddr, sizeof(servaddr));
+  servaddr.sin_family = AF_INET;
+  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+  servaddr.sin_port = htons(SERV_PORT);
+
+Execute (#67 \v breaks surrounding regex):
+  %EasyAlign/\v(\=\s)@<=</
+
+Expect:
+  bzero(&servaddr, sizeof(servaddr));
+  servaddr.sin_family =       AF_INET;
+  servaddr.sin_addr.s_addr =  htonl(INADDR_ANY);
+  servaddr.sin_port =         htons(SERV_PORT);
+
+Execute (#67 \V followed by \v shouldn't matter):
+  %EasyAlign/\v(\=\s)@<=<\V/
+
+Expect:
+  bzero(&servaddr, sizeof(servaddr));
+  servaddr.sin_family =       AF_INET;
+  servaddr.sin_addr.s_addr =  htonl(INADDR_ANY);
+  servaddr.sin_port =         htons(SERV_PORT);
+
+Execute (#67 \zs is now allowed):
+  %EasyAlign/=\zs/
+
+Expect:
+  bzero(&servaddr, sizeof(servaddr));
+  servaddr.sin_family =       AF_INET;
+  servaddr.sin_addr.s_addr =  htonl(INADDR_ANY);
+  servaddr.sin_port =         htons(SERV_PORT);
+
 Include: include/teardown.vader
+
+Given:
+  hello = world bye all
+  hello world = bye all
+  hello world = foo all
+
+Do (#105: Incorrectly detection of blockwise visual mode):
+  \<c-v>jj\<esc>
+  \<Space>Aip=
+
+Expect:
+  hello       = world bye all
+  hello world = bye all
+  hello world = foo all

test/interactive.vader

@@ -581,6 +581,120 @@ Do:
 Execute (g:easy_align_last_command should not be set if interrupted):
   Assert !exists('g:easy_align_last_command')
 
+Do (g:easy_align_nth is not set (work with default value 1)):
+  vip\<Enter>|
+
+Expect:
+  | Option| Type | Default | Description |
+  | --|--|--|--|
+  | threads | Fixnum | 1 | number of threads in the thread pool |
+  | queues |Fixnum | 1 | number of concurrent queues |
+  | queue_size | Fixnum | 1000 | size of each queue |
+  | interval | Numeric | 0 | dispatcher interval for batch processing |
+  | batch | Boolean | false | enables batch processing mode |
+  | batch_size | Fixnum | nil | number of maximum items to be assigned at once |
+  | logger | Logger | nil | logger instance for debug logs |
+
+Execute (set g:easy_align_nth):
+  let g:easy_align_nth = '2'
+
+Do (g:easy_align_nth is set as 2):
+  vip\<Enter>|
+
+Expect:
+  | Option     | Type | Default | Description |
+  |--          | --|--|--|
+  | threads    | Fixnum | 1 | number of threads in the thread pool |
+  |queues      | Fixnum | 1 | number of concurrent queues |
+  |queue_size  | Fixnum | 1000 | size of each queue |
+  |   interval | Numeric | 0 | dispatcher interval for batch processing |
+  |batch       | Boolean | false | enables batch processing mode |
+   |batch_size | Fixnum | nil | number of maximum items to be assigned at once |
+   |logger     | Logger | nil | logger instance for debug logs |
+
+Execute (unset g:easy_align_nth):
+  unlet g:easy_align_nth
+
+Execute (set g:easy_align_nth):
+  let g:easy_align_nth = '*'
+
+Do (g:easy_align_nth is set as *):
+  vip\<Enter>|
+
+Expect:
+  | Option     | Type    | Default | Description                                    |
+  | --         | --      | --      | --                                             |
+  | threads    | Fixnum  | 1       | number of threads in the thread pool           |
+  | queues     | Fixnum  | 1       | number of concurrent queues                    |
+  | queue_size | Fixnum  | 1000    | size of each queue                             |
+  | interval   | Numeric | 0       | dispatcher interval for batch processing       |
+  | batch      | Boolean | false   | enables batch processing mode                  |
+  | batch_size | Fixnum  | nil     | number of maximum items to be assigned at once |
+  | logger     | Logger  | nil     | logger instance for debug logs                 |
+
+Execute (unset g:easy_align_nth):
+  unlet g:easy_align_nth
+
+Execute (set g:easy_align_nth):
+  let g:easy_align_nth = '**'
+
+Do (g:easy_align_nth is set as **):
+  vip\<Enter>|
+
+Expect:
+  |     Option | Type    | Default | Description                                    |
+  |         -- | --      |      -- | --                                             |
+  |    threads | Fixnum  |       1 | number of threads in the thread pool           |
+  |     queues | Fixnum  |       1 | number of concurrent queues                    |
+  | queue_size | Fixnum  |    1000 | size of each queue                             |
+  |   interval | Numeric |       0 | dispatcher interval for batch processing       |
+  |      batch | Boolean |   false | enables batch processing mode                  |
+  | batch_size | Fixnum  |     nil | number of maximum items to be assigned at once |
+  |     logger | Logger  |     nil | logger instance for debug logs                 |
+
+Execute (unset g:easy_align_nth):
+  unlet g:easy_align_nth
+
+Execute (set g:easy_align_nth):
+  let g:easy_align_nth = '-'
+
+Do (g:easy_align_nth is set as -):
+  vip\<Enter>|
+
+Expect:
+  | Option| Type | Default | Description                                       |
+  |--|--|--|--                                                                 |
+  | threads | Fixnum | 1 | number of threads in the thread pool                |
+  |queues |Fixnum | 1 | number of concurrent queues                            |
+  |queue_size | Fixnum | 1000 | size of each queue                             |
+  |   interval | Numeric | 0 | dispatcher interval for batch processing        |
+  |batch | Boolean | false | enables batch processing mode                     |
+   |batch_size | Fixnum | nil | number of maximum items to be assigned at once |
+   |logger | Logger | nil | logger instance for debug logs                     |
+
+Execute (unset g:easy_align_nth):
+  unlet g:easy_align_nth
+
+Execute (set g:easy_align_nth):
+  let g:easy_align_nth = '-2'
+
+Do (g:easy_align_nth is set as -2):
+  vip\<Enter>|
+
+Expect:
+  | Option| Type | Default    | Description |
+  |--|--|--                   | --|
+  | threads | Fixnum | 1      | number of threads in the thread pool |
+  |queues |Fixnum | 1         | number of concurrent queues |
+  |queue_size | Fixnum | 1000 | size of each queue |
+  |   interval | Numeric | 0  | dispatcher interval for batch processing |
+  |batch | Boolean | false    | enables batch processing mode |
+   |batch_size | Fixnum | nil | number of maximum items to be assigned at once |
+   |logger | Logger | nil     | logger instance for debug logs |
+
+Execute (unset g:easy_align_nth):
+  unlet g:easy_align_nth
+
 ###########################################################
 
 Given (comma-separated items):
@@ -1535,6 +1649,67 @@ Expect:
   bbbbb=bbbbb=bbbbb
   aaa   = aaa   = aaa
 
+Given clojure (filter with blockwise-visual mode):
+  (let [a 1
+        bbb 2
+        ccccc (range
+                10 20)]
+    (prn [a bbb ccccc]))
+
+Do (filter with blockwise-visual mode):
+  f[
+  vi[
+  \<C-V>
+  \<Enter>
+  \<C-F>g/^\S\<Enter>
+  \<Space>
+
+Expect clojure:
+  (let [a     1
+        bbb   2
+        ccccc (range
+                10 20)]
+    (prn [a bbb ccccc]))
+
+Given clojure:
+  {:user {:plugins [[cider/cider-nrepl "0.9.1"]
+                    [lein-kibit "0.0.8"]
+                    [lein-licenses "0.1.1"]
+                    [lein-marginalia "0.8.0"] ; lein marg
+                    [codox "0.8.13"] ; lein doc
+                    [com.jakemccrary/lein-test-refresh "0.10.0"] ; lein test-refresh
+                    [lein-pprint "1.1.2"]
+                    [lein-exec "0.3.5"]
+                    [jonase/eastwood "0.2.1"]]
+          :dependencies [[slamhound "1.5.5"]]
+          :aliases {"slamhound" ["run" "-m" "slam.hound"]}
+          :signing {:gpg-key "FEF9C627"}}}
+
+Do (Virtual column should be used in blockwise-visual mode):
+  :set ve=block\<Enter>
+  f[
+  vi[
+  \<C-V>
+  $20l
+  \<Enter>\<Space>
+
+Expect clojure:
+  {:user {:plugins [[cider/cider-nrepl                 "0.9.1"]
+                    [lein-kibit                        "0.0.8"]
+                    [lein-licenses                     "0.1.1"]
+                    [lein-marginalia                   "0.8.0"] ; lein marg
+                    [codox                             "0.8.13"] ; lein doc
+                    [com.jakemccrary/lein-test-refresh "0.10.0"] ; lein test-refresh
+                    [lein-pprint                       "1.1.2"]
+                    [lein-exec                         "0.3.5"]
+                    [jonase/eastwood                   "0.2.1"]]
+          :dependencies [[slamhound "1.5.5"]]
+          :aliases {"slamhound" ["run" "-m" "slam.hound"]}
+          :signing {:gpg-key "FEF9C627"}}}
+
+Then:
+  set ve=
+
 ###########################################################
 
 Given (hard-tab indentation (#19)):