Fix regular expression for = rule

Bug reported by @cvlmtg

.gitattributes

@@ -1,3 +1,4 @@
+.travis.yml    export-ignore
 .gitattributes export-ignore
 .gitignore     export-ignore
 doc/tags       export-ignore

.travis.yml

@@ -2,12 +2,14 @@ language: vim
 
 before_script: |
   git clone https://github.com/junegunn/vader.vim.git
+  git clone https://github.com/tpope/vim-repeat
 
 script: |
   vim -Nu <(cat << VIMRC
   filetype off
   set rtp+=vader.vim
+  set rtp+=vim-repeat
   set rtp+=.
-  set rtp+=after
   filetype plugin indent on
+  syntax enable
   VIMRC) -c 'Vader! test/*' > /dev/null

EXAMPLES.md

@@ -3,10 +3,14 @@ vim-easy-align examples
 
 Open this document in your Vim and try it yourself.
 
-This document assumes that you have defined the following mapping.
+This document assumes that you have defined the following mappings.
 
 ```vim
-vnoremap <silent> <Enter> :EasyAlign<cr>
+" Start interactive EasyAlign in visual mode (e.g. vip<Enter>)
+vmap <Enter> <Plug>(EasyAlign)
+
+" Start interactive EasyAlign for a motion/text object (e.g. <Leader>aip)
+nmap <Leader>a <Plug>(EasyAlign)
 ```
 
 To enable syntax highlighting in the code blocks, define and call the following
@@ -214,6 +218,9 @@ This only works when syntax highlighting is enabled.
 Aligning in-line comments
 -------------------------
 
+*Note: Since the current version provides '#'-rule as one of the default rules,
+you can ignore this section.*
+
 ```ruby
 apple = 1 # comment not aligned
 banana = 'Gros Michel' # comment 2

README.md

@@ -1,4 +1,4 @@
-vim-easy-align
+vim-easy-align ![travis-ci](https://travis-ci.org/junegunn/vim-easy-align.svg?branch=master)
 ==============
 
 A simple, easy-to-use Vim alignment plugin.
@@ -6,9 +6,9 @@ A simple, easy-to-use Vim alignment plugin.
 Demo
 ----
 
-![Screencast](https://raw.github.com/junegunn/i/master/vim-easy-align.gif)
+<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.github.com/junegunn/i/master/vim-easy-align-slow.gif))
+(Too fast? Slower GIF is [here](https://raw.githubusercontent.com/junegunn/i/master/vim-easy-align-slow.gif))
 
 Features
 --------
@@ -22,32 +22,16 @@ Features
 - Optimized for code editing
   - Takes advantage of syntax highlighting feature to avoid unwanted alignments
 
-### _"I already have a similar one. Should I switch?"_
-
-Maybe or maybe not. See [related work](https://github.com/junegunn/vim-easy-align#related-work) section.
-
 Installation
 ------------
 
-Either [download zip file](http://www.vim.org/scripts/script.php?script_id=4520)
-and extract in ~/.vim or
-[use](https://github.com/tpope/vim-pathogen)
-[your](https://github.com/gmarik/vundle)
-[favorite](https://github.com/junegunn/vim-plug)
-[plugin](https://github.com/Shougo/neobundle.vim)
-[manager](https://github.com/MarcWeber/vim-addon-manager).
+User your favorite plugin manager.
 
-- [Pathogen](https://github.com/tpope/vim-pathogen)
-  - `git clone https://github.com/junegunn/vim-easy-align.git ~/.vim/bundle/vim-easy-align`
-- [Vundle](https://github.com/gmarik/vundle)
-  1. Add `Bundle 'junegunn/vim-easy-align'` to .vimrc
-  2. Run `:BundleInstall`
-- [NeoBundle](https://github.com/Shougo/neobundle.vim)
-  1. Add `NeoBundle 'junegunn/vim-easy-align'` to .vimrc
-  2. Run `:NeoBundleInstall`
-- [vim-plug](https://github.com/junegunn/vim-plug)
-  1. Add `Plug 'junegunn/vim-easy-align'` to .vimrc
-  2. Run `:PlugInstall`
+Using [vim-plug](https://github.com/junegunn/vim-plug):
+
+```vim
+Plug 'junegunn/vim-easy-align'
+```
 
 TL;DR - One-minute guide
 ------------------------
@@ -55,11 +39,11 @@ TL;DR - One-minute guide
 Add the following mappings to your .vimrc.
 
 ```vim
-" Start interactive EasyAlign in visual mode
+" Start interactive EasyAlign in visual mode (e.g. vip<Enter>)
 vmap <Enter> <Plug>(EasyAlign)
 
-" Start interactive EasyAlign with a Vim movement
-nmap <Leader>a <Plug>(EasyAlign)
+" Start interactive EasyAlign for a motion/text object (e.g. gaip)
+nmap ga <Plug>(EasyAlign)
 ```
 
 And with the following lines of text,
@@ -76,8 +60,8 @@ try these commands:
     - `v`isual-select `i`nner `p`aragraph
     - Start EasyAlign command (`<Enter>`)
     - Align around `=`
-- `<Leader>aip=`
-    - Start EasyAlign command (`<Leader>a`) for `i`nner `p`aragraph
+- `gaip=`
+    - Start EasyAlign command (`ga`) for `i`nner `p`aragraph
     - Align around `=`
 
 Notice that the commands are repeatable with `.` key if you have installed
@@ -88,57 +72,62 @@ to repeat in visual mode.
 Usage
 -----
 
-_vim-easy-align_ defines `:EasyAlign` command (and the right-align
-variant `:EasyAlign!`).
-
-| Mode                      | Command                                          |
-| ------------------------- | ------------------------------------------------ |
-| Interactive mode          | `:EasyAlign[!] [OPTIONS]`                        |
-| Using predefined rules    | `:EasyAlign[!] [N-th] DELIMITER_KEY [OPTIONS]`   |
-| Using regular expressions | `:EasyAlign[!] [N-th] /REGEXP/ [OPTIONS]`        |
-| Live interactive mode     | `:LiveEasyAlign[!] [...]`                        |
-
 ### Concept of _alignment rule_
 
+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 `,`.
+`=`, `:`, `.`, `|`, `&`, `#`, 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
+
+There are two ways to use easy-align.
+
+#### 1. Using `<Plug>` mappings
+
+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 command will go into the interactive mode when no argument is given.
+The following sections will assume that you have `<Plug>(EasyAlign)` mappings in
+your .vimrc as below:
 
 ```vim
-:EasyAlign
+" 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)
 ```
 
-However, it is strongly advised that you define mappings for triggering it in
-your `.vimrc` as follows. (Of course you can use any key combination as the
-trigger.)
+With these mappings, you can align text with only a few keystrokes.
 
-```vim
-" For visual mode (e.g. vip<Enter>)
-vmap <Enter>   <Plug>(EasyAlign)
-
-" For normal mode, with Vim movement (e.g. <Leader>aip)
-nmap <Leader>a <Plug>(EasyAlign)
-```
-
-The advantages of using the above mappings are two-fold:
-
-- They require less keystrokes
-- They make alignments repeatable with
-  [repeat.vim](https://github.com/tpope/vim-repeat) and
-  [visualrepeat](https://github.com/vim-scripts/visualrepeat)
-
-
-With the mapping, you can align selected lines of text with only a few keystrokes.
-
-1. `<Enter>` key in visual mode, or `<Leader>a` followed by a Vim movement to
-   start interactive EasyAlign command
+1. `<Enter>` 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`         Around the 1st occurrences of delimiters
@@ -149,9 +138,9 @@ With the mapping, you can align selected lines of text with only a few keystroke
     - `-`         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>`, `=`, `:`, `.`, `|`, `&`, `#`, `,`)
 
-Alignment rules for the following delimiters have been defined to meet the most needs.
+#### Predefined alignment rules
 
 | Delimiter key | Description/Use cases                                                |
 | ------------- | -------------------------------------------------------------------- |
@@ -161,29 +150,29 @@ Alignment rules for the following delimiters have been defined to meet the most
 | `.`           | Multi-line method chaining                                           |
 | `,`           | Multi-line method arguments                                          |
 | `&`           | LaTeX tables (matches `&` and `\\`)                                  |
+| `#`           | Ruby/Python comments                                                 |
 | `<Bar>`       | Table markdown                                                       |
 
 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).
 
-#### Example command sequences
+#### Examples
 
-| 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:s0l1` |
-| `<Enter>=`          | Around 1st operators with =        | `:'<,'>EasyAlign=`     |
-| `<Enter>2=`         | Around 2nd operators with =        | `:'<,'>EasyAlign2=`    |
-| `<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!**=`  |
+| 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!**=` |
 
 #### Using regular expressions
 
@@ -193,7 +182,7 @@ For example, if you want to align text around all occurrences of numbers:
 
 - `<Enter>`
 - `*`
-- `<CTRL-/>` (or `<CTRL-X>` on GVim)
+- `<CTRL-X>`
   - `[0-9]\+`
 
 #### Alignment options in interactive mode
@@ -211,85 +200,56 @@ keys listed below. The meaning of each option will be described in
 | `CTRL-D`  | `delimiter_align`  | left, center, right                                |
 | `CTRL-U`  | `ignore_unmatched` | 0, 1                                               |
 | `CTRL-G`  | `ignore_groups`    | [], ['String'], ['Comment'], ['String', 'Comment'] |
-| `CTRL-O`  | `mode_sequence`    | Input string (`/[lrc]+\*{0,2}/`)                   |
+| `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 }`          |
 
-After a successful alignment, you can repeat the same operation using the
-repeatable, non-interactive command recorded in `g:easy_align_last_command`.
-
-```vim
-:<C-R>=g:easy_align_last_command<Enter><Enter>
-```
-
-### EasyAlign as Vim operator
-
-With normal-mode map to `<Plug>(EasyAlign)`, EasyAlign command becomes a Vim
-operator that can be used with any Vim movement.
-
-```vim
-nmap <Leader>a <Plug>(EasyAlign)
-```
-
-Now without going into visual mode, you can align the lines in the paragraph
-with `<Leader>aip=`, `<Leader>aip*|`, or `<Leader>aip:`. And if you have
-installed [repeat.vim](https://github.com/tpope/vim-repeat) by Tim Pope, the
-exact alignment can be repeated with `.` key.
-
 ### 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
 of the alignment on-the-fly as you type in.
 
-Live interactive mode can be started with `:LiveEasyAlign` command which takes
-the same parameters as `:EasyAlign`. I suggest you define mappings such as
-follows in addition to the ones for `:EasyAlign` command.
-
-```vim
-vmap <Leader><Enter>   <Plug>(LiveEasyAlign)
-nmap <Leader><Leader>a <Plug>(LiveEasyAlign)
-```
+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.
 
-### Using `EasyAlign` in command line
+### Non-interactive mode
 
-Instead of going into the interactive mode, you can just type in arguments to
+Instead of starting interactive mode, you can use declarative, non-interactive
 `:EasyAlign` command.
 
 ```vim
 " Using predefined alignment rules
-:EasyAlign[!] [N-th] DELIMITER_KEY [OPTIONS]
+"   :EasyAlign[!] [N-th] DELIMITER_KEY [OPTIONS]
+:EasyAlign :
+:EasyAlign =
+:EasyAlign *=
+:EasyAlign 3\
 
 " Using arbitrary regular expressions
-:EasyAlign[!] [N-th] /REGEXP/ [OPTIONS]
+"   :EasyAlign[!] [N-th] /REGEXP/ [OPTIONS]
+:EasyAlign /[:;]\+/
+:EasyAlign 2/[:;]\+/
+:EasyAlign */[:;]\+/
+:EasyAlign **/[:;]\+/
 ```
 
-For example, when aligning the following lines around colons and semi-colons,
-
-    apple;:banana::cake
-    data;;exchange:;format
-
-try these commands:
-
-- `:EasyAlign /[:;]\+/`
-- `:EasyAlign 2/[:;]\+/`
-- `:EasyAlign */[:;]\+/`
-- `:EasyAlign **/[:;]\+/`
-
-You can also provide a number of alignment options, [which will be discussed in
+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),
-to EasyAlign command in Vim dictionary format.
+in Vim dictionary format.
 
 - `:EasyAlign * /[:;]\+/ { 'stick_to_left': 1, 'left_margin': 0 }`
 
-Which means that the matched delimiter should be positioned right next to the
-preceding token, without margin on the left. So we get:
+`stick_to_left` of 1 means that the matched delimiter should be positioned right
+next to the preceding token, and `left_margin` of 0 removes the margin on the
+left. So we get:
 
     apple;: banana::   cake
     data;;  exchange:; format
@@ -305,29 +265,29 @@ You can even omit spaces between the arguments, so concisely (or cryptically):
 Nice. But let's make it even shorter. Option values can be written in shorthand
 notation.
 
-- `:EasyAlign*/[:;]\+/s1l0`
+- `:EasyAlign*/[:;]\+/<l0`
 
 The following table summarizes the shorthand notation.
 
-| Option             | Expression |
-| ------------------ | ---------- |
-| `filter`           | `[gv]/.*/` |
-| `left_margin`      | `l[0-9]+`  |
-| `right_margin`     | `r[0-9]+`  |
-| `stick_to_left`    | `s[01]`    |
-| `ignore_unmatched` | `iu[01]`   |
-| `ignore_groups`    | `ig\[.*\]` |
-| `delimiter_align`  | `d[lrc]`   |
-| `mode_sequence`    | `m[lrc*]*` |
-| `indentation`      | `i[ksdn]`  |
+| Option             | Expression     |
+| ------------------ | -------------- |
+| `filter`           | `[gv]/.*/`     |
+| `left_margin`      | `l[0-9]+`      |
+| `right_margin`     | `r[0-9]+`      |
+| `stick_to_left`    | `<` or `>`     |
+| `ignore_unmatched` | `iu[01]`       |
+| `ignore_groups`    | `ig\[.*\]`     |
+| `align`            | `a[lrc*]*`     |
+| `delimiter_align`  | `d[lrc]`       |
+| `indentation`      | `i[ksdn]`      |
 
-For your information, the same thing can be done in the interactive mode as well
-with the following key combination.
+For your information, the same operation can be done in interactive mode as
+follows:
 
 - `<Enter>`
 - `*`
 - `<Left>`
-- `<CTRL-/>` (or `<CTRL-X>` on GVim)
+- `<CTRL-X>`
   - `[:;]\+`
 
 ### Partial alignment in blockwise-visual mode
@@ -375,7 +335,7 @@ Alignment options
 | `ignore_unmatched` | boolean | 1                     | Whether to ignore lines without matching delimiter      |
 | `indentation`      | string  | `k`                   | Indentation method (*k*eep, *d*eep, *s*hallow, *n*one)  |
 | `delimiter_align`  | string  | `r`                   | Determines how to align delimiters of different lengths |
-| `mode_sequence`    | string  |                       | Alignment modes for multiple occurrences of delimiters  |
+| `align`            | string  | `l`                   | Alignment modes for multiple occurrences of delimiters  |
 
 There are 4 ways to set alignment options (from lowest precedence to highest):
 
@@ -384,24 +344,24 @@ There are 4 ways to set alignment options (from lowest precedence to highest):
 3. Option values can be given as arguments to `:EasyAlign` command
 4. Option values can be set in interactive mode using special shortcut keys
 
-| Option name        | Shortcut key        | Abbreviated | Global variable                 |
-| ------------------ | ------------------- | ----------- | ------------------------------- |
-| `filter`           | `CTRL-F`            | `[gv]/.*/`  |                                 |
-| `left_margin`      | `CTRL-L`            | `l[0-9]+`   |                                 |
-| `right_margin`     | `CTRL-R`            | `r[0-9]+`   |                                 |
-| `stick_to_left`    | `<Left>`, `<Right>` | `s[01]`     |                                 |
-| `ignore_groups`    | `CTRL-G`            | `ig\[.*\]`  | `g:easy_align_ignore_groups`    |
-| `ignore_unmatched` | `CTRL-U`            | `iu[01]`    | `g:easy_align_ignore_unmatched` |
-| `indentation`      | `CTRL-I`            | `i[ksdn]`   | `g:easy_align_indentation`      |
-| `delimiter_align`  | `CTRL-D`            | `d[lrc]`    | `g:easy_align_delimiter_align`  |
-| `mode_sequence`    | `CTRL-O`            | `m[lrc*]*`  |                                 |
+| Option name        | Shortcut key        | Abbreviated    | Global variable                 |
+| ------------------ | ------------------- | -------------- | ------------------------------- |
+| `filter`           | `CTRL-F`            | `[gv]/.*/`     |                                 |
+| `left_margin`      | `CTRL-L`            | `l[0-9]+`      |                                 |
+| `right_margin`     | `CTRL-R`            | `r[0-9]+`      |                                 |
+| `stick_to_left`    | `<Left>`, `<Right>` | `<` or `>`     |                                 |
+| `ignore_groups`    | `CTRL-G`            | `ig\[.*\]`     | `g:easy_align_ignore_groups`    |
+| `ignore_unmatched` | `CTRL-U`            | `iu[01]`       | `g:easy_align_ignore_unmatched` |
+| `indentation`      | `CTRL-I`            | `i[ksdn]`      | `g:easy_align_indentation`      |
+| `delimiter_align`  | `CTRL-D`            | `d[lrc]`       | `g:easy_align_delimiter_align`  |
+| `align`            | `CTRL-A`            | `a[lrc*]*`     |                                 |
 
 ### Filtering lines
 
 With `filter` option, you can align lines that only match or do not match a
 given pattern. There are several ways to set the pattern.
 
-1. Press `CTRL-F` in interactive mode and input `g/pat/` or `v/pat/`
+1. Press `CTRL-F` in interactive mode and type in `g/pat/` or `v/pat/`
 2. In command-line, it can be written in dictionary format: `{'filter': 'g/pat/'}`
 3. Or in shorthand notation: `g/pat/` or `v/pat/`
 
@@ -482,7 +442,9 @@ For example if you set `ignore_groups` option to be an empty list, you get
 }
 ```
 
-Satisfied? :satisfied:
+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.
 
 ### Ignoring unmatched lines
 
@@ -654,38 +616,38 @@ To recap:
 :EasyAlign! **=
 ```
 
-In addition to these, you can fine-tune alignments over multiple occurrences of
-the delimiters with 'mode_sequence' option. (The option can also be set
-in interactive mode with the special key `CTRL-O`)
+In addition to these, you can fine-tune alignments over multiple occurrences
+of the delimiters with 'align' option. (The option can also be set in
+interactive mode with the special key `CTRL-A`)
 
 ```vim
 " Left alignment over the first two occurrences of delimiters
-:EasyAlign = { 'mode_sequence': 'll' }
+:EasyAlign = { 'align': 'll' }
 
 " Right, left, center alignment over the 1st to 3rd occurrences of delimiters
-:EasyAlign = { 'm': 'rlc' }
+:EasyAlign = { 'a': 'rlc' }
 
 " Using shorthand notation
-:EasyAlign = mrlc
+:EasyAlign = arlc
 
 " Right, left, center alignment over the 2nd to 4th occurrences of delimiters
-:EasyAlign 2=mrlc
+:EasyAlign 2=arlc
 
 " (*) Repeating alignments (default: l, r, or c)
 "   Right, left, center, center, center, center, ...
-:EasyAlign *=mrlc
+:EasyAlign *=arlc
 
 " (**) Alternating alignments (default: lr or rl)
 "   Right, left, center, right, left, center, ...
-:EasyAlign **=mrlc
+:EasyAlign **=arlc
 
 " Right, left, center, center, center, ... repeating alignment
 " over the 3rd to the last occurrences of delimiters
-:EasyAlign 3=mrlc*
+:EasyAlign 3=arlc*
 
 " Right, left, center, right, left, center, ... alternating alignment
 " over the 3rd to the last occurrences of delimiters
-:EasyAlign 3=mrlc**
+:EasyAlign 3=arlc**
 ```
 
 ### Extending alignment rules
@@ -694,15 +656,17 @@ Although the default rules should cover the most of the use cases,
 you can extend the rules by setting a dictionary named `g:easy_align_delimiters`.
 
 You may refer to the definitions of the default alignment rules
-[here](https://github.com/junegunn/vim-easy-align/blob/2.9.0/autoload/easy_align.vim#L29).
+[here](https://github.com/junegunn/vim-easy-align/blob/2.9.6/autoload/easy_align.vim#L32-L46).
 
 #### Examples
 
 ```vim
 let g:easy_align_delimiters = {
 \ '>': { 'pattern': '>>\|=>\|>' },
-\ '/': { 'pattern': '//\+\|/\*\|\*/', 'ignore_groups': ['String'] },
-\ '#': { 'pattern': '#\+', 'ignore_groups': ['String'], 'delimiter_align': 'l' },
+\ '/': {
+\     'pattern':         '//\+\|/\*\|\*/',
+\     'delimiter_align': 'l',
+\     'ignore_groups':   ['!Comment'] },
 \ ']': {
 \     'pattern':       '[[\]]',
 \     'left_margin':   0,
@@ -716,8 +680,8 @@ let g:easy_align_delimiters = {
 \     'stick_to_left': 0
 \   },
 \ 'd': {
-\     'pattern': ' \(\S\+\s*[;=]\)\@=',
-\     'left_margin': 0,
+\     'pattern':      ' \(\S\+\s*[;=]\)\@=',
+\     'left_margin':  0,
 \     'right_margin': 0
 \   }
 \ }
@@ -765,86 +729,12 @@ Advanced examples and use cases
 See [EXAMPLES.md](https://github.com/junegunn/vim-easy-align/blob/master/EXAMPLES.md)
 for more examples.
 
-
 Related work
 ------------
 
-There are two well-known plugins with the same goal as that of vim-easy-align.
-
-- [DrChip's Alignment Tool for Vim](http://www.drchip.org/astronaut/vim/align.html) (herein will be referred to as "Align")
+- [DrChip's Alignment Tool for Vim](http://www.drchip.org/astronaut/vim/align.html)
 - [Tabular](https://github.com/godlygeek/tabular)
 
-Both are great plugins with very large user bases. I actually had been a Tabular
-user for a couple of years before I finally made up my mind to roll out my own.
-
-So why would someone choose vim-easy-align over those two?
-
-Feature-by-feature comparison I believe is not quite useful, since a typical
-user will end up using only a small subset of the features.
-So I will mention just a few core benefits of vim-easy-align.
-
-### Ease of use
-
-As the name implies, vim-easy-align is *easier* to use. Its interactive mode
-allows you to achieve what you want with just a few keystrokes.
-The key sequence is mnemonic, so it's easy to remember and execute.
-It even feels like a native Vim command!
-
-- *Right-align*: `<Enter><Enter>`
-- around the *second* occurrences: `2`
-- of *whitespaces*: `<Space>`
-
-For the simplest cases, Tabular and Align are also easy to use. But sooner or
-later, you will find yourself scratching your head, trying to come up with some
-complex regular expressions.
-
-_"How am I going to align the third to the last word in each line to the right
-without affecting the ones before it?"_
-
-### Clean
-
-vim-easy-align doesn't clutter your workspace with mappings and global
-variables. All you would need is a single mapping to the interactive EasyAlign
-command, and even that is totally up to you.
-
-### Optimized for code editing
-
-vim-easy-align by default performs syntax-aware alignment, which is invaluable
-when editing codes.
-
-Try to come up with a regular expression to correctly format the following code
-snippet. With vim-easy-align under default configuration and a mapping, it can
-be done with just two keystrokes: `<Enter>:`
-
-```javascript
-var jdbc = {
-  // 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"
-};
-```
-
-(To be fair, Align also can be configured to consider syntax highlighting with
-`g:AlignSkip` function reference which should point to a custom function that
-looks up the syntax group of a character on a certain position)
-
-### Thoroughly tested
-
-Virtually every aspect of vim-easy-align is being tested with a comprehensive
-set of test cases using [Vader.vim](https://github.com/junegunn/vader.vim).
-
-### "Okay. So should I switch?"
-
-Maybe, but I can't really say. I have no ambition to make vim-easy-align
-an absolute superior to the others. For some cases, vim-easy-align works better
-than the others, but for some other cases, Tabular or Align.vim might be a
-better choice.
-
-So try it yourself and see if it works for you!
-
 Author
 ------
 

autoload/easy_align.vim

@@ -1,4 +1,4 @@
-" Copyright (c) 2013 Junegunn Choi
+" Copyright (c) 2014 Junegunn Choi
 "
 " MIT License
 "
@@ -31,12 +31,13 @@ set cpo&vim
 
 let s:easy_align_delimiters_default = {
 \  ' ': { 'pattern': ' ',  'left_margin': 0, 'right_margin': 0, 'stick_to_left': 0 },
-\  '=': { 'pattern': '===\|<=>\|\(&&\|||\|<<\|>>\)=\|=\~[#?]\?\|=>\|[:+/*!%^=><&|.-]\?=[#?]\?',
+\  '=': { 'pattern': '===\|<=>\|\(&&\|||\|<<\|>>\)=\|=\~[#?]\?\|=>\|[:+/*!%^=><&|.?-]\?=[#?]\?',
 \                          'left_margin': 1, 'right_margin': 1, 'stick_to_left': 0 },
 \  ':': { 'pattern': ':',  'left_margin': 0, 'right_margin': 1, 'stick_to_left': 1 },
 \  ',': { 'pattern': ',',  'left_margin': 0, 'right_margin': 1, 'stick_to_left': 1 },
 \  '|': { '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': '\\\@<!&\|\\\\',
 \                          'left_margin': 1, 'right_margin': 1, 'stick_to_left': 0 },
 \  '{': { 'pattern': '(\@<!{',
@@ -50,7 +51,8 @@ let s:known_options = {
 \ 'margin_left':   [0, 1], 'margin_right':     [0, 1], 'stick_to_left':   [0],
 \ 'left_margin':   [0, 1], 'right_margin':     [0, 1], 'indentation':     [1],
 \ 'ignore_groups': [3   ], 'ignore_unmatched': [0   ], 'delimiter_align': [1],
-\ 'mode_sequence': [1   ], 'ignores':          [3],    'filter':          [1]
+\ 'mode_sequence': [1   ], 'ignores':          [3],    'filter':          [1],
+\ 'align':         [1   ]
 \ }
 
 let s:option_values = {
@@ -64,7 +66,8 @@ let s:shorthand = {
 \ 'margin_left':   'lm', 'margin_right':     'rm', 'stick_to_left':   'stl',
 \ 'left_margin':   'lm', 'right_margin':     'rm', 'indentation':     'idt',
 \ 'ignore_groups': 'ig', 'ignore_unmatched': 'iu', 'delimiter_align': 'da',
-\ 'mode_sequence': 'm',  'ignores':          'ig', 'filter':          'f'
+\ 'mode_sequence': 'a',  'ignores':          'ig', 'filter':          'f',
+\ 'align':         'a'
 \ }
 
 if exists("*strdisplaywidth")
@@ -89,7 +92,11 @@ function! s:highlighted_as(line, col, groups)
   if empty(a:groups) | return 0 | endif
   let hl = synIDattr(synID(a:line, a:col, 0), 'name')
   for grp in a:groups
-    if hl =~# grp
+    if grp[0] == '!'
+      if hl !~# grp[1:-1]
+        return 1
+      endif
+    elseif hl =~# grp
       return 1
     endif
   endfor
@@ -139,7 +146,7 @@ endfunction
 
 function! s:echon(l, n, r, d, o, warn)
   let tokens = [
-  \ ['Function', ':EasyAlign'],
+  \ ['Function', s:live ? ':LiveEasyAlign' : ':EasyAlign'],
   \ ['ModeMsg', get(s:mode_labels, a:l, a:l)],
   \ ['None', ' ']]
 
@@ -222,8 +229,9 @@ function! s:normalize_options(opts)
     let v = a:opts[k]
     let k = s:fuzzy_lu(k)
     " Backward-compatibility
-    if k == 'margin_left'  | let k = 'left_margin'  | endif
-    if k == 'margin_right' | let k = 'right_margin' | endif
+    if k == 'margin_left'   | let k = 'left_margin'    | endif
+    if k == 'margin_right'  | let k = 'right_margin'   | endif
+    if k == 'mode_sequence' | let k = 'align'          | endif
     let ret[k] = v
     unlet v
   endfor
@@ -609,7 +617,7 @@ function! s:shift_opts(opts, key, vals)
   endif
 endfunction
 
-function! s:interactive(range, modes, n, d, opts, rules, vis, live)
+function! s:interactive(range, modes, n, d, opts, rules, vis, bvis)
   let mode = s:shift(a:modes, 1)
   let n    = a:n
   let d    = a:d
@@ -628,11 +636,11 @@ function! s:interactive(range, modes, n, d, opts, rules, vis, live)
       let undo = 0
       let rdrw = 1
     endif
-    if a:live && !empty(d)
-      let output = s:process(a:range, mode, n, d, s:normalize_options(opts), regx, a:rules, 0)
+    if s:live && !empty(d)
+      let output = s:process(a:range, mode, n, d, s:normalize_options(opts), regx, a:rules, a:bvis)
       let &undolevels = &undolevels " Break undo block
       call s:update_lines(output.todo)
-      let undo = 1
+      let undo = !empty(output.todo)
       let rdrw = 1
     endif
     if rdrw
@@ -663,8 +671,8 @@ function! s:interactive(range, modes, n, d, opts, rules, vis, live)
       endif
     elseif c == 13 " Enter key
       let mode = s:shift(a:modes, 1)
-      if has_key(opts, 'm')
-        let opts.m = mode . strpart(opts.m, 1)
+      if has_key(opts, 'a')
+        let opts.a = mode . strpart(opts.a, 1)
       endif
     elseif ch == '-'
       if empty(n)      | let n = '-'
@@ -705,6 +713,17 @@ function! s:interactive(range, modes, n, d, opts, rules, vis, live)
       call s:shift_opts(opts, 'iu', vals['ignore_unmatched'])
     elseif ch == "\<C-G>"
       call s:shift_opts(opts, 'ig', vals['ignore_groups'])
+    elseif ch == "\<C-P>"
+      if s:live
+        if !empty(d)
+          let ch = d
+          break
+        else
+          let s:live = 0
+        endif
+      else
+        let s:live = 1
+      endif
     elseif c == "\<Left>"
       let opts['stl'] = 1
       let opts['lm']  = 0
@@ -718,18 +737,18 @@ function! s:interactive(range, modes, n, d, opts, rules, vis, live)
       silent! call remove(opts, 'stl')
       silent! call remove(opts, 'lm')
       silent! call remove(opts, 'rm')
-    elseif ch == "\<C-O>"
-      let modes = tolower(s:input("Mode sequence: ", get(opts, 'm', mode), a:vis))
+    elseif ch == "\<C-A>" || ch == "\<C-O>"
+      let modes = tolower(s:input("Alignment ([lrc...][[*]*]): ", get(opts, 'a', mode), a:vis))
       if match(modes, '^[lrc]\+\*\{0,2}$') != -1
-        let opts['m'] = modes
+        let opts['a'] = modes
         let mode      = modes[0]
         while mode != s:shift(a:modes, 1)
         endwhile
       else
-        silent! call remove(opts, 'm')
+        silent! call remove(opts, 'a')
       endif
     elseif ch == "\<C-_>" || ch == "\<C-X>"
-      if a:live && regx && !empty(d)
+      if s:live && regx && !empty(d)
         break
       endif
 
@@ -738,7 +757,7 @@ function! s:interactive(range, modes, n, d, opts, rules, vis, live)
       if !empty(ch) && s:valid_regexp(ch)
         let regx = 1
         let d = ch
-        if !a:live | break | endif
+        if !s:live | break | endif
       else
         let warn = 'Invalid regular expression: '.ch
       endif
@@ -762,7 +781,10 @@ function! s:interactive(range, modes, n, d, opts, rules, vis, live)
       if empty(d)
         if has_key(a:rules, ch)
           let d = ch
-          if !a:live
+          if !s:live
+            if a:vis
+              execute "normal! gv\<esc>"
+            endif
             break
           endif
         else
@@ -781,9 +803,11 @@ function! s:interactive(range, modes, n, d, opts, rules, vis, live)
       endif
     endif
   endwhile
-  if a:live
+  if s:live
     let copts = call('s:summarize', output.summarize)
+    let s:live = 0
     let g:easy_align_last_command = s:echon('', n, regx, d, copts, '')
+    let s:live = 1
   end
   return [mode, n, ch, opts, regx]
 endfunction
@@ -806,8 +830,8 @@ endfunction
 
 let s:shorthand_regex =
   \ '\s*\%('
-  \   .'\(lm\?[0-9]\+\)\|\(rm\?[0-9]\+\)\|\(iu[01]\)\|\(s\%(tl\)\?[01]\)\|'
-  \   .'\(da\?[clr]\)\|\(ms\?[lrc*]\+\)\|\(i\%(dt\)\?[kdsn]\)\|\([gv]/.*/\)\|\(ig\[.*\]\)'
+  \   .'\(lm\?[0-9]\+\)\|\(rm\?[0-9]\+\)\|\(iu[01]\)\|\(\%(s\%(tl\)\?[01]\)\|[<>]\)\|'
+  \   .'\(da\?[clr]\)\|\(\%(ms\?\|a\)[lrc*]\+\)\|\(i\%(dt\)\?[kdsn]\)\|\([gv]/.*/\)\|\(ig\[.*\]\)'
   \ .'\)\+\s*$'
 
 function! s:parse_shorthand_opts(expr)
@@ -821,9 +845,8 @@ function! s:parse_shorthand_opts(expr)
     call s:exit("Invalid expression: ". a:expr)
   else
     let match = matchlist(expr, regex)
-    if empty(match) | break | endif
     for m in filter(match[ 1 : -1 ], '!empty(v:val)')
-      for key in ['lm', 'rm', 'l', 'r', 'stl', 's', 'iu', 'da', 'd', 'ms', 'm', 'ig', 'i', 'g', 'v']
+      for key in ['lm', 'rm', 'l', 'r', 'stl', 's', '<', '>', 'iu', 'da', 'd', 'ms', 'm', 'ig', 'i', 'g', 'v', 'a']
         if stridx(tolower(m), key) == 0
           let rest = strpart(m, len(key))
           if key == 'i' | let key = 'idt' | endif
@@ -832,7 +855,7 @@ function! s:parse_shorthand_opts(expr)
             let key = 'f'
           endif
 
-          if key == 'idt' || index(['d', 'f', 'm'], key[0]) >= 0
+          if key == 'idt' || index(['d', 'f', 'm', 'a'], key[0]) >= 0
             let opts[key] = rest
           elseif key == 'ig'
             try
@@ -845,6 +868,8 @@ function! s:parse_shorthand_opts(expr)
             catch
               call s:exit("Invalid ignore_groups: ". a:expr)
             endtry
+          elseif key =~ '[<>]'
+            let opts['stl'] = key == '<'
           else
             let opts[key] = str2nr(rest)
           endif
@@ -950,9 +975,9 @@ function! s:alternating_modes(mode)
 endfunction
 
 function! s:update_lines(todo)
-    for [line, content] in items(a:todo)
-      call setline(line, s:rtrim(content))
-    endfor
+  for [line, content] in items(a:todo)
+    call setline(line, s:rtrim(content))
+  endfor
 endfunction
 
 function! s:parse_nth(n)
@@ -1020,18 +1045,14 @@ function! s:process(range, mode, n, ch, opts, regexp, rules, bvis)
   let [nth, recur] = s:parse_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, 'mode_sequence', recur == 2 ? s:alternating_modes(a:mode) : a:mode),
+    \ get(dict, 'align', recur == 2 ? s:alternating_modes(a:mode) : a:mode),
     \ recur)
 
-  if recur && a:bvis
-    call s:exit('Recursive alignment is not supported in blockwise-visual mode')
-  endif
-
   let args = [
     \ {}, split(mode_sequence, '\zs'),
     \ {}, {}, a:range[0], a:range[1],
-    \ a:bvis ? min([col("'<"), col("'>")]) : 1,
-    \ a:bvis ? max([col("'<"), col("'>")]) : 0,
+    \ a:bvis             ? min([col("'<"), col("'>")]) : 1,
+    \ (!recur && a:bvis) ? max([col("'<"), col("'>")]) : 0,
     \ nth, recur, dict ]
   while len(args) > 1
     let args = call('s:do_align', args)
@@ -1045,11 +1066,11 @@ endfunction
 function s:summarize(opts, recur, mode_sequence)
   let copts = s:compact_options(a:opts)
   let nbmode = s:interactive_modes(0)[0]
-  if !has_key(copts, 'm') && (
+  if !has_key(copts, 'a') && (
     \  (a:recur == 2 && s:alternating_modes(nbmode) != a:mode_sequence) ||
     \  (a:recur != 2 && (a:mode_sequence[0] != nbmode || len(a:mode_sequence) > 1))
     \ )
-    call extend(copts, { 'm': a:mode_sequence })
+    call extend(copts, { 'a': a:mode_sequence })
   endif
   return copts
 endfunction
@@ -1067,10 +1088,7 @@ function! s:align(bang, live, visualmode, first_line, last_line, expr)
   let range = [a:first_line, a:last_line]
   let modes = s:interactive_modes(a:bang)
   let mode  = modes[0]
-
-  if bvis && a:live
-    call s:exit('Live mode is not supported in blockwise-visual mode')
-  endif
+  let s:live = a:live
 
   let rules = s:easy_align_delimiters_default
   if exists('g:easy_align_delimiters')
@@ -1084,11 +1102,11 @@ function! s:align(bang, live, visualmode, first_line, last_line, expr)
   try
     if bypass_fold | let &l:foldmethod = 'manual' | endif
 
-    if empty(n) && empty(ch) || a:live
-      let [mode, n, ch, opts, regexp] = s:interactive(range, copy(modes), n, ch, opts, rules, vis, a:live)
+    if empty(n) && empty(ch) || s:live
+      let [mode, n, ch, opts, regexp] = s:interactive(range, copy(modes), n, ch, opts, rules, vis, bvis)
     endif
 
-    if !a:live
+    if !s:live
       let output = s:process(range, mode, n, ch, s:normalize_options(opts), regexp, rules, bvis)
       call s:update_lines(output.todo)
       let copts = call('s:summarize', output.summarize)

plugin/easy_align.vim

@@ -1,4 +1,4 @@
-" Copyright (c) 2013 Junegunn Choi
+" Copyright (c) 2014 Junegunn Choi
 "
 " MIT License
 "
@@ -75,30 +75,31 @@ function! s:set_repeat()
 endfunction
 
 function! s:generic_easy_align_op(type, vmode, live)
+  if !&modifiable
+    if a:vmode
+      normal! gv
+    endif
+    return
+  endif
   let sel_save = &selection
   let &selection = "inclusive"
 
   if a:vmode
     let vmode = a:type
+    let [l1, l2] = ["'<", "'>"]
     call s:remember_visual(vmode)
   else
-    let tail = "\<C-c>"
-    if a:type == 'line'
-      silent execute "normal! '[V']".tail
-    elseif a:type == 'block'
-      silent execute "normal! `[\<C-V>`]".tail
-    else
-      silent execute "normal! `[v`]".tail
-    endif
     let vmode = ''
+    let [l1, l2] = [line("'["), line("']")]
     unlet! s:last_visual
   endif
 
   try
+    let range = l1.','.l2
     if get(g:, 'easy_align_need_repeat', 0)
-      execute "'<,'>". g:easy_align_last_command
+      execute range . g:easy_align_last_command
     else
-      '<,'>call easy_align#align('<bang>' == '!', a:live, vmode, '')
+      execute range . "call easy_align#align('<bang>' == '!', a:live, vmode, '')"
     end
     call s:set_repeat()
   finally

test/blockwise.vader

@@ -0,0 +1,22 @@
+Include: include/setup.vader
+
+Given clojure:
+  (def world [[1      1 1 1       1]
+              [999 999 999 999 1]
+              [1 1 1 1 1]
+              [1 999 999 999 999]
+              [1 1 1 1 1]])
+
+Do (Recursive alignment in blockwise-visual mode):
+  f[;
+  \<C-V>G
+  \<Enter>*\<Space>
+
+Expect clojure:
+  (def world [[1   1   1   1   1]
+              [999 999 999 999 1]
+              [1   1   1   1   1]
+              [1   999 999 999 999]
+              [1   1   1   1   1]])
+
+Include: include/teardown.vader

test/commandline.vader

@@ -40,14 +40,21 @@ Expect:
   apple;:;;banana   :: cake
   data  ;; exchange:;::format
 
-Execute (shorthand notation of mode_sequence and margin):
+Execute (DEPRECATED: shorthand notation of mode_sequence and margin):
   %EasyAlign/[:;]\+/mrc*l2r2
 
 Expect:
   apple  ;:;;   banana     ::   cake
    data    ;;  exchange  :;::  format
 
-Execute (deep indentation):
+Execute (shorthand notation of align and margin):
+  %EasyAlign/[:;]\+/arc*l2r2
+
+Expect:
+  apple  ;:;;   banana     ::   cake
+   data    ;;  exchange  :;::  format
+
+Execute (DEPRECATED: deep indentation):
   %EasyAlign/[:;]\+/mrc*l2r2
   %EasyAlign*/[:;]\+/idmrl*
 
@@ -55,6 +62,14 @@ Expect:
    apple ;:;; banana     :: cake
     data   ;; exchange :;:: format
 
+Execute (deep indentation):
+  %EasyAlign/[:;]\+/arc*l2r2
+  %EasyAlign*/[:;]\+/idarl*
+
+Expect:
+   apple ;:;; banana     :: cake
+    data   ;; exchange :;:: format
+
 Execute (stick_to_left):
   %EasyAlign*/[:;]\+/stl1l0dlrm3
 
@@ -62,6 +77,20 @@ Expect:
   apple;:;;   banana::       cake
   data;;      exchange:;::   format
 
+Execute (<):
+  %EasyAlign*/[:;]\+/<l0dlrm3
+
+Expect:
+  apple;:;;   banana::       cake
+  data;;      exchange:;::   format
+
+Execute (>):
+  %EasyAlign*/[:;]\+/l0dl<>rm3
+
+Expect:
+  apple;:;;   banana  ::     cake
+  data ;;     exchange:;::   format
+
 Execute (different regular expression):
   %EasyAlign*/../{'lm':'<','rm':'>'}
 

test/extra.vader

@@ -0,0 +1,13 @@
+Include: include/setup.vader
+
+Before:
+  set nomodifiable
+After:
+  set modifiable
+  AssertEqual "hello\nworld\n", @"
+Given:
+  hello
+  world
+Do (#43 Do nothing when nomodifiable):
+  vip\<enter>\<enter>\<enter>y
+

test/fixed.vader

@@ -139,4 +139,77 @@ Expect:
   	## 	n2gv = {}
   	# 	n2vt = {}
 
+Given (Some text):
+  a,b,c
+
+  d,e,f
+
+Do (Select 1st line, align 3rd line):
+- First line
+  V\<esc>
+- Last line
+  G
+- Align
+  \<space>Aip*,
+- Previous selection
+  gv
+- Upcase
+  U
+
+Expect:
+  A,B,C
+
+  d, e, f
+
+Given c (#40 Ignored delimiters in LiveEasyAlign causes spurious undo):
+  printf("foo = %f\n", foo);
+  printf("foobar = %f\n", foobar);
+
+Do:
+  gUiw
+  :%LiveEasyAlign\<enter>
+  =\<bs>==
+
+Expect c:
+  PRINTF("foo = %f\n", foo);
+  printf("foobar = %f\n", foobar);
+
+* #50 Error when using delimiter alignment option
+Given:
+  a|bbb|c
+  aa|bb|cc
+
+Do (#50 EasyAlign command with 'a' option):
+  :%EasyAlign {'a': 'l'}\<cr>
+  \<cr>
+  *|
+
+Expect (Some text):
+   a | bbb |  c
+  aa |  bb | cc
+
+* #51 Repeat of visual <Plug>(LiveEasyAlign) broken
+Do (#51/#52 <Plug>(EasyAlignRepeat) in visual mode):
+  V\<space>\<enter>\<enter>*||
+  G
+  V\<space>.
+
+Expect:
+  a | bbb | c
+  aa | bb | cc
+
+* #65 ?=
+Given:
+  a?=b
+  aa-=bb
+  aaa?=bbb
+
+Do (#65 Alignment around ?=):
+  \<space>Aip=
+
+Expect:
+  a   ?= b
+  aa  -= bb
+  aaa ?= bbb
+
 Include: include/teardown.vader

test/include/setup.vader

@@ -30,3 +30,9 @@ Execute (Clean up test environment):
   nmap <leader>A       <Plug>(EasyAlign)
   vmap <leader>.       <Plug>(EasyAlignRepeat)
 
+  silent! call plug#load('vim-easy-align')
+
+Before:
+After:
+Given:
+

test/include/teardown.vader

@@ -1,3 +1,4 @@
-Execute:
+Given:
+Execute (Restoring test environment):
   Restore
 

test/interactive.vader

@@ -19,6 +19,17 @@ Expect:
   111  22    333  444 55555 6666 7   88888
   1111 2     33   444 555   66   777 8
 
+Do (left-align / cursor position retained):
+  vGww
+  \<Enter>
+  *\<Space>D
+
+Expect:
+  1    22222 33   444 555   6666 7   888
+  11   222   3333 4   55    6666 77  888
+  111  22    333  444 55555 6666 7   88888
+  1111 2 
+
 Do (left-align using operator map):
   \<Space>Aip*\<Space>
 
@@ -485,6 +496,56 @@ Expect:
   |)batch_size(|) Fixnum(|)nil    (|)number of maximum items to be assigned at once(|
   |)logger    (|) Logger(|)nil    (|)                logger instance for debug logs(|
 
+Do (Switching to live interactive mode):
+  vip\<Enter>
+* Switch to live interactive mode
+  \<C-P>
+  |
+  \<C-L><\<Enter>
+  \<C-R>>\<Enter>
+  ***
+  **
+  \<BS>\<BS>\<BS>
+  **|\<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<|
+
+Do (Toggling live interactive mode (delimiter entered)):
+  vip\<Enter>
+* Enable live mode
+  \<C-P>
+  |*
+* Disable live mode
+  \<C-P>
+  gg2jdG
+
+Expect:
+  | Option     | Type    | Default | Description                                    |
+  | --         | --      | --      | --                                             |
+
+Do (Toggling live interactive mode (delimiter not entered)):
+  vip\<Enter>
+* Enable live mode
+  \<C-P>
+  \<Enter>
+* Disable live mode
+  \<C-P>
+  *|
+  gg2jdG
+
+Expect:
+  |     Option |    Type | Default |                                    Description |
+  |         -- |      -- |      -- |                                             -- |
+
 Do (live interactive mode!):
   vip\<Space>r\<Enter>
   |
@@ -758,7 +819,7 @@ Expect ruby:
   dddddd   /=      123
   gg      <=>       ee
 
-Do (Alignment using mode_sequence, delimiter_align):
+Do (DEPRECATED: Alignment using mode_sequence, delimiter_align):
   vip\<Enter>\<C-O>\<Backspace>cr*\<Enter>\<C-D>=
 
 Expect ruby:
@@ -787,7 +848,37 @@ Expect ruby:
       dddddd      /=       123
         gg        <=>       ee
 
-Do (mode_sequence starting from 2nd, delimiter_align = center):
+Do (Alignment using align, delimiter_align):
+  vip\<Enter>\<C-A>\<Backspace>cr*\<Enter>\<C-D>=
+
+Expect ruby:
+         a        =
+         a        =          1
+       bbbb       .=         2
+      ccccccc     =          3
+  ccccccccccccccc
+        ddd       =          #
+       eeee       ===      eee =  eee =   eee = f
+        fff       =        ggg +=  gg &&=  gg
+         g        !=  hhhhhhhh == # 8
+         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
+
+
+Do (DEPRECATED: mode_sequence starting from 2nd, delimiter_align = center):
   vip\<Enter>\<C-O>\<Backspace>rc**\<Enter>\<C-D>\<C-D>2=
 
 Expect ruby:
@@ -816,6 +907,35 @@ Expect ruby:
   dddddd /=            123
   gg <=>                ee
 
+Do (align starting from 2nd, delimiter_align = center):
+  vip\<Enter>\<C-A>\<Backspace>rc**\<Enter>\<C-D>\<C-D>2=
+
+Expect ruby:
+  a =
+  a =                    1
+  bbbb .=                2
+  ccccccc =              3
+  ccccccccccccccc
+  ddd =                  #
+  eeee ===             eee =  eee  =  eee = f
+  fff =                ggg += gg  &&=  gg
+  g !=            hhhhhhhh == # 8
+  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
+
 Do (around all =s, do not ignore unmatched):
   vip\<Enter>\<C-U>
   \<C-L>0\<Enter>
@@ -893,10 +1013,6 @@ Expect ruby:
   apricot = 'DAD' +      'F#AD'
   banana = 'Gros Michel' ## comment 2
 
-Execute (define # rule):
-  let g:easy_align_delimiters =
-  \ { '#': { 'pattern': '#\+', 'ignores': ['String'], 'delimiter_align': 'l' } }
-
 Do (using # rule):
   vip\<Enter>\<C-U>#
 
@@ -1572,7 +1688,7 @@ Do (Blockwise-visual-operator is also repeatable):
   f1
   4j
   \<Enter>:
-  7G
+  7G0
   fa
   .