Fix regular expression for = rule

Bug reported by @cvlmtg
Extend default = rule to include ?=
2025-11-18 06:43:40 -05:00 · 2015-07-20 00:39:09 +09:00 · 2015-07-15 21:57:33 +09:00 · 2014-12-14 02:48:28 +09:00 · 2014-12-10 12:01:39 +09:00 · 2014-12-10 11:53:28 +09:00
18 changed files with 1602 additions and 698 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,3 +1,4 @@
+.travis.yml    export-ignore
 .gitattributes export-ignore
 .gitignore     export-ignore
 doc/tags       export-ignore
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,15 @@
+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+=.
+  filetype plugin indent on
+  syntax enable
+  VIMRC) -c 'Vader! test/*' > /dev/null
--- a/EXAMPLES.md
+++ b/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
--- a/README.md
+++ b/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.gif))
+(Too fast? Slower GIF is [here](https://raw.githubusercontent.com/junegunn/i/master/vim-easy-align-slow.gif))

 Features
 --------
@@ -22,70 +22,112 @@ 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
+------------------------
+
+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 for a motion/text object (e.g. gaip)
+nmap ga <Plug>(EasyAlign)
+```
+
+And with the following lines of text,
+
+```
+apple   =red
+grass+=green
+sky-=   blue
+```
+
+try these commands:
+
+- `vip<Enter>=`
+    - `v`isual-select `i`nner `p`aragraph
+    - Start EasyAlign command (`<Enter>`)
+    - 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.

 Usage
 -----

-_vim-easy-align_ defines `:EasyAlign` command (and the right-align
-variant `:EasyAlign!`) for visual mode.
-
-| 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 `,`.
+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
+
+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.
-For convenience, it is advised that you define a mapping for triggering it in
-your `.vimrc`.
+The following sections will assume that you have `<Plug>(EasyAlign)` mappings in
+your .vimrc as below:

 ```vim
-vnoremap <silent> <Enter> :EasyAlign<Enter>
+" 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)
 ```

-(Of course you can use any key combination as the trigger. e.g. `<Leader>a`)
+With these mappings, you can align text with only a few keystrokes.

-With the mapping, you can align selected lines of text with only a few keystrokes.
-
-1. `<Enter>` key 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
@@ -96,41 +138,41 @@ 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                                                |
 | ------------- | -------------------------------------------------------------------- |
-| `<space>`     | General alignment around whitespaces                                 |
+| `<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 `\\`)                                  |
-| &#124;        | Table markdown                                                       |
+| `#`           | 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>`    | Alignment around 1st whitespaces                        | `:'<,'>EasyAlign\ `    |
-| `<Enter>2<space>`   | Alignment around 2nd whitespaces                        | `:'<,'>EasyAlign2\ `   |
-| `<Enter>-<space>`   | Alignment around the last whitespaces                   | `:'<,'>EasyAlign-\ `   |
-| `<Enter>-2<space>`  | Alignment around the 2nd to last whitespaces            | `:'<,'>EasyAlign-2\ `  |
-| `<Enter>:`          | Alignment around 1st colon (`key:  value`)              | `:'<,'>EasyAlign:`     |
-| `<Enter><Right>:`   | Alignment around 1st colon (`key : value`)              | `:'<,'>EasyAlign:s0l1` |
-| `<Enter>=`          | Alignment around 1st operators with =                   | `:'<,'>EasyAlign=`     |
-| `<Enter>2=`         | Alignment around 2nd operators with =                   | `:'<,'>EasyAlign2=`    |
-| `<Enter>3=`         | Alignment around 3rd operators with =                   | `:'<,'>EasyAlign3=`    |
-| `<Enter>*=`         | Alignment around all operators with =                   | `:'<,'>EasyAlign*=`    |
-| `<Enter>**=`        | Left-right alternating alignment around all = operators | `:'<,'>EasyAlign**=`   |
-| `<Enter><Enter>=`   | Right alignment around 1st equals signs                 | `:'<,'>EasyAlign!=`    |
-| `<Enter><Enter>**=` | Right-left alternating alignment around all = operators | `:'<,'>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

@@ -140,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
@@ -150,7 +192,7 @@ keys listed below. The meaning of each option will be described in
 [the following sections](https://github.com/junegunn/vim-easy-align#alignment-options).

 | Key       | Option             | Values                                             |
-| --------  | ------------------ | -------------------------------------------------- |
+| --------- | ------------------ | -------------------------------------------------- |
 | `CTRL-F`  | `filter`           | Input string (`[gv]/.*/?`)                         |
 | `CTRL-I`  | `indentation`      | shallow, deep, none, keep                          |
 | `CTRL-L`  | `left_margin`      | Input number or string                             |
@@ -158,70 +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>
-```
-
 ### 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 a mapping such as
-follows in addition to the one for `:EasyAlign` command.
-
-```vim
-vnoremap <silent> <Leader><Enter> :LiveEasyAlign<Enter>
-```
+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
@@ -237,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
@@ -289,25 +317,6 @@ my_hash = { :a   => 1,
 However, in this case, we don't really need blockwise visual mode
 since the same can be easily done using the negative N-th parameter: `<Enter>-=`

-### EasyAlign as Vim operator
-
-You can define an operator function which executes EasyAlign command, so that it
-can be used with a Vim movement.
-
-```vim
-function! s:easy_align_1st_eq(type, ...)
-  '[,']EasyAlign=
-endfunction
-nnoremap <Leader>= :set opfunc=<SID>easy_align_1st_eq<Enter>g@
-
-function! s:easy_align_1st_colon(type, ...)
-  '[,']EasyAlign:
-endfunction
-nnoremap <Leader>: :set opfunc=<SID>easy_align_1st_colon<Enter>g@
-```
-
-Now without going into visual mode, you can align the lines in the paragraph
-by `<Leader>=ip` or `<Leader>:ip`.

 Alignment options
 -----------------
@@ -326,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):

@@ -335,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/`

@@ -433,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

@@ -576,8 +587,6 @@ daisy    = 4
 eggplant = 5
 ```

-Notice that `idt` is fuzzy-matched to `indentation`.
-
 In interactive mode, you can change the option value with `CTRL-I` key.

 ### Alignments over multiple occurrences of delimiters
@@ -607,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
@@ -647,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.6.1/autoload/easy_align.vim#L29).
+[here](https://github.com/junegunn/vim-easy-align/blob/2.9.6/autoload/easy_align.vim#L32-L46).

-#### Example
+#### 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,
@@ -669,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
 \   }
 \ }
@@ -718,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
 ------

--- a/autoload/easy_align.vim
+++ b/autoload/easy_align.vim
@@ -1,4 +1,4 @@
-" Copyright (c) 2013 Junegunn Choi
+" Copyright (c) 2014 Junegunn Choi
 "
 " MIT License
 "
@@ -26,14 +26,18 @@ if exists("g:loaded_easy_align")
 endif
 let g:loaded_easy_align = 1

+let s:cpo_save = &cpo
+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': '(\@<!{',
@@ -47,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 = {
@@ -61,12 +66,13 @@ 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("*strwidth")
+if exists("*strdisplaywidth")
  function! s:strwidth(str)
-    return strwidth(a:str) + len(matchstr(a:str, '^\t*')) * (&tabstop - 1)
+    return strdisplaywidth(a:str)
  endfunction
 else
  function! s:strwidth(str)
@@ -74,11 +80,23 @@ else
  endfunction
 endif

+function! s:ceil2(v)
+  return a:v % 2 == 0 ? a:v : a:v + 1
+endfunction
+
+function! s:floor2(v)
+  return a:v % 2 == 0 ? a:v : a:v - 1
+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')
  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
@@ -128,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', ' ']]

@@ -211,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
@@ -332,7 +351,7 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, nth, r
  let mode       = a:modes[0]
  let lines      = {}
  let min_indent = -1
-  let max = { 'pivot_len': 0.0, 'token_len': 0, 'just_len': 0, 'delim_len': 0,
+  let max = { 'pivot_len2': 0, 'token_len': 0, 'just_len': 0, 'delim_len': 0,
        \ 'indent': 0, 'tokens': 0, 'strip_len': 0 }
  let d = a:dict
  let [f, fx] = s:parse_filter(d.filter)
@@ -410,8 +429,9 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, nth, r
    let max.delim_len = max([max.delim_len, s:strwidth(delim)])

    if mode ==? 'c'
-      if max.pivot_len < pw + tw / 2.0
-        let max.pivot_len = pw + tw / 2.0
+      let pivot_len2 = pw * 2 + tw
+      if max.pivot_len2 < pivot_len2
+        let max.pivot_len2 = pivot_len2
      endif
      let max.strip_len = max([max.strip_len, s:strwidth(s:trim(token))])
    endif
@@ -432,9 +452,9 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, nth, r
    end

    if idt !=? 'k'
-      let max.just_len  = 0
-      let max.token_len = 0
-      let max.pivot_len = 0
+      let max.just_len   = 0
+      let max.token_len  = 0
+      let max.pivot_len2 = 0

      for [line, elems] in items(lines)
        let [nth, prefix, token, delim] = elems
@@ -460,8 +480,9 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, nth, r
        let max.token_len = max([max.token_len, tw])
        let max.just_len  = max([max.just_len,  pw + tw])
        if mode ==? 'c'
-          if max.pivot_len < pw + tw / 2.0
-            let max.pivot_len = pw + tw / 2.0
+          let pivot_len2 = pw * 2 + tw
+          if max.pivot_len2 < pivot_len2
+            let max.pivot_len2 = pivot_len2
          endif
        endif

@@ -496,15 +517,15 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, nth, r
      let indent = matchstr(token, '^\s*')
      let token = indent . pad . s:ltrim(token)
    elseif mode ==? 'c'
-      let p1  = max.pivot_len - (pw + tw / 2.0)
-      let p2  = (max.token_len - tw) / 2.0
-      let pf1 = floor(p1)
-      if pf1 < p1 | let p2 = ceil(p2)
-      else        | let p2 = floor(p2)
+      let p1  = max.pivot_len2 - (pw * 2 + tw)
+      let p2  = max.token_len - tw
+      let pf1 = s:floor2(p1)
+      if pf1 < p1 | let p2 = s:ceil2(p2)
+      else        | let p2 = s:floor2(p2)
      endif
-      let strip = float2nr(ceil((max.token_len - max.strip_len) / 2.0))
+      let strip = s:ceil2(max.token_len - max.strip_len) / 2
      let indent = matchstr(token, '^\s*')
-      let token = indent. repeat(' ', float2nr(pf1)) .s:ltrim(token). repeat(' ', float2nr(p2))
+      let token = indent. repeat(' ', pf1 / 2) .s:ltrim(token). repeat(' ', p2 / 2)
      let token = substitute(token, repeat(' ', strip) . '$', '', '')

      if d.stick_to_left
@@ -546,7 +567,7 @@ function! s:do_align(todo, modes, all_tokens, all_delims, fl, ll, fc, lc, nth, r
    " Adjust indentation of the lines starting with a delimiter
    let lpad = ''
    if nth == 0
-      let ipad = repeat(' ', min_indent - len(token.ml))
+      let ipad = repeat(' ', min_indent - s:strwidth(token.ml))
      if mode ==? 'l'
        let token = ipad . token
      else
@@ -596,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
@@ -615,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
@@ -650,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 = '-'
@@ -692,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
@@ -705,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

@@ -725,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
@@ -749,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
@@ -768,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
@@ -793,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)
@@ -808,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
@@ -819,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
@@ -832,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
@@ -937,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)
@@ -1007,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)
@@ -1032,26 +1066,29 @@ 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

-function! s:align(bang, live, first_line, last_line, expr)
+function! s:align(bang, live, visualmode, first_line, last_line, expr)
  " Heuristically determine if the user was in visual mode
-  let vis   = a:first_line == line("'<") && a:last_line == line("'>")
-  let bvis  = vis && char2nr(visualmode()) == 22 " ^V
+  if empty(a:visualmode)
+    let vis  = a:first_line == line("'<") && a:last_line == line("'>")
+    let bvis = vis && visualmode() == "\<C-V>"
+  " Visual-mode explicitly given
+  else
+    let vis  = 1
+    let bvis = a:visualmode == "\<C-V>"
+  end
  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')
@@ -1065,11 +1102,11 @@ function! s:align(bang, live, 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)
@@ -1080,10 +1117,13 @@ function! s:align(bang, live, first_line, last_line, expr)
  endtry
 endfunction

-function! easy_align#align(bang, live, expr) range
+function! easy_align#align(bang, live, visualmode, expr) range
  try
-    call s:align(a:bang, a:live, a:firstline, a:lastline, a:expr)
+    call s:align(a:bang, a:live, a:visualmode, a:firstline, a:lastline, a:expr)
  catch 'exit'
  endtry
 endfunction

+let &cpo = s:cpo_save
+unlet s:cpo_save
+
--- a/doc/easy_align.txt
+++ b/doc/easy_align.txt
--- a/plugin/easy_align.vim
+++ b/plugin/easy_align.vim
@@ -1,4 +1,4 @@
-" Copyright (c) 2013 Junegunn Choi
+" Copyright (c) 2014 Junegunn Choi
 "
 " MIT License
 "
@@ -26,5 +26,117 @@ 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, '', <q-args>)
+command! -nargs=* -range -bang LiveEasyAlign <line1>,<line2>call easy_align#align('<bang>' == '!', 1, '', <q-args>)
+
+let s:last_command = 'EasyAlign'
+
+function! s:abs(v)
+  return a:v >= 0 ? a:v : - a:v
+endfunction
+
+function! s:remember_visual(mode)
+  let s:last_visual = [a:mode, s:abs(line("'>") - line("'<")), s:abs(col("'>") - col("'<"))]
+endfunction
+
+function! s:repeat_visual()
+  let [mode, ldiff, cdiff] = s:last_visual
+  let cmd = 'normal! '.mode
+  if ldiff > 0
+    let cmd .= ldiff . 'j'
+  endif
+
+  let ve_save = &virtualedit
+  try
+    if mode == "\<C-V>"
+      if cdiff > 0
+        let cmd .= cdiff . 'l'
+      endif
+      set virtualedit+=block
+    endif
+    execute cmd.":\<C-r>=g:easy_align_last_command\<Enter>\<Enter>"
+    call s:set_repeat()
+  finally
+    if ve_save != &virtualedit
+      let &virtualedit = ve_save
+    endif
+  endtry
+endfunction
+
+function! s:repeat_in_visual()
+  if exists('g:easy_align_last_command')
+    call s:remember_visual(visualmode())
+    call s:repeat_visual()
+  endif
+endfunction
+
+function! s:set_repeat()
+  silent! call repeat#set("\<Plug>(EasyAlignRepeat)")
+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 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 range . g:easy_align_last_command
+    else
+      execute range . "call easy_align#align('<bang>' == '!', a:live, vmode, '')"
+    end
+    call s:set_repeat()
+  finally
+    let &selection = sel_save
+  endtry
+endfunction
+
+function! s:easy_align_op(type, ...)
+  call s:generic_easy_align_op(a:type, a:0, 0)
+endfunction
+
+function! s:live_easy_align_op(type, ...)
+  call s:generic_easy_align_op(a:type, a:0, 1)
+endfunction
+
+function! s:easy_align_repeat()
+  if exists('s:last_visual')
+    call s:repeat_visual()
+  else
+    try
+      let g:easy_align_need_repeat = 1
+      normal! .
+    finally
+      unlet! g:easy_align_need_repeat
+    endtry
+  endif
+endfunction
+
+nnoremap <silent> <Plug>(EasyAlign) :set opfunc=<SID>easy_align_op<Enter>g@
+vnoremap <silent> <Plug>(EasyAlign) :<C-U>call <SID>easy_align_op(visualmode(), 1)<Enter>
+nnoremap <silent> <Plug>(LiveEasyAlign) :set opfunc=<SID>live_easy_align_op<Enter>g@
+vnoremap <silent> <Plug>(LiveEasyAlign) :<C-U>call <SID>live_easy_align_op(visualmode(), 1)<Enter>
+
+" vim-repeat support
+nnoremap <silent> <Plug>(EasyAlignRepeat) :call <SID>easy_align_repeat()<Enter>
+vnoremap <silent> <Plug>(EasyAlignRepeat) :<C-U>call <SID>repeat_in_visual()<Enter>
+
+" Backward-compatibility (deprecated)
+nnoremap <silent> <Plug>(EasyAlignOperator) :set opfunc=<SID>easy_align_op<Enter>g@
+
--- a/test/README.md
+++ b/test/README.md
@@ -7,7 +7,7 @@ Test cases for vim-easy-align

 ### Run

-```vim
-:Vader*
+```
+./run
 ```

--- a/test/blockwise.vader
+++ b/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
--- a/test/commandline.vader
+++ b/test/commandline.vader
@@ -1,14 +1,4 @@
-Execute (Clean up test environment):
-  Save g:easy_align_ignore_groups,     g:easy_align_ignore_unmatched
-  Save g:easy_align_indentation,       g:easy_align_delimiter_align
-  Save g:easy_align_interactive_modes, g:easy_align_bang_interactive_modes
-  Save g:easy_align_delimiters
-
-  let g:easy_align_delimiters = {}
-  silent! unlet g:easy_align_ignore_groups
-  silent! unlet g:easy_align_ignore_unmatched
-  silent! unlet g:easy_align_indentation
-  silent! unlet g:easy_align_delimiter_align
+Include: include/setup.vader

 Given (fruits):
  apple;:;;banana::cake
@@ -50,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*

@@ -65,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

@@ -72,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':'>'}

@@ -161,5 +180,4 @@ Expect javascript:
    "user:    pass": "r00t: pa55"
  };

-Execute:
-  Restore
+Include: include/teardown.vader
--- a/test/extra.vader
+++ b/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
+
--- a/test/fixed.vader
+++ b/test/fixed.vader
@@ -1,3 +1,5 @@
+Include: include/setup.vader
+
 Given (Table):
  |a|b|c|d|
  | -|-|>-|-|
@@ -40,3 +42,174 @@ Execute:
 Expect:
  a <|>b <|>c <|
  aa<|>bb<|>cc<|
+
+Given (Tab-indented code (#20)):
+  class MyUnitTest(unittest.TestCase):
+  	def test_base(self):
+  		n2f = {}
+  		n2v = {}
+  		f2v = {}
+  		n2gv = {}
+  		n2vt = {}
+
+Execute:
+  set tabstop=1
+  %EasyAlign=
+
+Expect:
+  class MyUnitTest(unittest.TestCase):
+  	def test_base(self):
+  		n2f  = {}
+  		n2v  = {}
+  		f2v  = {}
+  		n2gv = {}
+  		n2vt = {}
+
+Execute:
+  set tabstop=2
+  %EasyAlign=
+
+Expect:
+  class MyUnitTest(unittest.TestCase):
+  	def test_base(self):
+  		n2f  = {}
+  		n2v  = {}
+  		f2v  = {}
+  		n2gv = {}
+  		n2vt = {}
+
+Execute:
+  set tabstop=4
+  %EasyAlign=
+
+Expect:
+  class MyUnitTest(unittest.TestCase):
+  	def test_base(self):
+  		n2f  = {}
+  		n2v  = {}
+  		f2v  = {}
+  		n2gv = {}
+  		n2vt = {}
+
+Execute:
+  set tabstop=8
+  %EasyAlign=
+
+Expect:
+  class MyUnitTest(unittest.TestCase):
+  	def test_base(self):
+  		n2f  = {}
+  		n2v  = {}
+  		f2v  = {}
+  		n2gv = {}
+  		n2vt = {}
+
+Execute:
+  set tabstop=12
+  %EasyAlign=
+
+Expect:
+  class MyUnitTest(unittest.TestCase):
+  	def test_base(self):
+  		n2f  = {}
+  		n2v  = {}
+  		f2v  = {}
+  		n2gv = {}
+  		n2vt = {}
+
+Given (Tab-indented code (#20)):
+  class MyUnitTest(unittest.TestCase):
+  	def test_base(self):
+  	# 	n2f= {}
+  	## 	n2v= {}
+  	# 	f2v = {}
+  	## 	n2gv  = {}
+  	# 	n2vt   = {}
+
+Execute:
+  set tabstop=12
+  %EasyAlign=
+
+Expect:
+  class MyUnitTest(unittest.TestCase):
+  	def test_base(self):
+  	# 	n2f  = {}
+  	## 	n2v  = {}
+  	# 	f2v  = {}
+  	## 	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
--- a/test/fixme.vader
+++ b/test/fixme.vader
@@ -1,3 +1,5 @@
+Include: include/setup.vader
+
 # It is currently possible that EasyAlign command incorrectly judges
 # that it was executed in block-wise visual mode
 Given:
@@ -18,3 +20,5 @@ Do (TODO Workaround: reset visualmode() on error):
 Expect:
  a | b | c

+Include: include/teardown.vader
+
--- a/test/include/setup.vader
+++ b/test/include/setup.vader
@@ -0,0 +1,38 @@
+Execute (Clean up test environment):
+  Save g:easy_align_ignore_groups,     g:easy_align_ignore_unmatched
+  Save g:easy_align_indentation,       g:easy_align_delimiter_align
+  Save g:easy_align_interactive_modes, g:easy_align_bang_interactive_modes
+  Save g:easy_align_delimiters,        g:easy_align_bypass_fold
+  Save &tabstop, mapleader
+
+  unlet! g:easy_align_ignore_groups
+  unlet! g:easy_align_ignore_unmatched
+  unlet! g:easy_align_indentation
+  unlet! g:easy_align_delimiter_align
+  unlet! g:easy_align_interactive_modes
+  unlet! g:easy_align_bang_interactive_modes
+  unlet! g:easy_align_bypass_fold
+
+  let g:easy_align_delimiters = {}
+  let mapleader = ' '
+  vnoremap <silent> r<Enter>         :EasyAlign!<Enter>
+  vnoremap <silent> <Leader>r<Enter> :LiveEasyAlign!<Enter>
+
+  " " Legacy
+  " vnoremap <silent> <Enter>          :EasyAlign<Enter>
+  " vnoremap <silent> <Leader><Enter>  :LiveEasyAlign<Enter>
+  " nmap <leader>A <Plug>(EasyAlignOperator)
+
+  set ts=2
+
+  vmap <Enter>         <Plug>(EasyAlign)
+  vmap <leader><Enter> <Plug>(LiveEasyAlign)
+  nmap <leader>A       <Plug>(EasyAlign)
+  vmap <leader>.       <Plug>(EasyAlignRepeat)
+
+  silent! call plug#load('vim-easy-align')
+
+Before:
+After:
+Given:
+
--- a/test/include/teardown.vader
+++ b/test/include/teardown.vader
@@ -0,0 +1,4 @@
+Given:
+Execute (Restoring test environment):
+  Restore
+
--- a/test/interactive.vader
+++ b/test/interactive.vader
@@ -1,24 +1,4 @@
-Execute (Clean up test environment):
-  Save g:easy_align_ignore_groups,     g:easy_align_ignore_unmatched
-  Save g:easy_align_indentation,       g:easy_align_delimiter_align
-  Save g:easy_align_interactive_modes, g:easy_align_bang_interactive_modes
-  Save g:easy_align_delimiters
-  Save mapleader
-
-  " TODO: revert after test
-  silent! unlet g:easy_align_ignore_groups
-  silent! unlet g:easy_align_ignore_unmatched
-  silent! unlet g:easy_align_indentation
-  silent! unlet g:easy_align_delimiter_align
-  silent! unlet g:easy_align_interactive_modes
-  silent! unlet g:easy_align_bang_interactive_modes
-
-  let g:easy_align_delimiters = {}
-  let mapleader = ' '
-  vnoremap <silent> <Enter>          :EasyAlign<Enter>
-  vnoremap <silent> r<Enter>         :EasyAlign!<Enter>
-  vnoremap <silent> <Leader><Enter>  :LiveEasyAlign<Enter>
-  vnoremap <silent> <Leader>r<Enter> :LiveEasyAlign!<Enter>
+Include: include/setup.vader

 ###########################################################

@@ -39,6 +19,26 @@ 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>
+
+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     33   444 555   66   777 8
+
 Do (right-align):
  vip
  \<Enter>\<Enter>
@@ -496,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>
  |
@@ -769,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:
@@ -798,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:
@@ -827,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>
@@ -904,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>#

@@ -1501,6 +1606,106 @@ Expect:
  		            'url': 'http://localhost:8090/display/TEST'}

 ###########################################################
-Execute:
-  Restore

+Given (Two paragraphs (requires vim-repeat)):
+  a = 1
+  bb = 2
+  ccc = 3
+  dddd = 4
+
+  d = 1
+  cc = 2
+  bbb = 3
+  aaaa = 4
+  _____ = 5
+
+Do (Align and repeat):
+  \<Space>Aip\<Enter>=
+  6G
+  .
+
+Expect:
+     a = 1
+    bb = 2
+   ccc = 3
+  dddd = 4
+
+      d = 1
+     cc = 2
+    bbb = 3
+   aaaa = 4
+  _____ = 5
+
+Do (Visual-mode operator is also repeatable):
+  vip\<Enter>\<Enter>=
+  6G
+  .
+
+Expect:
+     a = 1
+    bb = 2
+   ccc = 3
+  dddd = 4
+
+     d = 1
+    cc = 2
+   bbb = 3
+  aaaa = 4
+  _____ = 5
+
+Do (Repeatable in visual mode):
+  2GvG\<Space>.
+
+Expect:
+  a = 1
+     bb = 2
+    ccc = 3
+   dddd = 4
+
+      d = 1
+     cc = 2
+    bbb = 3
+   aaaa = 4
+  _____ = 5
+
+Given:
+  :: a : 1
+  :: bb : 2
+  :: ccc : 3
+  :: dd : 4
+  :: e : 5
+
+  :: :: a:1
+  :: :: b :2
+  :: :: ccc : 3
+  :: :: dd : 4
+  :: :: e : 5
+  :: :: f : 6
+
+Do (Blockwise-visual-operator is also repeatable):
+  fa
+  \<C-V>
+  f1
+  4j
+  \<Enter>:
+  7G0
+  fa
+  .
+
+Expect:
+  :: a:   1
+  :: bb:  2
+  :: ccc:  3
+  :: dd:  4
+  :: e:   5
+
+  :: :: a:   1
+  :: :: b:   2
+  :: :: ccc:  3
+  :: :: dd:  4
+  :: :: e:   5
+  :: :: f : 6
+
+###########################################################
+
+Include: include/teardown.vader
--- a/test/run
+++ b/test/run
@@ -0,0 +1,11 @@
+#!/bin/bash
+
+cd $(dirname $BASH_SOURCE)
+
+vim -Nu <(cat << EOF
+syntax on
+for dep in ['vader.vim', 'vim-repeat']
+  execute 'set rtp+=' . finddir(dep, expand('~/.vim').'/**')
+endfor
+set rtp+=..
+EOF) +Vader*
--- a/test/tex.vader
+++ b/test/tex.vader
@@ -1,8 +1,6 @@
 # http://en.wikibooks.org/wiki/LaTeX/Tables
-Execute:
-  Save g:easy_align_delimiters, g:easy_align_bypass_fold
-  let g:easy_align_delimiters = {}
-  silent! unlet g:easy_align_bypass_fold
+
+Include: include/setup.vader

 Given tex (table with escaped &):
  \begin{tabular}{ l c r }
@@ -157,5 +155,4 @@ Expect tex:
    8192 & 9.45\e2 & 0.0 & 4.51\e2 & 0.0 &  &  &         &     &         &     \\
  \end{tabular}

-Execute:
-  Restore
+Include: include/teardown.vader
Author	SHA1	Message	Date
Junegunn Choi	1206c65dcb	Fix regular expression for = rule Bug reported by @cvlmtg	2015-07-20 00:39:09 +09:00
Junegunn Choi	a1118be7d9	Extend default = rule to include `?=` Close #65	2015-07-15 21:57:33 +09:00
Junegunn Choi	c62d124be6	Update help file	2014-12-14 02:48:28 +09:00
Junegunn Choi	883c6b67a0	Add regression test case for #51	2014-12-10 12:01:39 +09:00
Junegunn Choi	32591ec4d4	Merge branch 'wilywampa-fixrepeat'	2014-12-10 11:53:28 +09:00
Jacob Niehus	ac9aa14ae4	Fix repeat of visual LiveEasyAlign	2014-12-09 19:41:39 -07:00
Junegunn Choi	cafe55dd65	Fix #50 - Updated shorthand notation (m -> a)	2014-12-09 15:25:44 +09:00
Junegunn Choi	6c276c37ad	Add failing test case for #50	2014-12-09 15:23:46 +09:00
Junegunn Choi	1744414e7e	Update README	2014-12-08 17:34:12 +09:00
Junegunn Choi	246139c57c	Remove dead code (Fix #47 ) Thanks to @itchyny	2014-12-01 19:26:28 +09:00
Junegunn Choi	3afd4540ed	Fix #46 : Remove duplicate tags	2014-12-01 01:04:04 +09:00
Junegunn Choi	2782c1d0db	Fix <CTRL-P> to toggle liveness when delimiter is not entered (#44 )	2014-11-30 11:34:32 +09:00
Junegunn Choi	d983381a99	Merge branch 'master' of github.com:junegunn/vim-easy-align	2014-11-30 02:03:36 +09:00
Junegunn Choi	52814ccd96	Update License	2014-11-30 02:03:13 +09:00
Junegunn Choi	aa1ba68ea0	Retain cursor position after <Plug>(EasyAlign) in visual mode	2014-11-30 02:01:52 +09:00
Junegunn Choi	b8abc366a6	Fix code indentation	2014-11-30 01:46:11 +09:00
Junegunn Choi	f6586bad39	<CTRL-P> to switch to live interactive mode (#44 )	2014-11-30 01:45:27 +09:00
Junegunn Choi	44216b0a2c	Do nothing when nomodifiable (#43 )	2014-11-23 03:39:33 +09:00
Junegunn Choi	2595ebf933	Oops, remove duplicate line from the previous commit (#40 )	2014-10-03 11:29:03 +09:00
Junegunn Choi	6bc221c285	Fix #40 : Spurious undo in live interactive mode Problem identified and patch provided by @wilywampa	2014-10-03 11:25:51 +09:00
Junegunn Choi	21697776b4	Allow recursive alignment (, *) in blockwise-visual mode Recursive alignment in blockwise-visual mode will align around all the delimiters found after the start of the block. This behavior is inconsistent with non-recursive alignment where the delimiters after the end of the block are ignored. Making it respect the end of the block is non-trivial and may not be intuitive as each alignment will change the position of the delimiters inside the block and some of them will end up beyond the scope of the block.	2014-09-13 19:54:49 +09:00
Junegunn Choi	09167c79c9	Fix travis-ci build	2014-09-08 16:30:45 +09:00
Junegunn Choi	cbb005ee71	Update the link to the default alignment rules	2014-08-14 14:29:34 +09:00
Junegunn Choi	ec15731bc9	Update README: Shorthand notation for stick_to_left option	2014-08-14 14:14:22 +09:00
Junegunn Choi	eee4735770	Update shorthand notation for stick_to_left: `>` to unset - `<` == `stl1` - `>` == `stl0`	2014-08-14 12:38:44 +09:00
Junegunn Choi	5e2a588403	Update README	2014-07-23 22:17:40 +09:00
Junegunn Choi	2fa6a040f6	Change option name and shorthand notations - `mode_sequence` (`ms`) -> `align` (`a`) - `stick_to_left` (`<` / `s01`) This commit does not break backward compatibility. `mode_sequence` is still allowed.	2014-07-23 22:15:01 +09:00
Junegunn Choi	f9a49e441d	Preserve last selection when using <Plug>(EasyAlign)	2014-06-27 23:31:22 +09:00
Junegunn Choi	fc9555cd65	Allow negation operator in ignore_groups option e.g. ig['!String']	2014-06-24 00:09:51 +09:00
Junegunn Choi	a98c1ccc99	Add '#'-rule (#30 ) For Ruby/Python comments. This new '#' rule will only match '#' characters that are highlighted as comments.	2014-06-20 10:36:37 +09:00
Junegunn Choi	0aa6289d8c	Update EXAMPLES.md	2014-06-08 00:36:07 +09:00
Junegunn Choi	cc8966c0a5	Update README	2014-05-31 02:59:14 +09:00
Junegunn Choi	da281d78d3	Update document	2014-05-31 00:50:25 +09:00
Junegunn Choi	8e8629c0cd	Export-ignore .travis.yml	2014-05-16 11:56:25 +09:00
Junegunn Choi	a9f593fdf8	Update test runner	2014-05-09 00:55:28 +09:00
Junegunn Choi	d87ea32cfe	Update .travis.yml	2014-04-28 13:44:45 +09:00
Junegunn Choi	11a6b03e7e	Add .travis.yml	2014-04-28 13:25:20 +09:00
Junegunn Choi	ba54df53ca	Better handling of tab characters using strdisplaywidth	2014-04-11 10:39:39 +09:00
Junegunn Choi	d041e17bba	Update README	2014-03-19 19:10:53 +09:00
Junegunn Choi	2ab86911cb	Update README	2014-03-19 19:06:03 +09:00
Junegunn Choi	4929841a7a	Remove +float dependency	2014-01-20 01:30:31 +09:00
Junegunn Choi	12792cd60f	Simplify tests using `Include:` directive	2014-01-19 11:32:52 +09:00
Junegunn Choi	f7213f30f3	Update README - Changed maps to LiveEasyAlign	2013-12-22 15:19:58 +09:00
Junegunn Choi	f44c325aa2	Merge branch 'master' of github.com:junegunn/vim-easy-align	2013-12-21 16:47:27 +09:00
Junegunn Choi	dc4786841e	Workaround for Vim bug: `using Float as a String in gvim` (#27 )	2013-12-19 10:20:04 +09:00
Junegunn Choi	46abd8fb92	Add `set cpo&vim` for compatible mode	2013-12-19 10:04:03 +09:00
Junegunn Choi	af39e544ca	set cpo&vim for compatible mode	2013-12-19 00:53:05 +09:00
Junegunn Choi	49c7133328	Update documentation	2013-12-11 00:53:03 +09:00
Junegunn Choi	4298395085	Extract tags from code block as well	2013-12-08 19:11:43 +09:00
Junegunn Choi	e7fca89dde	Update helpdoc - Change heading format	2013-12-08 10:35:56 +09:00
Junegunn Choi	4b706efeb3	Fix helpfile	2013-12-08 00:48:59 +09:00
Junegunn Choi	9bb987599a	Tags for ToC	2013-12-08 00:36:18 +09:00
Junegunn Choi	b8e93f96b8	Convert current README.md into helpfile. Added TOC (#22 )	2013-12-08 00:14:50 +09:00
Junegunn Choi	6d85e93476	Make repeatable in visual mode	2013-12-06 02:11:57 +09:00
Junegunn Choi	9271fc3f8f	Make visual-operator repeatable (#24 )	2013-12-05 23:16:33 +09:00
Junegunn Choi	d3eec7fa8b	Remove an unnecessary function call	2013-12-05 20:50:46 +09:00
Junegunn Choi	62387b78e0	Fix normal-mode repeat affected by visual-mode operator	2013-12-05 13:36:01 +09:00
Junegunn Choi	f400e4d8d1	Wording	2013-12-03 02:27:30 +09:00
Junegunn Choi	9716fb3917	One-minute guide	2013-12-03 02:25:40 +09:00
Junegunn Choi	353ae9b071	One-minute guide	2013-12-03 02:21:05 +09:00
Junegunn Choi	ba4ba6e3c4	Fix vim-repeat integration	2013-12-02 00:33:33 +09:00
Junegunn Choi	da284f908e	<Plug>(EasyAlign) / <Plug>(LiveEasyAlign) for vim-repeat integration	2013-12-01 22:58:13 +09:00
Junegunn Choi	8d4d5b7941	Update documentation	2013-11-30 13:07:26 +09:00
Junegunn Choi	165bda1d95	Add <Plug>(EasyAlignOperator)	2013-11-30 13:04:32 +09:00
Junegunn Choi	ddc1e00b81	Update README - Add <silent> to opfunc mapping	2013-11-30 11:55:54 +09:00
Junegunn Choi	462a800064	Generic operator function with interactive mode	2013-11-30 11:41:11 +09:00
Junegunn Choi	3921d0bab3	Fix #20 - Alignment with tabs inserting spaces	2013-11-20 07:27:39 +09:00
Junegunn Choi	ea1ea51ef1	Fix link to slow GIF	2013-11-15 02:27:14 +09:00