Fix #20 - Alignment with tabs inserting spaces

Fix link to slow GIF
Fix indentation option to work with hard tabs (#19 )
2025-11-17 06:13:41 -05:00 · 2013-11-20 07:27:39 +09:00 · 2013-11-15 02:27:14 +09:00 · 2013-10-31 12:32:07 +09:00 · 2013-10-31 11:08:02 +09:00 · 2013-10-29 23:24:14 +09:00
20 changed files with 3680 additions and 1144 deletions
--- a/DEMO.md
+++ b/DEMO.md
@@ -0,0 +1,91 @@
+# vim: set buftype=nofile colorcolumn= scrolloff=0 noshowcmd:
+
+vim-easy-align
+==============
+
+Where's Lennon?
+---------------
+
+Paul McCartney 1942
+George Harrison 1943
+Ringo Starr 1940
+Pete Best 1941
+
+
+Formatting table
+----------------
+```
+
+| Option| Type | Default | Description |
+|--|--|--|--|
+| threads | Fixnum | 1 | number of threads in the thread pool |
+|queues |Fixnum | 1 | number of concurrent queues |
+|queue_size | Fixnum | 1000 | size of each queue |
+|   interval | Numeric | 0 | dispatcher interval for processing |
+|batch | Boolean | false | enables batch processing mode |
+ |batch_size | Fixnum | nil | maximum number of items in batch|
+ |logger | Logger | nil | logger instance for debug logs |
+
+```
+Operators with = sign
+---------------------
+```ruby
+
+a =
+a = 1
+bbbb = 2
+ccccccc = 3
+ccccccccccccccc
+ddd = 4
+eeee === eee = eee = eee=f
+fff = ggg += gg &&= gg
+g != hhhhhhhh == 888
+i   := 5
+i     %= 5
+i       *= 5
+j     =~ 5
+j   >= 5
+aa      =>         123
+aa <<= 123
+aa        >>= 123
+bbb               => 123
+c     => 1233123
+d   =>      123
+dddddd &&= 123
+dddddd ||= 123
+dddddd /= 123
+gg <=> ee
+
+```
+Formatting YAML (or JSON)
+-------------------------
+```yaml
+
+mysql:
+  # JDBC driver for MySQL database:
+  driver: com.mysql.jdbc.Driver
+  # JDBC URL for the connection (jdbc:mysql://HOSTNAME/DATABASE)
+  url: jdbc:mysql://localhost/test
+  database: test
+  "user:pass":r00t:pa55
+
+```
+Using blockwise-visual mode or negative N-th parameter
+------------------------------------------------------
+```ruby
+
+options = { :caching => nil,
+            :versions => 3,
+            "cache=blocks" => false }.merge(options)
+
+```
+Commas
+------
+
+aaa,   bb,c
+d,eeeeeee
+fffff, gggggggggg,
+h, ,           ii
+j,,k
+
+
--- a/EXAMPLES.md
+++ b/EXAMPLES.md
@@ -41,6 +41,7 @@ Try these commands:
 - `<Enter>-2<space>`
 - `<Enter><Enter><space>`
 - `<Enter><Enter>*<space>`
+- `<Enter><Enter><Enter>*<space>`

 ### Example

@@ -61,6 +62,7 @@ Try these commands:
 - `<Enter>**|`
 - `<Enter><Enter>*|`
 - `<Enter><Enter>**|`
+- `<Enter><Enter><Enter>*|`

 ### Example

@@ -90,6 +92,7 @@ Try these commands:
 - `<Enter>*=`
 - `<Enter>**=`
 - `<Enter><Enter>**=`
+- `<Enter><Enter><Enter>*=`

 ### Example

@@ -163,8 +166,8 @@ my_object
 ```


-Using blockwise-visual mode or negative field index
---------------------------------------------------
+Using blockwise-visual mode or negative N-th parameter
+------------------------------------------------------

 You can try either:
 - select text around `=>` in blockwise-visual mode (`CTRL-V`) and `<Enter>=`
@@ -237,10 +240,10 @@ So, let's define a custom mapping for `#`.
 if !exists('g:easy_align_delimiters')
  let g:easy_align_delimiters = {}
 endif
-let g:easy_align_delimiters['#'] = { 'pattern': '#', 'ignores': ['String'] } }
+let g:easy_align_delimiters['#'] = { 'pattern': '#', 'ignore_groups': ['String'] }
 ```

-Notice that the rule overrides `ignores` attribute in order *not to ignore*
+Notice that the rule overrides `ignore_groups` attribute in order *not to ignore*
 delimiters highlighted as comments.

 Then on `<Enter>#`, we get
@@ -282,7 +285,7 @@ let g:easy_align_ignore_unmatched = 0

 " 3. Update the alignment rule with ignore_unmatched option
 let g:easy_align_delimiters['#'] = {
-  \ 'pattern': '#', 'ignores': ['String'], 'ignore_unmatched': 0 } }
+  \ 'pattern': '#', 'ignore_groups': ['String'], 'ignore_unmatched': 0 }
 ```

 Then we get,
--- a/README.md
+++ b/README.md
@@ -1,17 +1,19 @@
 vim-easy-align
 ==============

-A simple, easy-to-use Vim alignment plugin without too much ambition.
+A simple, easy-to-use Vim alignment plugin.

 Demo
 ----

-![Screencast](https://raw.github.com/junegunn/vim-easy-align/gif/vim-easy-align.gif)
+![Screencast](https://raw.github.com/junegunn/i/master/vim-easy-align.gif)
+
+(Too fast? Slower GIF is [here](https://raw.github.com/junegunn/i/master/vim-easy-align-slow.gif))

 Features
 --------

- Makes the common case easy
+- Easy to use
  - Comes with a predefined set of alignment rules
  - Provides a fast and intuitive interface
 - Extensible
@@ -20,34 +22,54 @@ 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 [Vundle](https://github.com/gmarik/vundle) (recommended)
-or [Pathogen](https://github.com/tpope/vim-pathogen).
+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).

-### With Vundle
-
-Add the following line to your .vimrc,
-
-```vim
-Bundle 'junegunn/vim-easy-align'
-```
-
-then execute `:BundleInstall` command.
+- [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`

 Usage
 -----

-_vim-easy-align_ defines `:EasyAlign` command (and the right-justification
-variant `:EasyAlign!`) in the visual mode.
+_vim-easy-align_ defines `:EasyAlign` command (and the right-align
+variant `:EasyAlign!`) for visual mode.

-| Mode                      | Command                                       |
-| ------------------------- | --------------------------------------------- |
-| Interactive mode          | `:EasyAlign`                                  |
-| Using predefined rules    | `:EasyAlign [FIELD#] DELIMITER_KEY [OPTIONS]` |
-| Using regular expressions | `:EasyAlign [FIELD#] /REGEXP/ [OPTIONS]`      |
+| 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_
+
+An *alignment rule* is a predefined set of options for common alignment tasks,
+which is identified by a single character, *DELIMITER KEY*, such as `<space>`,
+`=`, `:`, `.`, `|`, `&`, and `,`.
+
+Think of it as a shortcut. Instead of writing regular expression and setting
+several options, you can just type in a single character.

 ### Interactive mode

@@ -56,14 +78,16 @@ For convenience, it is advised that you define a mapping for triggering it in
 your `.vimrc`.

 ```vim
-vnoremap <silent> <Enter> :EasyAlign<cr>
+vnoremap <silent> <Enter> :EasyAlign<Enter>
 ```

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

 1. `<Enter>` key to start interactive EasyAlign command
-1. Optional Enter keys to toggle right-justification mode
-1. Optional field number (default: 1)
+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
    - `2`         Around the 2nd occurrences of delimiters
    - ...
@@ -72,7 +96,7 @@ 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.

@@ -83,37 +107,99 @@ Alignment rules for the following delimiters have been defined to meet the most
 | `:`           | Suitable for formatting JSON or YAML                                 |
 | `.`           | Multi-line method chaining                                           |
 | `,`           | Multi-line method arguments                                          |
+| `&`           | LaTeX tables (matches `&` and `\\`)                                  |
 | &#124;        | 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

-| 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>:`          | Alignment around 1st colon                               | `:'<,'>EasyAlign:`    |
-| `<Enter>=`          | Alignment around 1st equals signs (and the likes)        | `:'<,'>EasyAlign=`    |
-| `<Enter>2=`         | Alignment around 2nd equals signs (and the likes)        | `:'<,'>EasyAlign2=`   |
-| `<Enter>3=`         | Alignment around 3rd equals signs (and the likes)        | `:'<,'>EasyAlign3=`   |
-| `<Enter>*=`         | Alignment around all equals signs (and the likes)        | `:'<,'>EasyAlign*=`   |
-| `<Enter>**=`        | Left-right alternating alignment around all equals signs | `:'<,'>EasyAlign**=`  |
-| `<Enter><Enter>=`   | Right-justified alignment around 1st equals signs        | `:'<,'>EasyAlign!=`   |
-| `<Enter><Enter>**=` | Right-left alternating alignment around all equals signs | `:'<,'>EasyAlign!**=` |
-| ...                 | ...                                                      |                       |
+| 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!**=`  |

-### Non-interactive mode
+#### Using regular expressions

-Instead of going into the interactive mode, you can type in arguments to
-`:EasyAlign` command. In non-interactive mode, you can even use arbitrary
-regular expressions.
+Instead of finishing the command with a predefined delimiter key, you can type
+in a regular expression after `<CTRL-/>` or `<CTRL-X>` key.
+For example, if you want to align text around all occurrences of numbers:
+
+- `<Enter>`
+- `*`
+- `<CTRL-/>` (or `<CTRL-X>` on GVim)
+  - `[0-9]\+`
+
+#### Alignment options in interactive mode
+
+While in interactive mode, you can set alignment options using special shortcut
+keys listed below. The meaning of each option will be described in
+[the following sections](https://github.com/junegunn/vim-easy-align#alignment-options).
+
+| Key       | Option             | Values                                             |
+| --------  | ------------------ | -------------------------------------------------- |
+| `CTRL-F`  | `filter`           | Input string (`[gv]/.*/?`)                         |
+| `CTRL-I`  | `indentation`      | shallow, deep, none, keep                          |
+| `CTRL-L`  | `left_margin`      | Input number or string                             |
+| `CTRL-R`  | `right_margin`     | Input number or string                             |
+| `CTRL-D`  | `delimiter_align`  | left, center, right                                |
+| `CTRL-U`  | `ignore_unmatched` | 0, 1                                               |
+| `CTRL-G`  | `ignore_groups`    | [], ['String'], ['Comment'], ['String', 'Comment'] |
+| `CTRL-O`  | `mode_sequence`    | 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>
+```
+
+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
+
+Instead of going into the interactive mode, you can just type in arguments to
+`:EasyAlign` command.

 ```vim
 " Using predefined alignment rules
-:EasyAlign[!] [FIELD#] DELIMITER_KEY [OPTIONS]
+:EasyAlign[!] [N-th] DELIMITER_KEY [OPTIONS]

 " Using arbitrary regular expressions
-:EasyAlign[!] [FIELD#] /REGEXP/ [OPTIONS]
+:EasyAlign[!] [N-th] /REGEXP/ [OPTIONS]
 ```

 For example, when aligning the following lines around colons and semi-colons,
@@ -128,18 +214,19 @@ try these commands:
 - `:EasyAlign */[:;]\+/`
 - `:EasyAlign **/[:;]\+/`

-Notice that you can't append `\zs` to your regular expression to put delimiters
-on the left. It can be done by providing additional options in Vim dictionary
-format.
+You can also provide a number of alignment options, [which will be discussed in
+detail later](https://github.com/junegunn/vim-easy-align#alignment-options),
+to EasyAlign command in Vim dictionary format.

- `:EasyAlign * /[:;]\+/ { 'stick_to_left': 1, 'left_margin': '' }`
+- `:EasyAlign * /[:;]\+/ { 'stick_to_left': 1, 'left_margin': 0 }`

-Then we get:
+Which means that the matched delimiter should be positioned right next to the
+preceding token, without margin on the left. So we get:

    apple;: banana::   cake
    data;;  exchange:; format

-Options keys are fuzzy-matched, so you can write as follows:
+Option names are fuzzy-matched, so you can write as follows:

 - `:EasyAlign * /[:;]\+/ { 'stl': 1, 'l': 0 }`

@@ -147,7 +234,33 @@ You can even omit spaces between the arguments, so concisely (or cryptically):

 - `:EasyAlign*/[:;]\+/{'s':1,'l':0}`

-Available options will be shown later in the document.
+Nice. But let's make it even shorter. Option values can be written in shorthand
+notation.
+
+- `:EasyAlign*/[:;]\+/s1l0`
+
+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]`  |
+
+For your information, the same thing can be done in the interactive mode as well
+with the following key combination.
+
+- `<Enter>`
+- `*`
+- `<Left>`
+- `<CTRL-/>` (or `<CTRL-X>` on GVim)
+  - `[:;]\+`

 ### Partial alignment in blockwise-visual mode

@@ -174,37 +287,89 @@ 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 field number: `<Enter>-=`
+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
 -----------------

-Options values can be 1) specified as global variables, 2) set on each alignment
-rule in `g:easy_align_delimiters`, 3) or given to every `:EasyAlign` command.
-
-Command-line options have the highest precedence, and global variables have the
-lowest precedence.
-
 ### List of options

-| Option             | Type              | Default                 | Description                                             |
-| ------------------ | ----------------- | ----------------------- | ------------------------------------------------------- |
-| `left_margin`      | number            | 0                       | Number of spaces to attach before delimiter             |
-| `left_margin`      | string            | `''`                    | String to attach before delimiter                       |
-| `right_margin`     | number            | 0                       | Number of spaces to attach after delimiter              |
-| `right_margin`     | string            | `''`                    | String to attach after delimiter                        |
-| `stick_to_left`    | boolean           | 0                       | Whether to position delimiter on the left-side          |
-| `ignore_unmatched` | boolean           | 1                       | Whether to ignore lines without matching delimiter      |
-| `ignores`          | array             | `['String', 'Comment']` | Delimiters in these syntax highlight groups are ignored |
-| `delimiter_align`  | string            | `r`                     | Determines how to align delimiters of different lengths |
+| Option             | Type    | Default               | Description                                             |
+| ------------------ | ------- | --------------------- | ------------------------------------------------------- |
+| `filter`           | string  |                       | Line filtering expression: `g/../` or `v/../`           |
+| `left_margin`      | number  | 1                     | Number of spaces to attach before delimiter             |
+| `left_margin`      | string  | `' '`                 | String to attach before delimiter                       |
+| `right_margin`     | number  | 1                     | Number of spaces to attach after delimiter              |
+| `right_margin`     | string  | `' '`                 | String to attach after delimiter                        |
+| `stick_to_left`    | boolean | 0                     | Whether to position delimiter on the left-side          |
+| `ignore_groups`    | list    | ['String', 'Comment'] | Delimiters in these syntax highlight groups are ignored |
+| `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  |

-Some of the options can be specified using corresponding global variables.
+There are 4 ways to set alignment options (from lowest precedence to highest):

-| Option             | Global variable                 |
-| ------------------ | ------------------------------- |
-| `ignore_unmatched` | `g:easy_align_ignore_unmatched` |
-| `ignores`          | `g:easy_align_ignores`          |
-| `delimiter_align`  | `g:easy_align_delimiter_align`  |
+1. Some option values can be set with corresponding global variables
+2. Option values can be specified in the definition of each alignment rule
+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*]*`  |                                 |
+
+### 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/`
+2. In command-line, it can be written in dictionary format: `{'filter': 'g/pat/'}`
+3. Or in shorthand notation: `g/pat/` or `v/pat/`
+
+(You don't need to escape '/'s in the regular expression)
+
+#### Examples
+
+```vim
+" Start interactive mode with filter option set to g/hello/
+EasyAlign g/hello/
+
+" Start live interactive mode with filter option set to v/goodbye/
+LiveEasyAlign v/goodbye/
+
+" Align the lines with 'hi' around the first colons
+EasyAlign:g/hi/
+```

 ### Ignoring delimiters in comments or strings

@@ -216,7 +381,7 @@ highlighted as code comments or strings are ignored.
 " Default:
 "   If a delimiter is in a highlight group whose name matches
 "   any of the followings, it will be ignored.
-let g:easy_align_ignores = ['Comment', 'String']
+let g:easy_align_ignore_groups = ['Comment', 'String']
 ```

 For example, the following paragraph
@@ -247,13 +412,15 @@ becomes as follows on `<Enter>:` (or `:EasyAlign:`)

 Naturally, this feature only works when syntax highlighting is enabled.

-You can change the default rule by using one of these 3 methods.
+You can change the default rule by using one of these 4 methods.

-1. Define global `g:easy_align_ignores` list
-2. Define a custom alignment rule in `g:easy_align_delimiters` with `ignores` option
-3. Provide `ignores` option to `:EasyAlign` command. e.g. `:EasyAlign:{'is':[]}`
+1. Press `CTRL-G` in interactive mode to switch groups
+2. Define global `g:easy_align_ignore_groups` list
+3. Define a custom rule in `g:easy_align_delimiters` with `ignore_groups` option
+4. Provide `ignore_groups` option to `:EasyAlign` command.
+   e.g. `:EasyAlign:ig[]`

-For example if you set `ignores` option to be an empty list, you get
+For example if you set `ignore_groups` option to be an empty list, you get

 ```ruby
 {
@@ -270,10 +437,18 @@ Satisfied? :satisfied:

 ### Ignoring unmatched lines

-Lines without any matching delimiter are ignored as well (except in
-right-justification mode).
+`ignore_unmatched` option determines how EasyAlign command processes lines that
+do not have N-th delimiter.

-For example, when aligning the following code block around the colons,
+1. In left-alignment mode, they are ignored
+2. In right or center-alignment mode, they are *not* ignored, and the last
+   tokens from those lines are aligned as well as if there is an invisible
+   trailing delimiter at the end of each line
+3. If `ignore_unmatched` is 1, they are ignored regardless of the alignment mode
+4. If `ignore_unmatched` is 0, they are *not* ignored regardless of the mode
+
+Let's take an example.
+When we align the following code block around the (1st) colons,

 ```ruby
 {
@@ -297,12 +472,13 @@ this is usually what we want.
 }
 ```

-However, this default behavior is also configurable by using one of these 3
-methods.
+However, we can override this default behavior by setting `ignore_unmatched`
+option to zero using one of the following methods.

-1. Set the global `g:easy_align_ignore_unmatched` variable to 0
-2. Define a custom alignment rule with `ignore_unmatched` option set to 0
-3. Provide `ignore_unmatched` option to `:EasyAlign` command. e.g. `:EasyAlign:{'iu':0}`
+1. Press `CTRL-U` in interactive mode to toggle `ignore_unmatched` option
+2. Set the global `g:easy_align_ignore_unmatched` variable to 0
+3. Define a custom alignment rule with `ignore_unmatched` option set to 0
+4. Provide `ignore_unmatched` option to `:EasyAlign` command. e.g. `:EasyAlign:iu0`

 Then we get,

@@ -336,7 +512,7 @@ banana  += apple
 cake   ||= banana
 ```

-However, with `:EasyAlign={'da':l}`, delimiters are left-aligned.
+However, with `:EasyAlign=dl`, delimiters are left-aligned.

 ```ruby
 apple  =   1
@@ -344,7 +520,7 @@ banana +=  apple
 cake   ||= banana
 ```

-And on `:EasyAlign={'da':c}`, center-aligned.
+And on `:EasyAlign=dc`, center-aligned.

 ```ruby
 apple   =  1
@@ -352,20 +528,136 @@ banana +=  apple
 cake   ||= banana
 ```

+In interactive mode, you can change the option value with `CTRL-D` key.
+
+### Adjusting indentation
+
+By default :EasyAlign command keeps the original indentation of the lines. But
+then again we have `indentation` option. See the following example.
+
+```ruby
+# Lines with different indentation
+  apple = 1
+    banana = 2
+      cake = 3
+        daisy = 4
+     eggplant = 5
+
+# Default: _k_eep the original indentation
+#   :EasyAlign=
+  apple       = 1
+    banana    = 2
+      cake    = 3
+        daisy = 4
+     eggplant = 5
+
+# Use the _s_hallowest indentation among the lines
+#   :EasyAlign=is
+  apple    = 1
+  banana   = 2
+  cake     = 3
+  daisy    = 4
+  eggplant = 5
+
+# Use the _d_eepest indentation among the lines
+#   :EasyAlign=id
+        apple    = 1
+        banana   = 2
+        cake     = 3
+        daisy    = 4
+        eggplant = 5
+
+# Indentation: _n_one
+#   :EasyAlign=in
+apple    = 1
+banana   = 2
+cake     = 3
+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
+
+As stated above, "N-th" parameter is used to target specific occurrences of
+the delimiter when it appears multiple times in each line.
+
+To recap:
+
+```vim
+" Left-alignment around the FIRST occurrences of delimiters
+:EasyAlign =
+
+" Left-alignment around the SECOND occurrences of delimiters
+:EasyAlign 2=
+
+" Left-alignment around the LAST occurrences of delimiters
+:EasyAlign -=
+
+" Left-alignment around ALL occurrences of delimiters
+:EasyAlign *=
+
+" Left-right ALTERNATING alignment around all occurrences of delimiters
+:EasyAlign **=
+
+" Right-left ALTERNATING alignment around all occurrences of delimiters
+: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`)
+
+```vim
+" Left alignment over the first two occurrences of delimiters
+:EasyAlign = { 'mode_sequence': 'll' }
+
+" Right, left, center alignment over the 1st to 3rd occurrences of delimiters
+:EasyAlign = { 'm': 'rlc' }
+
+" Using shorthand notation
+:EasyAlign = mrlc
+
+" Right, left, center alignment over the 2nd to 4th occurrences of delimiters
+:EasyAlign 2=mrlc
+
+" (*) Repeating alignments (default: l, r, or c)
+"   Right, left, center, center, center, center, ...
+:EasyAlign *=mrlc
+
+" (**) Alternating alignments (default: lr or rl)
+"   Right, left, center, right, left, center, ...
+:EasyAlign **=mrlc
+
+" Right, left, center, center, center, ... repeating alignment
+" over the 3rd to the last occurrences of delimiters
+:EasyAlign 3=mrlc*
+
+" Right, left, center, right, left, center, ... alternating alignment
+" over the 3rd to the last occurrences of delimiters
+:EasyAlign 3=mrlc**
+```
+
 ### Extending alignment rules

 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).
+
 #### Example

 ```vim
 let g:easy_align_delimiters = {
 \ '>': { 'pattern': '>>\|=>\|>' },
-\ '/': { 'pattern': '//\+\|/\*\|\*/', 'ignores': ['String'] },
-\ '#': { 'pattern': '#\+', 'ignores': ['String'], 'delimiter_align': 'l' },
+\ '/': { 'pattern': '//\+\|/\*\|\*/', 'ignore_groups': ['String'] },
+\ '#': { 'pattern': '#\+', 'ignore_groups': ['String'], 'delimiter_align': 'l' },
 \ ']': {
-\     'pattern':       '[\[\]]',
+\     'pattern':       '[[\]]',
 \     'left_margin':   0,
 \     'right_margin':  0,
 \     'stick_to_left': 0
@@ -384,12 +676,128 @@ let g:easy_align_delimiters = {
 \ }
 ```

+Other options
+-------------
+
+### Disabling &foldmethod during alignment
+
+[It is reported](https://github.com/junegunn/vim-easy-align/issues/14) that
+`&foldmethod` value of `expr` or `syntax` can significantly slow down the
+alignment when editing a large, complex file with many folds. To alleviate this
+issue, EasyAlign provides an option to temporarily set `&foldmethod` to `manual`
+during the alignment task. In order to enable this feature, set
+`g:easy_align_bypass_fold` switch to 1.
+
+```vim
+let g:easy_align_bypass_fold = 1
+```
+
+### Left/right/center mode switch in interactive mode
+
+In interactive mode, you can choose the alignment mode you want by pressing
+enter keys. The non-bang command, `:EasyAlign` starts in left-alignment mode
+and changes to right and center mode as you press enter keys, while the bang
+version first starts in right-alignment mode.
+
+- `:EasyAlign`
+  - Left, Right, Center
+- `:EasyAlign!`
+  - Right, Left, Center
+
+If you do not prefer this default mode transition, you can define your own
+settings as follows.
+
+```vim
+let g:easy_align_interactive_modes = ['l', 'r']
+let g:easy_align_bang_interactive_modes = ['c', 'r']
+```
+
 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")
+- [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
--- a/doc/easy_align.txt
+++ b/doc/easy_align.txt
@@ -3,23 +3,24 @@
 vim-easy-align                              *vim-easy-align* *easy-align*
 =========================================================================

-A simple, easy-to-use Vim alignment plugin without too much ambition.
+A simple, easy-to-use Vim alignment plugin.

-  Author: Junegunn Choi
-  Source: https://github.com/junegunn/vim-easy-align
+  Author:  Junegunn Choi
+  Source:  https://github.com/junegunn/vim-easy-align
+  License: MIT


 EasyAlign                                      *:EasyAlign* *:EasyAlign!*
 -------------------------------------------------------------------------

 vim-easy-align defines `:EasyAlign` command in the visual mode.
-(:EasyAlign! is the right-justification version.)
+(:EasyAlign! is the right-align version.)

-| Mode                      | Command                                     |
-| ------------------------- | ------------------------------------------- |
-| Interactive mode          | :EasyAlign                                  |
-| Using predefined rules    | :EasyAlign [FIELD#] DELIMITER_KEY [OPTIONS] |
-| Using regular expressions | :EasyAlign [FIELD#] /REGEXP/ [OPTIONS]      |
+| Mode                      | Command                                      |
+| ------------------------- | -------------------------------------------- |
+| Interactive mode          | :EasyAlign[!] [OPTIONS]                      |
+| Using predefined rules    | :EasyAlign[!] [N-th] DELIMITER_KEY [OPTIONS] |
+| Using regular expressions | :EasyAlign[!] [N-th] /REGEXP/ [OPTIONS]      |


 Interactive mode
@@ -29,29 +30,33 @@ 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`.

-    vnoremap <silent> <Enter> :EasyAlign<cr>
+    vnoremap <silent> <Enter> :EasyAlign<Enter>

 With this mapping, you can align selected lines of text with a few keystrokes.

 1. <Enter> key to start interactive EasyAlign command
-2. Optional Enter keys to switch justficiation mode (default: left)
-3. Optional field number (default: 1)
+2. Optional: Enter keys to select alignment mode (left, right, or center)
+3. Optional: N-th delimiter (default: 1)
    1        Around the 1st occurrences of delimiters
    2        Around the 2nd occurrences of delimiters
    *        Around all occurrences of delimiters
    **       Left-right alternating alignment around all delimiters
-    -        Around the last occurrences of delimiters (`-1`)
+    -        Around the last occurrences of delimiters (-1)
    -2       Around the second to last occurrences of delimiters
    ...
-4. Delimiter key (a single keystroke)
+4. Delimiter key for the predefined rules (a single keystroke)
    <space>  General alignment around whitespaces
    =        Operators containing equals sign (=, ==, !=, +=, &&=, ...)
    :        Suitable for formatting JSON or YAML
    .        Multi-line method chaining
    ,        Multi-line method arguments. CSV.
+    &        LaTeX tables (matches & and \\)
    |        Table markdown

-During the key sequence, <Enter> key will toggle right-justification mode.
+    (You can override these default rules or define your own rules with
+    `g:easy_align_delimiters`, which will be described in the later section.)
+
+During the key sequence, <Enter> key will toggle right-align mode.

 Examples:

@@ -64,22 +69,97 @@ Examples:
  <Enter>3=          Alignment around 3rd equals signs (and the likes)
  <Enter>*=          Alignment around all equals signs (and the likes)
  <Enter>**=         Left-right alternating alignment around all equals signs
-  <Enter><Enter>=    Right-justified alignment around 1st equals signs
+  <Enter><Enter>=    Right-alignment around 1st equals signs
  <Enter><Enter>**=  Right-left alternating alignment around all equals signs


-Non-interactive mode
+Instead of finishing the command with a predefined delimiter key, you can type
+in a regular expression after `<CTRL-/>` or `<CTRL-X>` key.
+For example, if you want to align text around all occurrences of numbers:
+
+- <Enter>
+- *
+- <CTRL-/> (or <CTRL-X> on Gvim)
+  - [0-9]\+
+
+
+While in interactive mode, you can adjust some of the alignment options using
+special shortcut keys listed below. The meanings of the options will be
+described in the following sections.
+
+| Key     | Option           | Values                                       |
+| ------- | ---------------- | -------------------------------------------- |
+| CTRL-I  | indentation      | shallow, deep, none, keep                    |
+| CTRL-L  | left_margin      | Input number or string                       |
+| CTRL-R  | right_margin     | Input number or string                       |
+| CTRL-D  | delimiter_align  | left, center, right                          |
+| CTRL-U  | ignore_unmatched | 0, 1                                         |
+| CTRL-G  | ignore_groups    | [], [String], [Comment], [String, Comment]   |
+| CTRL-O  | mode_sequence    | Input string of /[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 }      |
+
+                                              *g:easy_align_last_command*
+
+After a successful alignment, you can repeat the same operation using the
+repeatable, non-interactive command recorded in `g:easy_align_last_command`.
+
+    :<C-R>=g:easy_align_last_command<Enter><Enter>
+
+
+Live interactive mode                  *:LiveEasyAlign* *:LiveEasyAlign!*
+-------------------------------------------------------------------------
+
+If you're performing a complex alignment where multiple options should be
+carefully adjusted, try "live interactive mode" which aligns the text
+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 the
+following mapping in addition to the one for `:EasyAlign` command.
+
+    vnoremap <silent> <Leader><Enter> :LiveEasyAlign<Enter>
+
+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.
+
+
+Left/right/center mode switch in interactive mode
+-------------------------------------------------------------------------
+                                         *g:easy_align_interactive_modes*
+                                    *g:easy_align_bang_interactive_modes*
+
+In interactive mode, you can choose the alignment mode you want by pressing
+enter keys. The non-bang command, `:EasyAlign` starts in left-alignment mode
+and changes to right and center mode as you press enter keys, while the bang
+version first starts in right-alignment mode.
+
+- `:EasyAlign`
+  - Left, Right, Center
+- `:EasyAlign!`
+  - Right, Left, Center
+
+If you do not prefer this default mode transition, you can define your own
+settings as follows.
+
+    let g:easy_align_interactive_modes = ['l', 'r']
+    let g:easy_align_bang_interactive_modes = ['c', 'r']
+
+
+Using EasyAlign in command line
 -------------------------------------------------------------------------

 Instead of going into the interactive mode, you can type in arguments to
-`:EasyAlign` command. In non-interactive mode, you can even use arbitrary
-regular expressions.
+`:EasyAlign` command.

    " Using predefined alignment rules
-    :EasyAlign[!] [FIELD#] DELIMITER_KEY [OPTIONS]
+    :EasyAlign[!] [N-th] DELIMITER_KEY [OPTIONS]

    " Using arbitrary regular expressions
-    :EasyAlign[!] [FIELD#] /REGEXP/ [OPTIONS]
+    :EasyAlign[!] [N-th] /REGEXP/ [OPTIONS]

 For example, when aligning the following lines around colons and semi-colons,

@@ -88,50 +168,131 @@ For example, when aligning the following lines around colons and semi-colons,

 try these commands:

- :EasyAlign /[:;]\+/
- :EasyAlign 2/[:;]\+/
- :EasyAlign */[:;]\+/
- :EasyAlign **/[:;]\+/
+    :EasyAlign /[:;]\+/
+    :EasyAlign 2/[:;]\+/
+    :EasyAlign */[:;]\+/
+    :EasyAlign **/[:;]\+/

-Notice that you can't append `\zs` to your regular expression to put delimiters
-on the left. It can be done by providing additional options in Vim dictionary
-format.
+You can also provide a number of alignment options, which will be discussed in
+detail later, to EasyAlign command in Vim dictionary format.

- :EasyAlign * /[:;]\+/ { 'stick_to_left': 1, 'left_margin': '' }
+    :EasyAlign * /[:;]\+/ { 'stick_to_left': 1, 'left_margin': 0 }

-Then we get:
+Which means that the matched delimiter should be positioned right next to the
+preceding token, without margin on the left. So we get:

    apple;: banana::   cake
    data;;  exchange:; format

-Options keys are fuzzy-matched, so you can write as follows:
+Option names are fuzzy-matched, so you can write as follows:

- :EasyAlign * /[:;]\+/ { 'stl': 1, 'l': '' }
+    :EasyAlign * /[:;]\+/ { 'stl': 1, 'l': '' }

 You can even omit spaces between the arguments, so concisely (or cryptically):

- :EasyAlign*/[:;]\+/{'s':1,'l':''}
+    :EasyAlign*/[:;]\+/{'s':1,'l':''}

-Available options are as follows.
+Nice. But let's make it even shorter. Option values can be written in shorthand
+notation.

-| Atrribute        | Type             | Default                 |
-| ---------------- | ---------------- | ----------------------- |
-| left_margin      | number or string | 0                       |
-| right_margin     | number or string | 0                       |
-| stick_to_left    | boolean          | 0                       |
-| delimiter_align  | string           | 'r'                     |
-| ignore_unmatched | boolean          | 1                       |
-| ignores          | array            | `['String', 'Comment']` |
+    :EasyAlign*/[:;]\+/s1l0
+
+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]    |
+
+For your information, the same thing can be done in the interactive mode as well
+with the following key combination.
+
+    - <Enter>
+    - *
+    - <Left>
+    - <CTRL-/> (or <CTRL-X> on GVim)
+      - [:;]\+


 Partial alignment in blockwise-visual mode
 -------------------------------------------------------------------------

-In blockwise-visual mode (`CTRL-V`), EasyAlign command aligns only
+In blockwise-visual mode (CTRL-V), EasyAlign command aligns only
 the selected text in the block, instead of the whole lines in the range.


-Ignoring delimiters in comments or strings         *g:easy_align_ignores*
+Alignment options
+-------------------------------------------------------------------------
+
+Available options are as follows.
+
+| Atrribute        | Type             | Default                       |
+| ---------------- | ---------------- | ----------------------------- |
+| filter           | string           |                               |
+| left_margin      | number or string | 1                             |
+| right_margin     | number or string | 1                             |
+| stick_to_left    | boolean          | 0                             |
+| ignore_unmatched | boolean          | 1                             |
+| ignore_groups    | array            | ['String', 'Comment']         |
+| delimiter_align  | string           | 'r'                           |
+|                  |                  |   (right, left, center)       |
+| indentation      | string           | 'k'                           |
+|                  |                  |   (keep, shallow, deep, none) |
+| mode_sequence    | string           | (Depends on N-th param and    |
+|                  |                  |  selected alignment mode)     |
+
+There are 4 ways to set alignment options (from lowest precedence to highest):
+
+1. Some option values can be set with corresponding global variables
+2. Option values can be specified in the definition of each alignment rule
+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           | 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*]+    |                               |
+
+
+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/
+2. In command-line, it can be written in dictionary format: {'filter': 'g/pat/'}
+3. Or in shorthand notation: g/pat/ or v/pat/
+
+Examples:
+
+    " Start interactive mode with filter option set to g/hello/
+    EasyAlign g/hello/
+
+    " Start live interactive mode with filter option set to v/goodbye/
+    LiveEasyAlign v/goodbye/
+
+    " Align the lines with 'hi' around the first colons
+    EasyAlign : g/hi/
+
+(You don't need to escape '/'s in the regular expression)
+
+
+Ignoring delimiters in comments or strings   *g:easy_align_ignore_groups*
 -------------------------------------------------------------------------

 EasyAlign can be configured to ignore delimiters in certain syntax
@@ -141,7 +302,7 @@ that are highlighted as code comments or strings are ignored.
    " Default:
    "   If a delimiter is in a highlight group whose name matches
    "   any of the followings, it will be ignored.
-    let g:easy_align_ignores = ['Comment', 'String']
+    let g:easy_align_ignore_groups = ['Comment', 'String']

 For example, the following paragraph

@@ -154,7 +315,7 @@ For example, the following paragraph
      'grape:fruits': 3
    }

-becomes as follows on `<Enter>:`
+becomes as follows on '<Enter>:' (or `:EasyAlign:`)

    {
      # Quantity of apples: 1
@@ -167,17 +328,15 @@ becomes as follows on `<Enter>:`

 Naturally, this feature only works when syntax highlighting is enabled.

-You can change the default rule by either defining global `g:easy_align_ignores`
-array,
+You can change the default rule by using one of these 4 methods.

-    " Ignore nothing!
-    let g:easy_align_ignores = []
+1. Press CTRL-G in interactive mode to switch groups
+2. Define global `g:easy_align_ignore_groups` list
+3. Define a custom rule in `g:easy_align_delimiters` with 'ignore_groups' option
+4. Provide 'ignore_groups' option to `:EasyAlign` command.
+   e.g. :EasyAlign:ig[]

-or providing `ignores` option directly to :EasyAlign command
-
-    :EasyAlign:{'is':[]}
-
-Then you get,
+For example if you set 'ignore_groups' option to be an empty list, you get

    {
      # Quantity of apples:  1
@@ -192,10 +351,18 @@ Then you get,
 Ignoring unmatched lines                  *g:easy_align_ignore_unmatched*
 -------------------------------------------------------------------------

-Lines without any matching delimiter are ignored as well (except in
-right-justification mode).
+'ignore_unmatched' option determines how EasyAlign command processes lines that
+do not have N-th delimiter.

-For example, when aligning the following code block around the colons,
+1. In left-alignment mode, they are ignored
+2. In right or center-alignment mode, they are not ignored, and the last
+   tokens from those lines are aligned as well as if there is an invisible
+   trailing delimiter at the end of each line
+3. If 'ignore_unmatched' is 1, they are ignored regardless of the alignment mode
+4. If 'ignore_unmatched' is 0, they are not ignored regardless of the mode
+
+Let's take an example.
+When we align the following code block around the (1st) colons,

    {
      apple: proc {
@@ -215,17 +382,14 @@ this is usually what we want.
      grapefruits: 3
    }

-However, this default behavior is also configurable.
-
-One way is to set the global `g:easy_align_ignore_unmatched` variable to 0.
-
-    let g:easy_align_ignore_unmatched = 0
-
-Or in non-interactive mode, you can provide `ignore_unmatched` option to
-`:EasyAlign` command as follows.
-
-    :EasyAlign:{'iu':0}
+However, we can override this default behavior by setting 'ignore_unmatched'
+option to zero using one of the following methods.

+1. Press CTRL-U in interactive mode to toggle 'ignore_unmatched' option
+2. Set the global `g:easy_align_ignore_unmatched` variable to 0
+3. Define a custom alignment rule with 'ignore_unmatched' option set to 0
+4. Provide 'ignore_unmatched' option to `:EasyAlign` command.
+   e.g. :EasyAlign:iu0

 Then we get,

@@ -238,12 +402,11 @@ Then we get,
    }


-
 Aligning delimiters of different lengths   *g:easy_align_delimiter_align*
 -------------------------------------------------------------------------

 Global `g:easy_align_delimiter_align` option and rule-wise/command-wise
-`delimiter_align` option determines how matched delimiters of different
+'delimiter_align' option determines how matched delimiters of different
 lengths are aligned.

    apple = 1
@@ -256,18 +419,131 @@ By default, delimiters are right-aligned as follows.
    banana  += apple
    cake   ||= banana

-However, with `:EasyAlign={'da':l}`, delimiters are left-aligned.
+However, with ':EasyAlign=dl', delimiters are left-aligned.

    apple  =   1
    banana +=  apple
    cake   ||= banana

-And on `:EasyAlign={'da':c}`, center-aligned.
+And on ':EasyAlign=dc', center-aligned.

    apple   =  1
    banana +=  apple
    cake   ||= banana

+In interactive mode, you can change the option value with `CTRL-D` key.
+
+
+Adjusting indentation                          *g:easy_align_indentation*
+-------------------------------------------------------------------------
+
+By default :EasyAlign command keeps the original indentation of the lines.
+But then again we have 'indentation' option. See the following example.
+
+    # Lines with different indentation
+      apple = 1
+        banana = 2
+          cake = 3
+            daisy = 4
+         eggplant = 5
+
+    # Default: _k_eep the original indentation
+    #   :EasyAlign=
+      apple       = 1
+        banana    = 2
+          cake    = 3
+            daisy = 4
+         eggplant = 5
+
+    # Use the _s_hallowest indentation among the lines
+    #   :EasyAlign=is
+      apple    = 1
+      banana   = 2
+      cake     = 3
+      daisy    = 4
+      eggplant = 5
+
+    # Use the _d_eepest indentation among the lines
+    #   :EasyAlign=id
+            apple    = 1
+            banana   = 2
+            cake     = 3
+            daisy    = 4
+            eggplant = 5
+
+    # Indentation: _n_one
+    #   :EasyAlign=in
+    apple    = 1
+    banana   = 2
+    cake     = 3
+    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
+-------------------------------------------------------------------------
+
+As stated above, "N-th" parameter is used to target specific occurrences of
+the delimiter when it appears multiple times in each line.
+
+To recap:
+
+    " Left-alignment around the FIRST occurrences of delimiters
+    :EasyAlign =
+
+    " Left-alignment around the SECOND occurrences of delimiters
+    :EasyAlign 2=
+
+    " Left-alignment around the LAST occurrences of delimiters
+    :EasyAlign -=
+
+    " Left-alignment around ALL occurrences of delimiters
+    :EasyAlign *=
+
+    " Left-right ALTERNATING alignment around all occurrences of delimiters
+    :EasyAlign **=
+
+    " Right-left ALTERNATING alignment around all occurrences of delimiters
+    :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)
+
+    " Left alignment over the first two occurrences of delimiters
+    :EasyAlign = { 'mode_sequence': 'll' }
+
+    " Right, left, center alignment over the 1st to 3rd occurrences of delimiters
+    :EasyAlign = { 'm': 'rlc' }
+
+    " Using shorthand notation
+    :EasyAlign = mrlc
+
+    " Right, left, center alignment over the 2nd to 4th occurrences of delimiters
+    :EasyAlign 2=mrlc
+
+    " (*) Repeating alignments (default: l, r, or c)
+    "   Right, left, center, center, center, center, ...
+    :EasyAlign *=mrlc
+
+    " (**) Alternating alignments (default: lr or rl)
+    "   Right, left, center, right, left, center, ...
+    :EasyAlign **=mrlc
+
+    " Right, left, center, center, center, ... repeating alignment
+    " over the 3rd to the last occurrences of delimiters
+    :EasyAlign 3=mrlc*
+
+    " Right, left, center, right, left, center, ... alternating alignment
+    " over the 3rd to the last occurrences of delimiters
+    :EasyAlign 3=mrlc**
+
+
 Extending alignment rules                       *g:easy_align_delimiters*
 -------------------------------------------------------------------------

@@ -277,10 +553,10 @@ you can extend the rules by setting a dictionary named

    let g:easy_align_delimiters = {
    \ '>': { 'pattern': '>>\|=>\|>' },
-    \ '/': { 'pattern': '//\+\|/\*\|\*/', 'ignores': ['String'] },
-    \ '#': { 'pattern': '#\+', 'ignores': ['String'] },
+    \ '/': { 'pattern': '//\+\|/\*\|\*/', 'ignore_groups': ['String'] },
+    \ '#': { 'pattern': '#\+', 'ignore_groups': ['String'] },
    \ ']': {
-    \     'pattern':       '[\[\]]',
+    \     'pattern':       '[[\]]',
    \     'left_margin':   0,
    \     'right_margin':  0,
    \     'stick_to_left': 0
@@ -294,3 +570,14 @@ you can extend the rules by setting a dictionary named
    \ }


+Disabling `foldmethod` during alignment        *g:easy_align_bypass_fold*
+-------------------------------------------------------------------------
+
+It is reported that `foldmethod` value of expr or syntax can significantly
+slow down the alignment when editing a large, complex file with many
+folds. To alleviate this issue, EasyAlign provides an option to
+temporarily set `foldmethod` to manual during the alignment task.
+In order to enable this feature, set g:easy_align_bypass_fold to 1.
+
+    let g:easy_align_bypass_fold = 1
+
--- a/plugin/easy_align.vim
+++ b/plugin/easy_align.vim
@@ -26,4 +26,5 @@ 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>' == '!', <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>)
--- a/test/README.md
+++ b/test/README.md
@@ -0,0 +1,13 @@
+Test cases for vim-easy-align
+=============================
+
+### Prerequisite
+
+- [Vader.vim](https://github.com/junegunn/vader.vim)
+
+### Run
+
+```vim
+:Vader*
+```
+
--- a/test/basic.expected
+++ b/test/basic.expected
@@ -1,506 +0,0 @@
-" :source run.vim
-" @a
-
-Pa  ul  Mc  Ca  rt  ne  y{  {1  }}  94 2
-Ge  or  ge  Ha  rr  is  on  {{  1}  }9  43
-Ri  ng  o   St  ar  r   {{  1}  }9  40
-Pe  te  Be  st  {{  1}  }9  41
-
-  Paul McCartney{{1}}942
-George Harrison {{1}}943
- Ringo Starr    {{1}}940
-  Pete Best     {{1}}941
-
-  Paul McCartney 1942
-George Harrison  1943
- Ringo Starr     1940
-  Pete Best      1941
-
-Paul  McCartney 1942
-George Harrison 1943
-Ringo     Starr 1940
-Pete       Best 1941
-
-Paul   McCartney 1942
-George Harrison 1943
-Ringo  Starr 1940
-Pete   Best 1941
-
-Paul McCartney  1942
-George Harrison 1943
-Ringo Starr     1940
-Pete Best       1941
-
-Paul   McCartney 1942
-George  Harrison 1943
-Ringo      Starr 1940
-Pete        Best 1941
-
-  Paul McCartney 1942
-George  Harrison 1943
- Ringo     Starr 1940
-  Pete      Best 1941
-
-Paul  McCartney 1942
-George Harrison 1943
-Ringo     Starr 1940
-Pete       Best 1941
-
-  Paul McCartney 1942
-George Harrison 1943
- Ringo Starr 1940
-  Pete Best 1941
-
-Paul   McCartney 1942
-George Harrison  1943
-Ringo  Starr     1940
-Pete   Best      1941
-
-Paul McCartney  1942
-George Harrison 1943
-Ringo Starr     1940
-Pete Best       1941
-
-Paul   McCartney 1942
-George Harrison 1943
-Ringo  Starr 1940
-Pete   Best 1941
-
-|     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                 |
-
-|     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 |
-
-| 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                 |
-
-aaa,   bb,         c
-d,     eeeeeee
-fffff, gggggggggg,
-h,     ,           ii
-j,     ,           k
-
-```ruby
-
-              a   =
-              a   =        1
-           bbbb   =        2
-        ccccccc   =        3
-ccccccccccccccc
-            ddd   =        4
-           eeee ===      eee  = eee = eee=f
-            fff   =      ggg += gg &&= gg
-              g  != hhhhhhhh == 888
-              i  :=        5
-              i  %=        5
-              i  *=        5
-              j  =~        5
-              j  >=        5
-             aa  =>      123
-             aa <<=      123
-             aa >>=      123
-            bbb  =>      123
-              c  =>  1233123
-              d  =>      123
-         dddddd &&=      123
-         dddddd ||=      123
-         dddddd  /=      123
-             gg <=>       ee
-
-a         =
-a         =        1
-bbbb      =        2
-ccccccc   =        3
-ccccccccccccccc
-ddd       =        4
-eeee    ===      eee  = eee   = eee = f
-fff       =      ggg += gg  &&=  gg
-g        != hhhhhhhh == 888
-i        :=        5
-i        %=        5
-i        *=        5
-j        =~        5
-j        >=        5
-aa       =>      123
-aa      <<=      123
-aa      >>=      123
-bbb      =>      123
-c        =>  1233123
-d        =>      123
-dddddd  &&=      123
-dddddd  ||=      123
-dddddd   /=      123
-gg      <=>       ee
-
-a         =
-a         = 1
-bbbb      = 2
-ccccccc   = 3
-ccccccccccccccc
-ddd       = 4
-eeee    === eee       = eee   = eee = f
-fff       = ggg      += gg  &&= gg
-g        != hhhhhhhh == 888
-i        := 5
-i        %= 5
-i        *= 5
-j        =~ 5
-j        >= 5
-aa       => 123
-aa      <<= 123
-aa      >>= 123
-bbb      => 123
-c        => 1233123
-d        => 123
-dddddd  &&= 123
-dddddd  ||= 123
-dddddd   /= 123
-gg      <=> ee
-
-a         =
-a         = 1
-bbbb      = 2
-ccccccc   = 3
-ccccccccccccccc
-ddd       = 4
-eeee    === eee = eee = eee=f
-fff       = ggg += gg &&= gg
-g        != hhhhhhhh == 888
-i        := 5
-i        %= 5
-i        *= 5
-j        =~ 5
-j        >= 5
-aa       => 123
-aa      <<= 123
-aa      >>= 123
-bbb      => 123
-c        => 1233123
-d        => 123
-dddddd  &&= 123
-dddddd  ||= 123
-dddddd   /= 123
-gg      <=> ee
-
-options = {       :caching => nil,
-                 :versions => 3,
-            "cache=blocks" => false }.merge(options)
-
-options = { :caching       => nil,
-            :versions      => 3,
-            "cache=blocks" => false }.merge(options)
-
-options                     = { :caching => nil,
-            :versions      => 3,
-            "cache=blocks" => false }.merge(options)
-
-apple = 1              # comment not aligned
-banana = 'Gros Michel' # comment 2
-
-# let g:easy_align_delimiters = { '#': { 'pattern': '#\+', 'ignores': ['String'] } }
-
-apple = 1              # comment not aligned
-apricot = 'DAD' + 'F#AD'
-banana = 'Gros Michel' # comment 2
-
-apple = 1 # comment not aligned
-apricot = 'DAD' + 'F#AD'
-banana = 'Gros Michel' # comment 2
-
-```
-
-```yaml
-
-        mysql:
-  # JDBC driver for MySQL database:
-       driver: com.mysql.jdbc.Driver
-  # JDBC URL for the connection (jdbc:mysql://HOSTNAME/DATABASE)
-          url: jdbc:mysql://localhost/test
-     database: test
-  "user:pass": r00t:pa55
-
-mysql:
-  # JDBC driver for MySQL database:
-  driver:      com.mysql.jdbc.Driver
-  # JDBC URL for the connection (jdbc:mysql://HOSTNAME/DATABASE)
-  url:         jdbc:mysql://localhost/test
-  database:    test
-  "user:pass": r00t:pa55
-
-```
-```c
-
-/* a */ b          = c
-aa                >= bb
-// aaa             = bbb        = cccc
-/* aaaa            = */ bbbb  === cccc   " = dddd   = " = eeee
-aaaaa /* bbbbb */ == ccccc /*  != eeeee    = */   === fffff
-
-/* a */ b           = c
-aa                 >= bb
-// aaa = bbb = cccc
-/* aaaa = */ bbbb === cccc   " = dddd = "      = eeee
-aaaaa /* bbbbb */  == ccccc /* != eeeee = */ === fffff
-
-```
-
-my_object
-      .method1    .chain
-    .second_method.call
-      .third      .call
-     .method_4    .execute
-
-my_object
-         .method1      .  chain
-         .second_method.   call
-         .third        .   call
-         .method_4     .execute
-
-my_object
-    .      method1.chain
-    .second_method.call
-    .        third.call
-    .     method_4.execute
-
-my_object
-         .      method1.chain
-         .second_method.call
-         .        third.call
-         .     method_4.execute
-
-my_object
-         .      method1.  chain
-         .second_method.   call
-         .        third.   call
-         .     method_4.execute
-
-my_object
-    .method1      .chain
-    .second_method.call
-    .third        .call
-    .method_4     .execute
-
-my_object
-    .method1.chain
-    .second_method.call
-    .third.call
-    .method_4.execute
-
-my_object        .
-      method1    .chain.
-    second_method.call.
-      third      .call.
-     method_4    .execute
-
-  | 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 |
-
-  |     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 |
-
-  | 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                 |
-
-
-  |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                     |
-
-  |    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                <|
-
-```c
-
-const char*                          str    = "Hello";
-int64_t                              count  = 1 + 2;
-static double                        pi     = 3.14;
-static std::map<std::string, float>* scores = pointer;
-
-```
-
-  Paul<<< McCartney{{{ 1942
-George<<< Harrison {{{ 1943
- Ringo<<< Starr    {{{ 1940
-  Pete<<< Best     {{{ 1941
-
-  Paul McCartney 1942
-George  Harrison 1943
- Ringo     Starr 1940
-  Pete      Best 1941
-
-...    - .     -----
-..    -- ..     ----
-.    --- ...     ---
-    ---- ....     --
-.    --- .....     -
-..    -- ......
-...    - .....     -
-
-...  -   .     -----
-..   --  ..    ----
-.   ---  ...    ---
-    ---- ....   --
-.   ---  .....   -
-..   --  ......
-...  -   .....   -
-
-... -    .     -----
-..  --   ..    ----
-.   ---  ...   ---
-    ---- ....  --
-.   ---  ..... -
-..  --   ......
-... -    ..... -
-
-...  -   .     -----
-..   --  ..    ----
-.   ---  ...    ---
-    ---- ....   --
-.   ---  .....   -
-..   --  ......
-...  -   .....   -
-
-...  -   .-----
-..   --  ..----
-.   ---  ...---
-    ---- ....--
-.   ---  .....-
-..   --  ......
-...  -   .....-
-
-... -    .     -----
-..  --   ..    ----
-.   ---  ...   ---
-    ---- ....  --
-.   ---  ..... -
-..  --   ......
-... -    ..... -
-
-... -    .-----
-..  --   ..----
-.   ---  ...---
-    ---- ....--
-.   ---  .....-
-..  --   ......
-... -    .....-
-
-...    - .-----
-..    -- ..----
-.    --- ...---
-    ---- ....--
-.    --- .....-
-..    -- ......
-...    - .....-
-
-...-.-----
-..--..----
-.---...---
----....--
-.---.....-
-..--......
-...-.....-
-
-...  -   .     -----
-..   --  ..    ----
-.   ---  ...    ---
-    ---- ....   --
-.   ---  .....   -
-..   --  ......
-...  -   .....   -
-
-...  -   .-----
-..   --  ..----
-.   ---  ...---
-    ---- ....--
-.   ---  .....-
-..   --  ......
-...  -   .....-
-
-... -    .     -----
-..  --   ..    ----
-.   ---  ...   ---
-    ---- ....  --
-.   ---  ..... -
-..  --   ......
-... -    ..... -
-
-...    - .     -----
-..    -- ..     ----
-.    --- ...     ---
-    ---- ....     --
-.    --- .....     -
-..    -- ......
-...    - .....     -
-
-...-.     -----
-..--..     ----
-.---...     ---
----....     --
-.---.....     -
-..--......
-...-.....     -
-
-...    - .-----
-..    -- ..----
-.    --- ...---
-    ---- ....--
-.    --- .....-
-..    -- ......
-...    - .....-
-
--- a/test/basic.md
+++ b/test/basic.md
@@ -1,132 +0,0 @@
-" :source run.vim
-" @a
-
-Paul McCartney 1942
-George Harrison 1943
-Ringo Starr 1940
-Pete Best 1941
-
-| 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 |
-
-aaa,   bb,c
-d,eeeeeee
-fffff, gggggggggg,
-h, ,           ii
-j,,k
-
-```ruby
-
-a =
-a = 1
-bbbb = 2
-ccccccc = 3
-ccccccccccccccc
-ddd = 4
-eeee === eee = eee = eee=f
-fff = ggg += gg &&= gg
-g != hhhhhhhh == 888
-i   := 5
-i     %= 5
-i       *= 5
-j     =~ 5
-j   >= 5
-aa      =>         123
-aa <<= 123
-aa        >>= 123
-bbb               => 123
-c     => 1233123
-d   =>      123
-dddddd &&= 123
-dddddd ||= 123
-dddddd /= 123
-gg <=> ee
-
-options = { :caching => nil,
-            :versions => 3,
-            "cache=blocks" => false }.merge(options)
-
-apple = 1 # comment not aligned
-banana = 'Gros Michel' # comment 2
-
-# let g:easy_align_delimiters = { '#': { 'pattern': '#\+', 'ignores': ['String'] } }
-
-apple = 1 # comment not aligned
-apricot = 'DAD' + 'F#AD'
-banana = 'Gros Michel' # comment 2
-
-```
-
-```yaml
-
-mysql:
-  # JDBC driver for MySQL database:
-  driver: com.mysql.jdbc.Driver
-  # JDBC URL for the connection (jdbc:mysql://HOSTNAME/DATABASE)
-  url: jdbc:mysql://localhost/test
-  database: test
-  "user:pass":r00t:pa55
-
-```
-```c
-
-/* a */ b = c
-aa >= bb
-// aaa = bbb = cccc
-/* aaaa = */ bbbb   === cccc   " = dddd = " = eeee
-aaaaa /* bbbbb */      == ccccc /* != eeeee = */ === fffff
-
-```
-
-my_object
-      .method1.chain
-    .second_method.call
-      .third.call
-     .method_4.execute
-
-my_object.
-      method1.chain.
-    second_method.call.
-      third.call.
-     method_4.execute
-
-   | 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 |
-
-
-```c
-
-const char* str = "Hello";
-int64_t count = 1 + 2;
-static double pi = 3.14;
-static std::map<std::string, float>* scores =    pointer;
-
-```
-
-Paul McCartney 1942
-George Harrison 1943
-Ringo Starr 1940
-Pete Best 1941
-
-...-.-----
-..--..----
-.---...---
----....--
-.---.....-
-..--......
-...-.....-
-
--- a/test/basic.script
+++ b/test/basic.script
@@ -1 +0,0 @@
-4Gvipjyvip
--- a/test/commandline.vader
+++ b/test/commandline.vader
@@ -0,0 +1,165 @@
+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
+
+Given (fruits):
+  apple;:;;banana::cake
+  data;;exchange:;::format
+
+Execute (regular expression):
+  %EasyAlign/[:;]\+/
+  AssertEqual ':EasyAlign /[:;]\+/', g:easy_align_last_command
+
+Expect:
+  apple ;:;; banana::cake
+  data    ;; exchange:;::format
+
+Execute (options dictionary):
+  %EasyAlign/[:;]\+/{ 'left_margin': '<', 'right_margin': 3 }
+
+Expect:
+  apple<;:;;   banana::cake
+  data <  ;;   exchange:;::format
+
+Execute (fuzzy matching):
+  %EasyAlign/[:;]\+/{ 'l':'<', 'r': '>'}
+
+Expect:
+  apple<;:;;>banana::cake
+  data <  ;;>exchange:;::format
+
+Execute (shorthand notation of margin):
+  %EasyAlign/[:;]\+/l0r0
+
+Expect:
+  apple;:;;banana::cake
+  data   ;;exchange:;::format
+
+Execute (delimiter align):
+  %EasyAlign*/[:;]\+/l0r0dc
+
+Expect:
+  apple;:;;banana   :: cake
+  data  ;; exchange:;::format
+
+Execute (shorthand notation of mode_sequence and margin):
+  %EasyAlign/[:;]\+/mrc*l2r2
+
+Expect:
+  apple  ;:;;   banana     ::   cake
+   data    ;;  exchange  :;::  format
+
+Execute (deep indentation):
+  %EasyAlign/[:;]\+/mrc*l2r2
+  %EasyAlign*/[:;]\+/idmrl*
+
+Expect:
+   apple ;:;; banana     :: cake
+    data   ;; exchange :;:: format
+
+Execute (stick_to_left):
+  %EasyAlign*/[:;]\+/stl1l0dlrm3
+
+Expect:
+  apple;:;;   banana::       cake
+  data;;      exchange:;::   format
+
+Execute (different regular expression):
+  %EasyAlign*/../{'lm':'<','rm':'>'}
+
+Expect:
+  ap><pl><e;><:;><;b><an><an><a:><:c><ak>e
+  da><ta><;;><ex><ch><an><ge><:;><::><fo><rm><at
+
+Execute (merge different option notations):
+  %EasyAlign*/../iu0 { 'l': '<', 'r': '>' }
+
+Expect:
+  ap><pl><e;><:;><;b><an><an><a:><:c><ak>e
+  da><ta><;;><ex><ch><an><ge><:;><::><fo> <rm><at
+
+Given javascript (json):
+  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"
+  };
+
+Execute (default syntax-aware alignment):
+  %EasyAlign*:
+
+Expect 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"
+  };
+
+Execute (do not ignore unmatched):
+  %EasyAlign*:iu0
+
+Expect 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"
+  };
+
+Execute (do not ignore any group):
+  %EasyAlign*:ig[]iu0
+
+Expect 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"
+  };
+
+Execute (ignore only strings):
+  %EasyAlign*:ig['String']
+
+Expect 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"
+  };
+
+Execute (ignore only comments):
+  %EasyAlign*:ig['Comment']
+
+Expect 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"
+  };
+
+Execute:
+  Restore
--- a/test/fixed.vader
+++ b/test/fixed.vader
@@ -0,0 +1,122 @@
+Execute:
+  Save &tabstop
+
+Given (Table):
+  |a|b|c|d|
+  | -|-|>-|-|
+  |aaa|bbb|ccc|ddd|
+
+Do (Partial alignment around 1st |):
+  \<C-V>ljj\<Enter>|
+
+Expect (Right margin should be correctly attached):
+  | a|b|c|d|
+  | -|-|>-|-|
+  | aaa|bbb|ccc|ddd|
+
+Given (empty buffer):
+
+Execute (Aligning lines with many delimiters should not fail):
+  call visualmode(1)
+  call setline(1, repeat('|', &maxfuncdepth + 1))
+  %EasyAlign*|
+  AssertEqual (&maxfuncdepth + 1) * 3 - 2, len(getline(1))
+
+Given:
+  a  | b | c
+  aa | bb | cc
+
+Execute:
+  %EasyAlign*|iu0{'l':'<', 'r': '>'}
+
+Expect:
+  a <|>b <|>c
+  aa<|>bb<|>cc
+
+Given (Trailing delimiter):
+  a  | b | c |
+  aa | bb | cc |
+
+Execute:
+  %EasyAlign*|iu0{'l':'<', 'r': '>'}
+
+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 = {}
+
+Execute:
+  Restore
--- a/test/fixme.vader
+++ b/test/fixme.vader
@@ -0,0 +1,20 @@
+# It is currently possible that EasyAlign command incorrectly judges
+# that it was executed in block-wise visual mode
+Given:
+  a|b|c
+
+Do (FIXME invalid judgement - block-wise visual mode):
+  \<C-V>\<Esc>
+  :%EasyAlign|\<CR>
+
+Expect:
+  a | b | c
+
+Do (TODO Workaround: reset visualmode() on error):
+  \<C-V>\<Esc>
+  :%EasyAlign|\<CR>
+  :%EasyAlign|\<CR>
+
+Expect:
+  a | b | c
+
--- a/test/include.vim
+++ b/test/include.vim
@@ -1,44 +0,0 @@
-function! GFM()
-  let syntaxes = {
-  \ 'ruby':   'syntax/ruby.vim',
-  \ 'yaml':   'syntax/yaml.vim',
-  \ 'vim':    'syntax/vim.vim',
-  \ 'sh':     'syntax/sh.vim',
-  \ 'python': 'syntax/python.vim',
-  \ 'java':   'syntax/java.vim',
-  \ 'c':      'syntax/c.vim'
-  \ }
-
-  for [lang, syn] in items(syntaxes)
-    unlet b:current_syntax
-    silent! exec printf("syntax include @%s %s", lang, syn)
-    exec printf("syntax region %sSnip matchgroup=Snip start='```%s' end='```' contains=@%s",
-                \ lang, lang, lang)
-  endfor
-  let b:current_syntax='mkd'
-
-  syntax sync fromstart
-endfunction
-
-silent! unlet g:easy_align_delimiters
-silent! unlet g:easy_align_ignore_unmatched
-silent! unlet g:easy_align_ignores
-
-vnoremap <silent> <Enter> :EasyAlign<cr>
-
-noremap  <silent> <C-k> <nop>
-noremap  <silent> <C-j> <nop>
-noremap  <silent> <C-h> <nop>
-noremap  <silent> <C-l> <nop>
-vnoremap <silent> <C-k> <nop>
-vnoremap <silent> <C-j> <nop>
-vnoremap <silent> <C-h> <nop>
-vnoremap <silent> <C-l> <nop>
-
-set nolazyredraw
-set buftype=nofile
-
-silent! ScrollPositionHide
-
-call GFM()
-
--- a/test/interactive.vader
+++ b/test/interactive.vader
--- a/test/regexp.expected
+++ b/test/regexp.expected
@@ -1,96 +0,0 @@
-" :source run.vim
-" @a
-
-apple;:banana  :: cake
-data;;exchange :; format
-
-apple ;: banana   ::   cake
- data ;; exchange :; format
-
-apple ;:   banana :: cake
-data  ;; exchange :; format
-
-apple ;:____banana::cake
-data  ;;____exchange:;format
-
-apple ;  : banana   :  : cake
-data  ;  ; exchange :  ; format
-
-ap  pl  e;  :b  an  an  a:  :c  ak e
-da  ta  ;;  ex  ch  an  ge  :;  fo  rm  at
-
-ap ple;:banana::cake
-da ta;;exchange:;format
-
-apple???;:~~~banana???::~~~  cake
-data???;;~~~ exchange???:;~~~format
-
-apple;: banana::cake
-data;;  exchange:;format
-
-apple<<<;:>>>banana::cake
-data <<<;;>>>exchange:;format
-
-apple ;: banana::cake
-data  ;; exchange:;format
-
-apple;:banana  :: cake
-data;;exchange :; format
-
-apple ;: banana   :: cake
-data  ;; exchange :; format
-
-apple ;: banana   :: cake
-data  ;; exchange :; format
-
-apple ;: banana   :: cake
-data  ;; exchange :; format
-
-apple ;: banana   :: cake
-data  ;; exchange :; format
-
-apple ;: banana::cake
-data  ;; exchange:;format
-
-apple ; :banana::cake
-data  ;  ; exchange: ; format
-
-apple ; :banana::cake
-data  ; ;exchange:;format
-
-apple ; :banana::cake
-data  ; ;exchange:;format
-
-apple;:banana::cake
-data;;exchange:;format
-
-apple;:         banana: : cake
-data;;exchange: ;format
-
-apple;:banana: :cake
-data;;exchange:;format
-
-apple;:banana: :cake
-data;;exchange:;format
-
-apple;:         banana: : cake
-data;;exchange: ;format
-
-apple;:banana:: cake
-data;;exchange: ;format
-
-apple;:         banana: : cake
-data;;exchange: ;format
-
-apple;:         banana::cake
-data;;exchange: ;format
-
-```ruby
-apple = 1                # comment not aligned
-apricot = 'DAD' + 'F#AD'
-banana = 'Gros Michel'   # comment 2
-```
-
-a()p()p()l()e();():()b()a()n()a()n()a():():()c()a()k()e
-d()a()t()a();();()e()x()c()h()a()n()g()e():();()f()o()r()m()a()t
-
--- a/test/regexp.md
+++ b/test/regexp.md
@@ -1,12 +0,0 @@
-" :source run.vim
-" @a
-
-apple;:banana::cake
-data;;exchange:;format
-
-```ruby
-apple = 1 # comment not aligned
-apricot = 'DAD' + 'F#AD'
-banana = 'Gros Michel' # comment 2
-```
-
--- a/test/regexp.script
+++ b/test/regexp.script
@@ -1 +0,0 @@
-4Gvipjyvip:EasyAlign:
--- a/test/run.vim
+++ b/test/run.vim
@@ -1,7 +0,0 @@
-e!
-execute 'source '. expand('%:p:h') . '/include.vim'
-
-normal gg
-let @b=system('cat '. expand('%:p:r') . '.script')
-let @a='@b:vert diffsplit ' . expand('%:p:r') . '.expected
-'
--- a/test/tex.vader
+++ b/test/tex.vader
@@ -0,0 +1,161 @@
+# 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
+
+Given tex (table with escaped &):
+  \begin{tabular}{ l c r }
+    1&2&3\\
+    44&55&66\\
+    777&8\&8&999\\
+  \end{tabular}
+
+# FIXME vip doesn't work if folded
+Do (Align around all &s and \\s):
+  VG\<Enter>*&
+
+Expect tex:
+  \begin{tabular}{ l c r }
+    1   & 2    & 3   \\
+    44  & 55   & 66  \\
+    777 & 8\&8 & 999 \\
+  \end{tabular}
+
+Do (right-align with explicit ignore_unmatched):
+  VG\<Enter>\<Enter>\<C-U>\<C-U>*&
+
+Expect tex:
+  \begin{tabular}{ l c r }
+      1 &    2 &   3 \\
+     44 &   55 &  66 \\
+    777 & 8\&8 & 999 \\
+  \end{tabular}
+
+Do (center-align with explicit ignore_unmatched):
+  VG\<Enter>\<Enter>\<Enter>\<C-U>\<C-U>*&
+
+Expect tex:
+  \begin{tabular}{ l c r }
+     1  &  2   &  3  \\
+    44  &  55  & 66  \\
+    777 & 8\&8 & 999 \\
+  \end{tabular}
+
+Given tex (simple table with \hline):
+  \begin{tabular}{ l c r }
+    1&2&3\\ \hline
+    44&55&66\\ \hline
+    777&8\&&999\\ \hline
+  \end{tabular}
+
+Do:
+  VG\<Enter>*&
+
+Expect tex:
+  \begin{tabular}{ l c r }
+    1   & 2   & 3   \\ \hline
+    44  & 55  & 66  \\ \hline
+    777 & 8\& & 999 \\ \hline
+  \end{tabular}
+
+Given tex (table with lines w/o &s):
+  \begin{tabular}{|r|l|}
+    \hline
+    7C0 & hexadecimal \\
+    3700&octal \\ \cline{2-2}
+    1111100000 & binary \\
+    \hline \hline
+    1984 & decimal \\
+    \hline
+  \end{tabular}
+
+Do (left-align*):
+  VG\<Enter>*&
+
+Expect tex:
+  \begin{tabular}{|r|l|}
+    \hline
+    7C0        & hexadecimal \\
+    3700       & octal       \\ \cline{2-2}
+    1111100000 & binary      \\
+    \hline \hline
+    1984       & decimal     \\
+    \hline
+  \end{tabular}
+
+Do(left-align* and right-align around 2nd):
+  VG\<Enter>*&
+  gv\<Enter>\<Enter>2&
+
+Expect tex:
+  \begin{tabular}{|r|l|}
+    \hline
+    7C0        & hexadecimal \\
+    3700       &       octal \\ \cline{2-2}
+    1111100000 &      binary \\
+    \hline \hline
+    1984       &     decimal \\
+    \hline
+  \end{tabular}
+
+Given tex:
+  \begin{tabular}{}
+    32&1.14\e1&&5.65\e2&&&&1.16\e1&&1.28\e1&\\
+    64&1.03\e1&0.1&4.98\e2&0.2&&&9.21\e2&0.3&1.02\e1&0.3\\
+    128&9.86\e2&0.1&4.69\e2&0.1&&&8.46\e2&0.1&9.45\e2&0.1\\
+    256&9.65\e2&0.0&4.59\e2&0.0&&&8.15\e2&0.1&9.11\e2&0.1\\
+  % 512&9.55\e2&0.0&4.56\e2&0.0&&&8.01\e2&0.0&8.96\e2&0.0\\
+    1024&9.49\e2&0.0&4.53\e2&0.0&&&7.94\e2&0.0&8.89\e2&0.0\\
+    2048&9.47\e2&0.0&4.52\e2&0.0&&&7.91\e2&0.0&8.85\e2&0.0\\
+    4096&9.46\e2&0.0&4.51\e2&0.0%&&&7.90\e2&0.0&8.83\e2&0.0\\
+    8192&9.45\e2&0.0&4.51\e2&0.0&&&&&&\\
+  \end{tabular}
+
+Execute (Alignment around &s, foldmethod should not change):
+  setlocal foldmethod=syntax
+  %EasyAlign*&
+  AssertEqual 'syntax', &l:foldmethod
+
+  setlocal foldmethod=manual
+  %EasyAlign*&
+  AssertEqual 'manual', &l:foldmethod
+
+Expect tex:
+  \begin{tabular}{}
+    32   & 1.14\e1 &     & 5.65\e2 &     &  &  & 1.16\e1 &     & 1.28\e1 &     \\
+    64   & 1.03\e1 & 0.1 & 4.98\e2 & 0.2 &  &  & 9.21\e2 & 0.3 & 1.02\e1 & 0.3 \\
+    128  & 9.86\e2 & 0.1 & 4.69\e2 & 0.1 &  &  & 8.46\e2 & 0.1 & 9.45\e2 & 0.1 \\
+    256  & 9.65\e2 & 0.0 & 4.59\e2 & 0.0 &  &  & 8.15\e2 & 0.1 & 9.11\e2 & 0.1 \\
+  % 512&9.55\e2&0.0&4.56\e2&0.0&&&8.01\e2&0.0&8.96\e2&0.0\\
+    1024 & 9.49\e2 & 0.0 & 4.53\e2 & 0.0 &  &  & 7.94\e2 & 0.0 & 8.89\e2 & 0.0 \\
+    2048 & 9.47\e2 & 0.0 & 4.52\e2 & 0.0 &  &  & 7.91\e2 & 0.0 & 8.85\e2 & 0.0 \\
+    4096 & 9.46\e2 & 0.0 & 4.51\e2 & 0.0%&&&7.90\e2&0.0&8.83\e2&0.0\\
+    8192 & 9.45\e2 & 0.0 & 4.51\e2 & 0.0 &  &  &         &     &         &     \\
+  \end{tabular}
+
+Execute (g:easy_align_bypass_fold set, foldmethod should not change):
+  let g:easy_align_bypass_fold = 1
+  setlocal foldmethod=syntax
+  %EasyAlign*&
+  AssertEqual 'syntax', &l:foldmethod
+
+  setlocal foldmethod=manual
+  %EasyAlign*&
+  AssertEqual 'manual', &l:foldmethod
+
+Expect tex:
+  \begin{tabular}{}
+    32   & 1.14\e1 &     & 5.65\e2 &     &  &  & 1.16\e1 &     & 1.28\e1 &     \\
+    64   & 1.03\e1 & 0.1 & 4.98\e2 & 0.2 &  &  & 9.21\e2 & 0.3 & 1.02\e1 & 0.3 \\
+    128  & 9.86\e2 & 0.1 & 4.69\e2 & 0.1 &  &  & 8.46\e2 & 0.1 & 9.45\e2 & 0.1 \\
+    256  & 9.65\e2 & 0.0 & 4.59\e2 & 0.0 &  &  & 8.15\e2 & 0.1 & 9.11\e2 & 0.1 \\
+  % 512&9.55\e2&0.0&4.56\e2&0.0&&&8.01\e2&0.0&8.96\e2&0.0\\
+    1024 & 9.49\e2 & 0.0 & 4.53\e2 & 0.0 &  &  & 7.94\e2 & 0.0 & 8.89\e2 & 0.0 \\
+    2048 & 9.47\e2 & 0.0 & 4.52\e2 & 0.0 &  &  & 7.91\e2 & 0.0 & 8.85\e2 & 0.0 \\
+    4096 & 9.46\e2 & 0.0 & 4.51\e2 & 0.0%&&&7.90\e2&0.0&8.83\e2&0.0\\
+    8192 & 9.45\e2 & 0.0 & 4.51\e2 & 0.0 &  &  &         &     &         &     \\
+  \end{tabular}
+
+Execute:
+  Restore
Author	SHA1	Message	Date
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
Junegunn Choi	2daae46a43	Fix `indentation` option to work with hard tabs (#19 )	2013-10-31 12:32:07 +09:00
Junegunn Choi	2b119f9bb6	Fix issue #19 (hard tab indentation)	2013-10-31 11:08:02 +09:00
Junegunn Choi	15bcbc9499	Update readme	2013-10-29 23:24:14 +09:00
Junegunn Choi	54e6b5d866	Update screenshot	2013-10-29 22:17:23 +09:00
Junegunn Choi	1f28ce346e	Update README	2013-10-27 03:14:40 +09:00
Junegunn Choi	2832a76cea	Implement filter option (#16 , #17 ) This commit implements filter option which can be used to filter lines within the range based on the given pattern. The value of filter option should be either `g/pattern/` or `v/pattern/`. The former aligns lines that match the pattern, the latter aligns lines that do not match the pattern.	2013-10-27 03:10:04 +09:00
Junegunn Choi	1a232ac19b	Revert "Make user confirm regular expression on live interactive mode" This reverts commit `a76cfdb8ae`.	2013-10-25 02:17:52 +09:00
Junegunn Choi	a76cfdb8ae	Make user confirm regular expression on live interactive mode	2013-10-25 02:11:43 +09:00
Junegunn Choi	c3a7842b0d	Remove a redundant Expect block	2013-10-22 11:24:46 +09:00
Junegunn Choi	3cc564bd68	Do not attach margin_left string before phantom token	2013-10-19 19:49:11 +09:00
Junegunn Choi	6e2264672a	Implement live interactive mode (#15 ) This commit adds LiveEasyAlign command. (The name was chosen not to introduce ambiguity when typing in only the prefix of the command: e.g. `:EasyA*\|`) In live interactive mode, the selected text is aligned on-the-fly as the user type in. In order to finalize the alignment, the user has to type in the same delimiter key again. (Or CTRL-X on regular expressions)	2013-10-19 19:21:23 +09:00
Junegunn Choi	bec3e94383	Log g:easy_align_last_command	2013-10-18 18:05:52 +09:00
Junegunn Choi	7f0fccba0b	Update README	2013-10-15 23:08:16 +09:00
Junegunn Choi	aa62ca4603	Update documentation	2013-10-15 23:07:14 +09:00
Junegunn Choi	831cecdaf2	Implement g:easy_align_bypass_fold switch (#14 ) with a small fix	2013-10-15 23:00:43 +09:00
Junegunn Choi	37fa908d04	Remove s:max function Sadly function calls are rather slow in Vimscript. Test shows that this commit reduces the response time by 10%.	2013-10-13 12:16:58 +09:00
Junegunn Choi	256e5b83ab	Remove recursion not to fail in case of many delimiters (> maxfuncdepth)	2013-10-13 03:31:05 +09:00
Junegunn Choi	cb7306341c	Use function() instead of a forwarding function	2013-10-13 02:10:33 +09:00
Junegunn Choi	7b82a1e496	Fix: right margin sometimes not attached in partial alignment	2013-10-13 02:09:06 +09:00
Junegunn Choi	ad2df21039	Add alignment rule for LaTeX tables (#13 )	2013-10-10 22:15:23 +09:00
Junegunn Choi	4c2808d13c	Relocate operator section	2013-10-10 16:04:48 +09:00
Junegunn Choi	124654ec46	Update test doc	2013-10-10 12:58:27 +09:00
Junegunn Choi	ab4b72addf	Update README	2013-10-10 12:55:00 +09:00
Junegunn Choi	cdc648f5a4	EasyAlign command as Vim operator	2013-10-10 12:51:43 +09:00
Junegunn Choi	438b5312ee	Thoroughly tested	2013-10-10 00:33:32 +09:00
Junegunn Choi	e24f8479a5	Fix invalid test case	2013-10-10 00:19:54 +09:00
Junegunn Choi	9d626dd765	Add test cases for ignore_unmatched behavior	2013-10-10 00:18:52 +09:00
Junegunn Choi	7490aa61d7	Merge pull request #12 from junegunn/vader Testing with Vader.vim	2013-10-09 08:06:51 -07:00
Junegunn Choi	aa42666f10	Remove recording-based test for interactive mode	2013-10-10 00:03:21 +09:00
Junegunn Choi	9951cad2d0	Rename README	2013-10-09 22:18:38 +09:00
Junegunn Choi	cb5041ba67	Merge branch 'master' into vader	2013-10-09 22:18:20 +09:00
Junegunn Choi	7019edb08c	More test cases on Vader	2013-10-09 22:11:03 +09:00
Junegunn Choi	247f69bf3f	Migrate more test cases to Vader	2013-10-09 20:39:17 +09:00
Junegunn Choi	133588b181	Testing with Vader.vim	2013-10-09 20:16:58 +09:00
Junegunn Choi	fb8cf1d54a	Update doc	2013-10-08 10:59:17 +09:00
Junegunn Choi	013fb54dd1	Update documentation	2013-10-07 21:13:17 +09:00
Junegunn Choi	2bf1b2164d	Allow shorthand option notation when using delimiter key e.g. :EasyAlign=l2r2dlmlr**	2013-10-07 21:09:37 +09:00
Junegunn Choi	bab23a1917	Update documentation	2013-10-05 15:55:22 +09:00
Junegunn Choi	fa26fd7b42	Remove option value after every cycle	2013-10-05 15:27:50 +09:00
Junegunn Choi	a4a1e27395	Apply ignore_unmatched option on R/C mode if explicitly set By default, unmatched trailing token from each line is also aligned in right and center alignment modes unlike in left alignment mode. If ignore_unmatched option is explicitly set to 1 by user, they will be ignored even in right/center modes.	2013-10-05 12:23:44 +09:00
Junegunn Choi	98bd9fe6f0	Shorthand notation for ignore_groups/ignore_unmatched e.g. ig['String']iu0	2013-10-04 02:29:24 +09:00
Junegunn Choi	f944f5bf29	Set g:easy_align_last_command	2013-10-04 02:07:35 +09:00
Junegunn Choi	484b4ba5ec	Update doc	2013-10-04 01:50:43 +09:00
Junegunn Choi	9d3afa6206	Merge option values in dictionary and shortcut expression	2013-10-04 01:36:55 +09:00
Junegunn Choi	4c6a8c174d	Implement shortcut expression for options	2013-10-03 21:59:51 +09:00
Junegunn Choi	3304f4e95a	Make <Down> set both left and right margin to zero (Undocumented) <Up> will clear UP left_margin, right_margin, and stick_to_left	2013-10-03 16:06:23 +09:00
Junegunn Choi	e4f86274e3	Update install instructions	2013-09-22 23:04:20 +09:00
Junegunn Choi	2d575bcc25	Underscore between parens	2013-09-22 22:56:27 +09:00
Junegunn Choi	8a783c2125	Fix a failure in test due to change in interactive mode	2013-09-22 22:21:23 +09:00
Junegunn Choi	5230a2402f	Disallow 0 as the first character of `N-th`	2013-09-22 21:58:31 +09:00
Junegunn Choi	94a750e03e	Remove unnecessary prev output wipe	2013-09-22 21:48:14 +09:00
Junegunn Choi	afc95b5ed7	Forgiving interactive mode: Do not terminate on invalid input	2013-09-22 21:17:02 +09:00
Junegunn Choi	1d2c58c06a	Field index -> N-th parameter	2013-09-22 03:52:36 +09:00
Junegunn Choi	4cdc450126	Update DEMO.md	2013-09-21 23:53:47 +09:00
Junegunn Choi	7e1be152dc	Add DEMO.md	2013-09-21 15:46:40 +09:00
Junegunn Choi	c61a11d150	Update doc - Field number -> Field index	2013-09-21 13:08:55 +09:00
Junegunn Choi	2797baca6c	Disallow non-printable character input	2013-09-21 12:04:56 +09:00
Junegunn Choi	663264ed39	Fix center-alignment = = eee = eee = f = = gg &&= gg = = fff = = eee = eee = f = = gg &&= gg = = f f	2013-09-21 03:31:34 +09:00
Junegunn Choi	df75520f72	Colored, replayable output	2013-09-21 03:11:20 +09:00
Junegunn Choi	a2d52611ee	Fix invalid type conversion	2013-09-20 23:19:32 +09:00
Junegunn Choi	fce0a103ff	Use try-finally for reverting the setup	2013-09-19 17:27:26 +09:00
Junegunn Choi	1752bf567b	Improve message output - Error message highlighting - Wipe previous message if needed - No line wrap on narrow terminal	2013-09-19 17:10:00 +09:00
Junegunn Choi	003194a47f	Update example command sequences	2013-09-18 16:18:03 +09:00
Junegunn Choi	c1c6f32e8c	Update example command sequence	2013-09-18 15:50:19 +09:00
Junegunn Choi	71edb17182	Update help file	2013-09-17 23:36:58 +09:00
Junegunn Choi	8951e13cf8	Update documentation	2013-09-17 23:32:41 +09:00
Junegunn Choi	a998aee45d	Update README.md	2013-09-17 15:57:41 +09:00
Junegunn Choi	912bf6ca93	Update README.md	2013-09-17 15:54:33 +09:00
Junegunn Choi	9cf4fde00c	Use number as margins (same effect, but easier to read)	2013-09-17 03:12:30 +09:00
Junegunn Choi	5f5cd49e95	Update README.md	2013-09-17 03:05:43 +09:00
Junegunn Choi	639ade715b	Wording	2013-09-15 19:59:36 +09:00
Junegunn Choi	a1f2a697a5	Update README	2013-09-15 19:49:26 +09:00
Junegunn Choi	0fb127cee6	Update doc	2013-09-15 01:28:42 +09:00
Junegunn Choi	d3803b927d	Heuristically determine if the user was in visual mode	2013-09-14 23:15:03 +09:00
Junegunn Choi	40a06e3d36	Left arrow key will also set left_margin to zero - Right arrow key will set left_margin to one - Up and Down arrow will clear the values of stick_to_left and left_margin	2013-09-14 17:30:51 +09:00
Junegunn Choi	11e0623959	DASH, not LI	2013-09-14 17:23:08 +09:00
Junegunn Choi	e9b6418280	Concept of alignment rule	2013-09-14 17:20:14 +09:00
Junegunn Choi	9f9d18ca71	Fix #8 , #9 , and #10 . - <Left> and <Right> key to toggle stick_to_left option - <CTRL-X> in addition to <CTRL-/> to take regular expression - Retain visual selection display on <CTRL-O/L/R/X>	2013-09-14 12:31:01 +09:00
Junegunn Choi	301bdbcfc7	Regular expression in interactive mode (#8 )	2013-09-14 00:40:16 +09:00
Junegunn Choi	56e498a57d	Implement mode_sequence expansion (#7 )	2013-09-14 00:05:08 +09:00
Junegunn Choi	c0a500728c	Update README	2013-09-13 10:34:16 +09:00
Junegunn Choi	2e0f9a73cd	Update README.md	2013-09-13 10:26:38 +09:00
Junegunn Choi	6cac16dc3d	Include =~# and =~? in = rule (Vimscript)	2013-08-25 23:03:30 +09:00
Junegunn Choi	6b275b8a46	Revert C-style variable definition example	2013-08-23 17:55:35 +09:00
Junegunn Choi	25fec2e955	Implement stick_to_left in center-alignment mode	2013-08-23 17:47:03 +09:00
Junegunn Choi	01337b9c4e	Include `.=` operator in = rule	2013-08-23 17:40:13 +09:00
Junegunn Choi	0f70b20fdb	Add related work section (#6 )	2013-08-23 13:14:03 +09:00
Junegunn Choi	61be5b3abf	Update doc	2013-08-23 01:37:50 +09:00
Junegunn Choi	2ad49b24f0	Add CTRL-O special key for `mode_sequence` option	2013-08-23 00:09:21 +09:00
Junegunn Choi	5058de6f4c	Retain lm and rm values on CTRL-L and CTRL-R	2013-08-22 23:47:25 +09:00
Junegunn Choi	4c5d6d9e82	Improve center-alignment: ignore leading whitespaces	2013-08-22 23:41:21 +09:00
Junegunn Choi	12c319a8ac	Implement special keys to switch option values in interactive mode With this commit, we can now change option values in interactive mode with the folowing special keys - CTRL-L left_margin - CTRL-R right_margin - CTRL-D delimiter_align - CTRL-I indentation - CTRL-U ignore_unmatched - CTRL-G ignore_groups ('ignores' option has been renamed to 'ignore_groups', but backward-compatible)	2013-08-20 01:38:20 +09:00
Junegunn Choi	62314afcaf	Fix typo	2013-08-19 15:16:19 +09:00
Junegunn Choi	cef26cdef9	Update EXAMPLES	2013-08-19 14:59:35 +09:00
Junegunn Choi	659e2ff513	Update README	2013-08-19 10:57:21 +09:00
Junegunn Choi	481a88f601	Update README	2013-08-19 04:21:02 +09:00
Junegunn Choi	6fb4f57b5a	Add test cases for center-alignment	2013-08-19 04:14:56 +09:00
Junegunn Choi	beb986ebc3	Update documentation	2013-08-19 04:06:36 +09:00
Junegunn Choi	5222db47cf	Rename align_mode to mode_sequence	2013-08-19 02:37:46 +09:00
Junegunn Choi	74003c0297	Allow interactive mode with options	2013-08-19 02:25:38 +09:00
Junegunn Choi	999e1ff68e	Implement center-align mode and align_modes option	2013-08-19 02:09:34 +09:00
Junegunn Choi	11a74c4176	Fix right-justification for lines with different indentation	2013-08-16 23:47:01 +09:00
Junegunn Choi	e7e7a80afb	Update doc	2013-08-16 17:58:05 +09:00
Junegunn Choi	29e5cd1d19	Add the link to slower GIF	2013-08-16 15:03:57 +09:00
Junegunn Choi	5c6558bd1b	Improve right-justification mode With this commit you can right-align the last token with * or field number. For example, the following lines a = 1 bb = 22 ccc = 333 are aligned as follows on `:EasyAlign=` a = 1 bb = 22 ccc = 333 And even if we don't have the second =, we can do `:EasyAlign!2=` to get a = 1 bb = 22 ccc = 333	2013-08-16 13:58:28 +09:00
Junegunn Choi	b6625f6d2b	Fix: Unmatched token incorrectly ignored in right-justification mode	2013-08-16 09:37:04 +09:00
Junegunn Choi	d4277a0298	Fix a typo	2013-08-16 03:12:36 +09:00
Junegunn Choi	d31e6ed257	Update README	2013-08-16 02:37:24 +09:00
Junegunn Choi	1e2af43a64	Ignore unmatched line on right-justification mode Unmatched line is NOT ignored on right-justification mode. However this commit makes such a line ignored when the end of the line is highlighted as one of the ignored syntax groups (e.g. Comments or Strings)	2013-08-16 02:23:00 +09:00
Junegunn Choi	0fb997d5ab	Add g:easy_align_indentation. Add `n` indentation option.	2013-08-16 01:38:50 +09:00
Junegunn Choi	90a5487974	Add `indentation` option	2013-08-16 00:15:57 +09:00